def test_contender_add_to_multiple_Rumbles(): rumble_a = rumble.Rumble() rumble_b = rumble.Rumble() @rumble_a.contender @rumble_b.contender def foo(): pass assert rumble_a._functions == [foo] assert rumble_b._functions == [foo]
def test_named_argument_string(): r = rumble.Rumble() args, setup, name = 'args', 'setup', 'name' r.arguments_string(args, _setup=setup, _name=name) assert r._args_setups[0].args == args assert r._args_setups[0].setup == setup assert r._args_setups[0].name == name
def mock_three_results(): data = (Result(name='foo', timingreport=TimingReport(best=0.6152389320013754, number=1000000, repeat=3)), Result(name='bar', timingreport=TimingReport(best=10.568919159995858, number=100000, repeat=3)), Result(name='baz', timingreport=TimingReport(best=0.8228213680013141, number=1000000, repeat=3))) expected = ("args: 'test' usec loops best of\n" '-------------- ------ ------- ---------\n' 'foo 0.62 1000000 3\n' 'bar 10.57 100000 3\n' 'baz 0.82 1000000 3\n\n') r = rumble.Rumble() r._get_results = Mock(return_value=data) for _ in range(len(data)): r.contender(lambda: None) return dict(rumble=r, expected=expected, data=data)
def test_prepared_setup_string_result(): r = rumble.Rumble() setup_string = 'nonce' expected = ('from rumble.rumble ' 'import _rumble_current_function\n' '{0}').format(setup_string) assert r._prepared_setup(setup_string, lambda: None) == expected
def test_run_setup_and_func_with_args_calls_adaptiverun(monkeypatch): r = rumble.Rumble() r._prepared_setup = Mock() m = Mock() monkeypatch.setattr(rumble, 'adaptiverun', m) setup, func = Mock(), Mock() r._run_setup_and_func_with_args(setup, func, None) assert rumble.adaptiverun.call_count == 1
def test_calling_report_function_with_default_name(): r = rumble.Rumble() r.arguments(1, 2, 3) r.contender(lambda x: None) r._get_results = Mock(return_value=()) m = Mock(return_value='') r.run(report_function=m) assert m.called_with(title='args: 1, 2, 3')
def test_contender_length(): for n in (1, 2, 3, 7, 42, 85): r = rumble.Rumble() for _ in range(n): @r.contender def foo(): pass assert len(r._functions) == n
def test_get_results_functions_order(monkeypatch): monkeypatch.setattr(rumble, 'adaptiverun', Mock()) r = rumble.Rumble() funcs = [MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()] for i, f in enumerate(funcs): f.__name__ = str(i) r.contender(f) expected = [f.__name__ for f in funcs] assert [res.name for res in r._get_results('pass', 'pass')] == expected
def test_run_setup_and_func_with_args_called_times(monkeypatch): r = rumble.Rumble() r._run_setup_and_func_with_args = Mock() monkeypatch.setattr(rumble, 'adaptiverun', Mock()) for func in (None for _ in range(4)): r.contender(func) setup, func = Mock(), Mock() r._get_results(setup, None) assert r._run_setup_and_func_with_args.call_count == 4
def test_calling_report_function_with_specified_name(): r = rumble.Rumble() name = 'test' r.arguments(1, 2, 3, _name=name) r.contender(lambda x: None) r._get_results = Mock(return_value=()) m = Mock(return_value='') r.run(report_function=m) assert m.called_with(title=name)
def test_prepared_setup_callable_calls_setup_and_sets_current_function(): setup, func = Mock(), object() prepped = rumble.Rumble()._prepared_setup(setup, func) prepped() assert rumble._rumble_current_function is func assert setup.call_count == 1 # teardown del rumble._rumble_current_function
def test_run_calls_report_function_times(capsys, mock_three_results): for n in (1, 2, 10, 500): r = rumble.Rumble() r._get_results = Mock(return_value=mock_three_results['data']) r.contender(None) for x in range(n): r.arguments(x) report_function = Mock(return_value='') r.run(report_function=report_function) assert report_function.call_count == n
def test_get_results_called_with_args_setups(): r = rumble.Rumble() r._get_results = Mock(return_value=()) a_s = tuple( ArgsAndSetup(args=Mock(), setup=Mock(), name=Mock()) for _ in range(3)) r._args_setups = a_s r.run(report_function=Mock(return_value='')) assert r._get_results.call_count == len(a_s) for actual, expected in zip(r._get_results.call_args_list, a_s): assert actual == call(expected.args, expected.setup)
def test_run_setup_and_func_with_args_called_times(monkeypatch): monkeypatch.setattr(rumble, 'adaptiverun', Mock()) for n in (0, 1, 2, 10, 100): r = rumble.Rumble() r._run_setup_and_func_with_args = Mock() for func in (lambda x: None for _ in range(n)): func.__name__ = 'foo' r.contender(func) setup, func = Mock(), Mock() result = r._get_results(setup, None) assert len(tuple(r._get_results(setup, None))) == n
def test_contender_values(): r = rumble.Rumble() @r.contender def foo(): pass @r.contender def bar(): pass @r.contender def baz(): pass assert r._functions == [foo, bar, baz]
def test_setup_error_on_invalid_type(): r = rumble.Rumble() with pytest.raises(ValueError): r.arguments(None, _setup=7)
def test_prepared_setup_callable_result_is_callable(): r = rumble.Rumble() assert callable(r._prepared_setup(lambda: None, None))
def test_arguments_invalid_input(): r = rumble.Rumble() with pytest.raises(ValueError): r.arguments(lambda x: None)
def test_arguments_setup(): r = rumble.Rumble() setups = ['import foo', 'import bar', 'import baz'] for s in setups: r.arguments('', _setup=s) assert [x.setup for x in r._args_setups] == setups
def test_arguments_values(): r = rumble.Rumble() args = ['foo', {'a': 1, 'b': 2}, 19] for a in args: r.arguments(a) assert [x.args for x in r._args_setups] == list(map(repr, args))
def test_adding_arguments_with_name(): r = rumble.Rumble() name = 'lol' r.arguments(1, 2, 3, _name=name) assert r._args_setups[0].name == name
def test_adding_arguments_with_no_name(): r = rumble.Rumble() r.arguments(1, 2, 3) assert r._args_setups[0].name == None
def test_named_argument_string_default_args(): r = rumble.Rumble() args = 'args' r.arguments_string(args) assert r._args_setups[0].setup == 'pass' assert r._args_setups[0].name == None
def test_arguments_setup_default(): r = rumble.Rumble() args = ['foo', 'bar'] for a in args: r.arguments(a) assert [x.setup for x in r._args_setups] == ['pass', 'pass']
def test_arguments_string(): r = rumble.Rumble() r.arguments_string('test', _setup='test2') assert r._args_setups[0].args == 'test' assert r._args_setups[0].setup == 'test2' assert len(r._args_setups) == 1
from functools import wraps from rumble import rumble fib_timer = rumble.Rumble() for x in [3, 9, 17]: fib_timer.arguments(x) def memoize(f): '''memoizer for single-argument functions''' _cache = {} @wraps(f) def wrapper(x): try: return _cache[x] except KeyError: _cache[x] = f(x) return _cache[x] return wrapper @fib_timer.contender def recursive(n): if n == 0: return 0 if n in (1, 2): return 1 return recursive(n - 1) + recursive(n - 2)
def test_error_on_invalid_setup(): setup = {'invalid': 'setup'} with pytest.raises(ValueError): rumble.Rumble()._prepared_setup(setup, lambda: None)
from functools import wraps from rumble import rumble r = rumble.Rumble() r.arguments(10, 100, _name='easy: 10 and 100') r.arguments(8000, 92833, _name='medium: 8000 and 92833') r.arguments(898989, 1000000000001, _name='hard: 898989 and 1000000000001') @r.contender def divide(a, b): while b != 0: a, b = b, a % b return a @r.contender def subtract(a, b): while a != b: if a > b: a -= b else: b -= a return a @r.contender def recurse(a, b): if b == 0:
def test_arguments_args_length(): for n in (1, 2, 3, 7, 39, 99): r = rumble.Rumble() for _ in range(n): r.arguments('') assert len(r._args_setups) == n