def test_summary(self):
def assert_sum_code(c):
code, _ = t.summary()
self.assertEqual(code, c)
t = Test(list, operation=True)
assert_sum_code(t.EXIT_EMPTY)
t.add_case(Case('append', [1], 'pop', Result(1)))
t.run()
assert_sum_code(t.EXIT_PASS)
t.add_case(Case('pop', Result(None)))
# assert_sum_code(t.EXIT_PENDING)
with self.assertRaises(IndexError):
t.run()
assert_sum_code(t.EXIT_FAIL)
t.add_case(Case('append', [1], Result(None)))
# assert_sum_code(t.EXIT_PENDING)
t.run()
assert_sum_code(t.EXIT_FAIL)
def f(i):
if i == 0:
return Case('append', [1], Result(None))
raise ValueError
t.add_func(f)
with self.assertRaises(ValueError):
t.run()
assert_sum_code(t.EXIT_GEN_ERR)
def test__initialize(self):
with self.assertRaisesRegexp(RuntimeError,
r'target.*specified.*neither'):
Case('append', Result(1), operation=True)._initialize()
with self.assertRaisesRegexp(RuntimeError, r'both'):
Case('append', Result(1), result=1, target=nop)._initialize()
with self.assertRaisesRegexp(RuntimeError, r'both'):
Case('append', Result(2), operation=True, result=None,
target=nop)._initialize()
Case('append', result=1, target=nop)._initialize()
with self.assertRaisesRegexp(RuntimeError, r'object.*not specified'):
Case('append', operation=True, target=nop)._initialize()
with self.assertRaisesRegexp(RuntimeError, r'result.*not specified'):
Case('append', target=nop)._initialize()
Case('append', Result(2), operation=True, target=nop)._initialize()
with self.assertRaisesRegexp(RuntimeError,
r'keyword.*target.*operation is True'):
Case('append', operation=True, result=None,
target=nop)._initialize()
Case('append', operation=True, result=list, target=nop)._initialize()
with self.assertRaises(AttributeError):
Case('a', operation=True, result=list, target=nop)._initialize()
with self.assertRaisesRegexp(RuntimeError, r'object.*not accepted'):
Case('append', Result(2), target=nop)._initialize()
def test_check_result(self):
t = Test(list, operation=True)
t.add_case(
Case('append', [1], 'pop', Result(1), 'append', [2], 'append', [3],
'pop', 'pop', Result(2)))
t.add_case(
Case('append', [1],
'pop',
'append', [2],
'append', [3],
'pop',
'pop',
result=list))
t.run()
def _make_case(root):
operations = []
# Constructor arguments
operations.append([root])
# Methods names and asserted results
if root is not None:
for val in root.inorder():
operations.extend(
['hasNext', Result(True), 'next',
Result(val)])
operations.extend(['hasNext', Result(False)])
return Case(*operations)
def r(i):
ops = []
nums = randints(max(1, i), max_num=75)
tmp_nums = []
for num in nums:
tmp_nums.append(num)
tmp_nums.sort()
if len(tmp_nums) % 2 == 1:
median = tmp_nums[len(tmp_nums) // 2]
else:
median = float(tmp_nums[len(tmp_nums) // 2] +
tmp_nums[len(tmp_nums) // 2 - 1]) / 2
ops.extend(['addNum', [num], 'findMedian', Result(median)])
return Case(*ops)
def test_process_args(self):
c = Case()
res = c.process_args([1, 2, 3], False)
self.assertEqual(res, Operations((),
[Operation(None, [1, 2, 3], True)]))
res = c.process_args([['a', 2, 'c'], 'push', [1, 2, 3], 'pop',
Result(1), 'count', 'count', 'pop',
Result('d'), 'push', [[4, 5]],
Result([0]), 'len'], True)
self.assertEqual(
res,
Operations(('a', 2, 'c'), [
Operation('push', [1, 2, 3], False),
Operation('pop', collect=True),
Operation('count'),
Operation('count'),
Operation('pop', collect=True),
Operation('push', [[4, 5]], True),
Operation('len'),
]))
STRS = [
([], r'no args were specified'),
([[1, 2, 3], []], r'expected.*, got \[\]'),
([[1, 2, 3], 'a', [], [1]], r'expected.*, got \[1\]'),
(['a', Result(1), Result(2)], r'expected.*, got Result\(2\)'),
([
Result(1),
], r'got Result\(1\)'),
([[1, 2, 3], Result(1)], r'got Result\(1\)'),
(['1', Result('b'), [1]], r'got \[1\]'),
]
for args, pat in STRS:
with self.assertRaisesRegexp(ValueError, pat):
c.process_args(args, True)
with self.assertRaisesRegexp(ValueError, r'no args'):
c.process_args([], True)
with self.assertRaisesRegexp(ValueError, r'no method call'):
c.process_args([[]], True)
from __future__ import print_function
from rapidtest import Result, Test, Case
from solutions.implement_stack_using_queues import Stack
with Test(Stack, operation=True) as test:
Case('empty', Result(True), 'push', [1], 'empty', Result(False), 'top',
Result(1), 'empty', Result(False), 'pop', Result(1), 'empty',
Result(True), 'push', [2], 'push', [3], 'push', [4], 'push', [5],
'empty', Result(False), 'top', Result(5), 'pop', Result(5), 'empty',
Result(False), 'top', Result(4), 'pop', Result(4), 'empty',
Result(False), 'top', Result(3), 'pop', Result(3), 'empty',
Result(False), 'top', Result(2), 'pop', Result(2), 'empty',
Result(True))
from __future__ import print_function
from rapidtest import Result, Test, Case
from solutions.lru_cache import LRUCache
with Test(LRUCache, operation=True) as test:
Case([4], 'get', [1], Result(-1), 'set', [1, 1], 'set', [2, 2],
'set', [3, 3], 'set', [4, 4], 'get', [1], Result(1), 'get', [2],
Result(2), 'get', [3], Result(3), 'get', [4], Result(4), 'get', [5],
Result(-1), 'get', [1], Result(1), 'set', [5, 5], 'get', [2],
Result(-1), 'get', [1], Result(1), 'set', [6, 6], 'get', [1],
Result(1), 'get', [3], Result(-1))
Case([3], 'set', [1, 1], 'set', [2, 2], 'set', [3, 3], 'set',
[4, 4], 'get', [4], Result(4), 'get', [3], Result(3), 'get', [2],
Result(2), 'get', [1], Result(-1), 'set', [5, 5], 'get', [1],
Result(-1), 'get', [2], Result(2), 'get', [3], Result(3), 'get', [4],
Result(-1), 'get', [5], Result(5))
Case([2], 'set', [2, 1], 'set', [2, 2], 'get', [2], Result(2), 'set',
[1, 1], 'set', [4, 1], 'get', [2], Result(-1))
def f(i):
if i == 0:
return Case('append', [1], Result(None))
raise ValueError
from __future__ import print_function
from rapidtest import Result, Test, Case
from solutions.all_oone_data_structure import AllOne
with Test(AllOne, operation=True) as test:
Case('getMaxKey', Result(''),
'getMinKey', Result(''),
'inc', ['a'],
'getMaxKey', Result('a'),
'getMinKey', Result('a'),
'inc', ['b'],
'inc', ['b'],
'getMaxKey', Result('b'),
'getMinKey', Result('a'),
'dec', ['a'],
'getMaxKey', Result('b'),
'getMinKey', Result('b'),
'dec', ['b'],
'getMaxKey', Result('b'),
'getMinKey', Result('b'),
'dec', ['b'],
'getMaxKey', Result(''),
'getMinKey', Result(''),
'inc', ['a'],
'inc', ['b'],
'inc', ['b'],
'inc', ['c'],
'inc', ['c'],
from __future__ import print_function
from rapidtest import Result, Test, Case, TreeNode
from solutions.binary_search_tree_iterator import BSTIterator
with Test(BSTIterator, operation=True) as test:
root = TreeNode.from_iterable([5, 3, 7, 1, 4, 6, 8, None, 2])
Case([root], 'hasNext', Result(True), 'next', Result(1), 'hasNext',
Result(True), 'next', Result(2), 'hasNext', Result(True), 'next',
Result(3), 'hasNext', Result(True), 'next', Result(4), 'hasNext',
Result(True), 'next', Result(5), 'hasNext', Result(True), 'next',
Result(6), 'hasNext', Result(True), 'next', Result(7), 'hasNext',
Result(True), 'next', Result(8), 'hasNext', Result(False))
@test
def random_case(i):
"""
:param int i: number of times this function is called starting from 0
:return Case:
"""
root = TreeNode.make_random(size=i)
return _make_case(root)
@test(50)
def random_case_with_duplicate_nodes(i):
root = TreeNode.make_random(size=i, duplicate=True)
return _make_case(root)
def _make_case(root):
operations = []
from __future__ import print_function
from rapidtest import Result, Test, Case, randints
from solutions.find_median_from_data_stream import MedianFinder
with Test(MedianFinder, operation=True) as test:
Case('addNum', [1], 'findMedian', Result(1), 'addNum', [1], 'findMedian',
Result(1.0), 'addNum', [2], 'findMedian', Result(1), 'addNum', [2],
'findMedian', Result(1.5), 'addNum', [0], 'findMedian', Result(1))
@test
def r(i):
ops = []
nums = randints(max(1, i), max_num=75)
tmp_nums = []
for num in nums:
tmp_nums.append(num)
tmp_nums.sort()
if len(tmp_nums) % 2 == 1:
median = tmp_nums[len(tmp_nums) // 2]
else:
median = float(tmp_nums[len(tmp_nums) // 2] +
tmp_nums[len(tmp_nums) // 2 - 1]) / 2
ops.extend(['addNum', [num], 'findMedian', Result(median)])
return Case(*ops)