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
