class TestIsSubsequence(unittest.TestCase): def test_simple_input(self): self.assertTrue(is_subsequence([], [])) self.assertFalse(is_subsequence([1, 2], [1, 2, 3])) self.assertFalse(is_subsequence([1, 2, 3], [1, 3])) self.assertTrue(is_subsequence([1, 2, 3], [1, 2])) self.assertTrue(is_subsequence([1, 2, 3], [2, 3])) @given(integers(min_value=20, max_value=ARRAY_LENGTH - 1), random_module()) def test_complex_input_true(self, size, rnd): gen = RandomDatasetGenerator(rnd.seed) l = gen.get_unsorted_list(size) start_idx = random.randint(0, size - 10) end_idx = random.randint(start_idx + 1, size) self.assertTrue(is_subsequence(l, l[start_idx:end_idx])) @given(integers(min_value=50, max_value=ARRAY_LENGTH - 1), random_module()) def test_complex_input_false(self, size, rnd): gen = RandomDatasetGenerator(rnd.seed) l = gen.get_unsorted_list(size) start_idx = random.randint(0, size - 20) end_idx = random.randint(start_idx + 10, size - 1) subseq = l[start_idx:end_idx] subseq[end_idx - start_idx - 1] += 12 self.assertFalse(is_subsequence(l, subseq))
def test_find_does_not_pollute_state(): with deterministic_PRNG(): find(st.random_module(), lambda r: True) state_a = random.getstate() find(st.random_module(), lambda r: True) state_b = random.getstate() assert state_a != state_b
class ThanksViewTestCase(HypothesisTestCase): def get_thanks_response(self, post_dict): post_url = reverse('register:registration') post_dict['agree'] = "True" response = self.client.post(post_url, post_dict) last_candidate = Candidate.objects.last() self.assertEqual(post_dict['first_name'].strip(), last_candidate.first_name) self.assertEqual(post_dict['last_name'].strip(), last_candidate.last_name) identifier = last_candidate.user_registration.identifier url = reverse('register:thanks', kwargs={'user_id': identifier}) self.assertRedirects(response, url) response = self.client.get(url) self.assertContains(response=response, text=escape(last_candidate.first_name), status_code=200) return response @settings(suppress_health_check=[HealthCheck.too_slow]) @given(first_name=name_strategy, last_name=name_strategy, date_of_birth=date_strategy, bicycle_kind=bicycle_kind_strategy, email=email_strategy, dummy=random_module()) def test_email_registration(self, **kwargs): response = self.get_thanks_response(kwargs) self.assertContains(response=response, text='email with a link', status_code=200) self.assertContains(response=response, text='SMS', count=0, status_code=200) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(first_name=name_strategy, last_name=name_strategy, date_of_birth=date_strategy, bicycle_kind=bicycle_kind_strategy, mobile_number=phone_strategy_clean, dummy=random_module()) def test_phone_registration(self, **kwargs): response = self.get_thanks_response(kwargs) self.assertContains(response=response, text='SMS', status_code=200) self.assertContains(response=response, text='email with a link', count=0, status_code=200)
def test_find_does_not_pollute_state(): with deterministic_PRNG(): find(st.random_module(), lambda r: True) state_a = random.getstate() state_a2 = core._hypothesis_global_random.getstate() find(st.random_module(), lambda r: True) state_b = random.getstate() state_b2 = core._hypothesis_global_random.getstate() assert state_a == state_b assert state_a2 != state_b2
class TestAuxiliary(unittest.TestCase): def test_seed(self): ciw.seed(5) a1 = random.expovariate(5) b1 = nprandom.choice([4, 5, 6, 1]) c1 = random.random() ciw.seed(5) a2 = random.expovariate(5) b2 = nprandom.choice([4, 5, 6, 1]) c2 = random.random() self.assertEqual(a1, a2) self.assertEqual(b1, b2) self.assertEqual(c1, c2) @given(choices=lists(integers(min_value=0, max_value=10000), min_size=1, max_size=100), lmbda=floats(min_value=0.0001, max_value=10000), s=integers(min_value=0, max_value=10000), rm=random_module()) def test_seedh(self, choices, lmbda, s, rm): ciw.seed(s) a1 = random.expovariate(lmbda) b1 = nprandom.choice(choices) c1 = random.random() ciw.seed(s) a2 = random.expovariate(lmbda) b2 = nprandom.choice(choices) c2 = random.random() self.assertEqual(a1, a2) self.assertEqual(b1, b2) self.assertEqual(c1, c2)
def matches(draw, strategies=axelrod.strategies, min_turns=1, max_turns=200, min_noise=0, max_noise=1): """ A hypothesis decorator to return a random match as well as a random seed (to ensure reproducibility when instance of class need the random library). Parameters ---------- strategies : list The strategies from which to sample the two the players min_turns : integer The minimum number of turns max_turns : integer The maximum number of turns min_noise : float The minimum noise max_noise : float The maximum noise Returns ------- tuple : a random match as well as a random seed """ seed = draw(random_module()) strategies = draw(strategy_lists(min_size=2, max_size=2)) players = [s() for s in strategies] turns = draw(integers(min_value=min_turns, max_value=max_turns)) noise = draw(floats(min_value=min_noise, max_value=max_noise)) match = axelrod.Match(players, turns=turns, noise=noise) return match, seed
def general_group_test( f: Callable[[Type[jaxlie.MatrixLieGroup]], None], max_examples: int = 100 ) -> Callable[[Type[jaxlie.MatrixLieGroup], Any], None]: """Decorator for defining tests that run on all group types.""" # Disregard unused argument def f_wrapped(Group: Type[jaxlie.MatrixLieGroup], _random_module) -> None: f(Group) # Disable timing check (first run requires JIT tracing and will be slower) f_wrapped = settings(deadline=None)(f_wrapped) # Add _random_module parameter f_wrapped = given(_random_module=st.random_module())(f_wrapped) # Parametrize tests with each group type f_wrapped = pytest.mark.parametrize( "Group", [ jaxlie.SO2, jaxlie.SE2, jaxlie.SO3, jaxlie.SE3, ], )(f_wrapped) return f_wrapped
def get_bnf_string(): bnf_string = hs.builds( write_rule_str, hs.integers(min_value=1, max_value=10), hs.integers(min_value=1, max_value=10), hs.random_module(), ) return bnf_string
def unstable_extension_settings(draw): # Pre-seed random module - we could need it for weighted truth. draw(st.random_module()) settings = draw(valid_settings()) shared = draw(shared_config()) settings.update( draw(unstable_extension_interdependent().filter( valid_interdependent_timeouts(shared)))) return settings
def test_can_seed_random(): with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): @given(st.random_module()) def test(r): assert False test() assert 'random.seed(0)' in out.getvalue()
def test_max_examples_are_respected(): counter = [0] @given(st.random_module(), st.integers()) @settings(max_examples=100) def test(rnd, i): counter[0] += 1 test() assert counter == [100]
def test_can_seed_random(): with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): @given(st.random_module()) def test(r): raise AssertionError test() assert "RandomSeeder(0)" in out.getvalue()
class ModelTestCase(HypothesisTestCase): @settings(suppress_health_check=[HealthCheck.too_slow]) @given(candidate_with_phone, random_module()) def test_phone(self, registration, dummy): self.assertTrue(registration.mobile_number.is_valid()) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(candidate_with_email) def test_email(self, registration): self.assertFalse(registration.mobile_number) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(candidate_with_email_and_phone, random_module()) def test_email_and_phone(self, registration, dummy): if registration.mobile_number: self.assertTrue(registration.mobile_number.is_valid()) @settings(suppress_health_check=[HealthCheck.too_slow]) @given(lists(candidate), random_module()) def test_valid_mobile_number(self, registrations, dummy): self.assertFalse(UserRegistration.objects.count())
def test_nesting_with_control_passes_health_check(): @given(st.integers(0, 100), st.random_module()) @settings(max_examples=5, database=None) def test_blah(x, rnd): @given(st.integers()) @settings( max_examples=100, max_shrinks=0, database=None, verbosity=Verbosity.quiet) def test_nest(y): assert y < x with raises(AssertionError): test_nest() test_blah()
class TestStrategyList(unittest.TestCase): def test_call(self): strategies = strategy_lists().example() self.assertIsInstance(strategies, list) for p in strategies: self.assertIsInstance(p(), axelrod.Player) @given(strategies=strategy_lists(min_size=1, max_size=50), rm=random_module()) @settings(max_examples=10, timeout=0) def test_decorator(self, strategies, rm): self.assertIsInstance(strategies, list) self.assertGreaterEqual(len(strategies), 1) self.assertLessEqual(len(strategies), 50) for strategy in strategies: self.assertIsInstance(strategy(), axelrod.Player) @given(strategies=strategy_lists(strategies=axelrod.basic_strategies), rm=random_module()) @settings(max_examples=10, timeout=0) def test_decorator_with_given_strategies(self, strategies, rm): self.assertIsInstance(strategies, list) basic_player_names = [str(s()) for s in axelrod.basic_strategies] for strategy in strategies: player = strategy() self.assertIsInstance(player, axelrod.Player) self.assertIn(str(player), basic_player_names) @given(strategies=strategy_lists(strategies=stochastic_strategies), rm=random_module()) @settings(max_examples=10, timeout=0) def test_decorator_with_stochastic_strategies(self, strategies, rm): self.assertIsInstance(strategies, list) stochastic_player_names = [str(s()) for s in stochastic_strategies] for strategy in strategies: player = strategy() self.assertIsInstance(player, axelrod.Player) self.assertIn(str(player), stochastic_player_names)
def test_can_eval_stream_inside_find(): @given(st.streaming(st.integers(min_value=0)), st.random_module()) @settings(buffer_size=200, max_shrinks=5, max_examples=10) def test(stream, rnd): x = find(st.lists(st.integers(min_value=0), min_size=10), lambda t: any(t > s for (t, s) in zip(t, stream)), settings=settings(database=None, max_shrinks=2000, max_examples=2000)) note('x: %r' % (x, )) note('Evalled: %r' % (stream, )) assert len([1 for i, v in enumerate(x) if stream[i] < v]) == 1 test()
def test_given_does_not_pollute_state(): with deterministic_PRNG(): @given(st.random_module()) def test(r): pass test() state_a = random.getstate() test() state_b = random.getstate() assert state_a != state_b
def run(data): from hypothesis.control import note with BuildContext(is_final=is_final): seed = data.draw(random_module()).seed if seed != 0: note("random.seed(%d)" % (seed,)) args, kwargs = data.draw(search_strategy) if print_example: report(lambda: "Falsifying example: %s(%s)" % (test.__name__, arg_string(test, args, kwargs))) elif current_verbosity() >= Verbosity.verbose: report(lambda: "Trying example: %s(%s)" % (test.__name__, arg_string(test, args, kwargs))) return test(*args, **kwargs)
def test_nesting_with_control_passes_health_check(): @given(st.integers(0, 100), st.random_module()) @settings(max_examples=5, database=None, deadline=None) def test_blah(x, rnd): @given(st.integers()) @settings( max_examples=100, phases=no_shrink, database=None, verbosity=Verbosity.quiet ) def test_nest(y): assert y < x with raises(AssertionError): test_nest() test_blah()
def test_can_eval_stream_inside_find(): @given(st.streaming(st.integers(min_value=0)), st.random_module()) @settings(buffer_size=200, max_shrinks=5, max_examples=10) def test(stream, rnd): x = find( st.lists(st.integers(min_value=0), min_size=10), lambda t: any(t > s for (t, s) in zip(t, stream)), settings=settings( database=None, max_shrinks=2000, max_examples=2000) ) note('x: %r' % (x,)) note('Evalled: %r' % (stream,)) assert len([1 for i, v in enumerate(x) if stream[i] < v]) == 1 test()
def base_vector_arrays(draw, count=1, dtype=None, max_dim=100): """ Parameters ---------- draw hypothesis control function object count how many bases do you want dtype dtype for the generated bases, defaults to `np.float_` max_dim size limit for the generated Returns a list of |VectorArray| linear-independent objects of same dim and length ------- """ dtype = dtype or np.float_ # simplest way currently of getting a |VectorSpace| to construct our new arrays from space_types = _picklable_vector_space_types + _other_vector_space_types space = draw( vector_arrays(count=1, dtype=dtype, length=hyst.just((1, )), compatible=True, space_types=space_types).filter(lambda x: x[ 0].space.dim > 0 and x[0].space.dim < max_dim)).space length = space.dim # this lets hypothesis control np's random state too random = draw(hyst.random_module()) # scipy performs this check although technically numpy accepts a different range assume(0 <= random.seed < 2**32 - 1) random_correlation = random_correlation_gen(random.seed) def _eigs(): """sum must equal to `length` for the scipy construct method""" min_eig, max_eig = 0.001, 1. eigs = np.asarray( (max_eig - min_eig) * np.random.random(length - 1) + min_eig, dtype=float) return np.append(eigs, [length - np.sum(eigs)]) if length > 1: mat = [ random_correlation.rvs(_eigs(), tol=1e-12) for _ in range(count) ] return [space.from_numpy(m) for m in mat] else: scalar = 4 * np.random.random((1, 1)) + 0.1 return [space.from_numpy(scalar) for _ in range(count)]
def run(data): from hypothesis.control import note with BuildContext(is_final=is_final): seed = data.draw(random_module()).seed if seed != 0: note('random.seed(%d)' % (seed, )) args, kwargs = data.draw(search_strategy) if print_example: report(lambda: 'Falsifying example: %s(%s)' % (test.__name__, arg_string(test, args, kwargs))) elif current_verbosity() >= Verbosity.verbose: report(lambda: 'Trying example: %s(%s)' % (test.__name__, arg_string(test, args, kwargs))) return test(*args, **kwargs)
def test_given_does_not_pollute_state(): with deterministic_PRNG(): @given(st.random_module()) def test(r): pass test() state_a = random.getstate() state_a2 = core._hypothesis_global_random.getstate() test() state_b = random.getstate() state_b2 = core._hypothesis_global_random.getstate() assert state_a == state_b assert state_a2 != state_b2
def get_int_flip_mutation(): mutation_probability = hs.floats(min_value=0.0, max_value=1.0) codon_size = hs.integers(min_value=1) individual = hs.builds( get_individual_with_fitness, hs.just(None), hs.integers(min_value=1, max_value=128), hs.integers(min_value=1, max_value=128), hs.integers(), hs.random_module(), ) return hs.fixed_dictionaries({ "individual": individual, "mutation_probability": mutation_probability, "codon_size": codon_size, })
def get_grammar(): def _get_grammar(n_non_terminals, n_terminals, rnd): grammar = donkey_ge.Grammar("") bnf_string = write_rule_str(n_non_terminals, n_terminals, rnd) grammar.parse_bnf_string(bnf_string["bnf_string"]) return grammar rnd = hs.random_module() grammar = hs.builds( _get_grammar, hs.integers(min_value=1, max_value=10), hs.integers(min_value=1, max_value=10), rnd, ) inputs = hs.lists(hs.integers(min_value=1)) return hs.fixed_dictionaries({"grammar": grammar, "inputs": inputs})
class TypeHintsTests(unittest.TestCase): @given(type_to_strat(VCFRow)) def test_namedtuple_vcfrow(self, obj): for attr, typ in fields: self.assertIsInstance(getattr(obj, attr), typ) def test_func_strat(self): #def example_func(m: int, xs: List[int]) -> None: def example_func(m, xs): # type: (int, List[int]) -> None self.assertIsInstance(xs, List[int]) self.assertIsInstance(m, int) argtypes = {'m': int, 'xs': List[int], 'return': None} example_func.__annotations__ = argtypes strat = func_strat(example_func) for _ in range(20): example_func(**strat.example()) SimpleObj = NamedTuple("SimpleObj", [('int', int), ('bool', bool)]) some_types = [ int, str, Optional[int], List[Tuple[int, str]], Tuple[bool, int], SimpleObj ] atype = reduce(operator.ior, map(just, some_types)) @given(atype, atype, atype, random_module()) def test_union_is_either(self, t1, t2, t3, _): union = Union[t1, t2, t3] strat = type_to_strat(union) for _ in range(20): ex = strat.example() self.assertIsInstance(ex, (t1, t2, t3)) @given(type_to_strat(Union[int, str])) def test_union_produces_first(self, x): assume(isinstance(x, int)) self.assertIsInstance(x, int) @given(type_to_strat(Union[int, str])) def test_union_produces_second(self, y): assume(isinstance(y, str)) self.assertIsInstance(y, str)
def get_individuals(n=None, used_input=hs.just(None)): if n is None: n = hs.integers(min_value=1, max_value=20) individuals = n.flatmap(lambda x: hs.lists( hs.builds( get_individual_with_fitness, hs.just(None), hs.integers(min_value=1, max_value=128), hs.integers(min_value=1, max_value=128), hs.integers(), hs.random_module(), used_input, ), max_size=x, min_size=x, )) return individuals
def tournaments(draw, strategies=axelrod.strategies, min_size=1, max_size=10, min_turns=1, max_turns=200, min_noise=0, max_noise=1, min_repetitions=1, max_repetitions=20): """ A hypothesis decorator to return a tournament and a random seed (to ensure reproducibility for strategies that make use of the random module when initiating). Parameters ---------- min_size : integer The minimum number of strategies to include max_size : integer The maximum number of strategies to include min_turns : integer The minimum number of turns max_turns : integer The maximum number of turns min_noise : float The minimum noise value min_noise : float The maximum noise value min_repetitions : integer The minimum number of repetitions max_repetitions : integer The maximum number of repetitions """ seed = draw(random_module()) strategies = draw(strategy_lists(strategies=strategies, min_size=min_size, max_size=max_size)) players = [s() for s in strategies] turns = draw(integers(min_value=min_turns, max_value=max_turns)) repetitions = draw(integers(min_value=min_repetitions, max_value=max_repetitions)) noise = draw(floats(min_value=min_noise, max_value=max_noise)) tournament = axelrod.Tournament(players, turns=turns, repetitions=repetitions, noise=noise) return tournament, seed
class PoolMachine(RuleBasedStateMachine): """Tests the buffer pool in chirp.""" MAX_BUFFERS = 32 def __init__(self): super(PoolMachine, self).__init__() self.max_buffers = PoolMachine.MAX_BUFFERS self.buffers = [] self.pool = ffi.new("ch_buffer_pool_t*") self.count = 0 lib.test_ch_bf_init(self.pool, self.max_buffers) assert self.pool.max_buffers == self.max_buffers assert self.pool.used_buffers == 0 def __del__(self): """Remove data buffers.""" lib.test_ch_bf_free(self.pool) @rule() @precondition(lambda self: self.count < self.max_buffers) def reserve_buf(self): """Reserve a buffer.""" buf = lib.test_ch_bf_reserve(self.pool) assert buf.used == 1 assert buf.id < self.max_buffers self.buffers.append(buf) self.count += 1 @rule(rnd=st.random_module()) @precondition(lambda self: self.count > 0) def return_buf(self, rnd): # Ignore PyLintBear (W0613) """Return a buffer.""" random.shuffle(self.buffers) buf = self.buffers.pop() assert buf.used == 1 lib.test_ch_bf_return(self.pool, buf) assert buf.used == 0 self.count -= 1
seen.add(hbytes(x)) if hbytes(x) in seen: data.mark_interesting() runner = ConjectureRunner(f, settings=settings(database=db), database_key=key) runner.run() assert runner.interesting_examples assert len(seen) == n in_db = non_covering_examples(db) assert in_db.issubset(seen) assert in_db == seen @given(st.randoms(), st.random_module()) @settings(max_shrinks=0, deadline=None, suppress_health_check=[HealthCheck.hung_test]) def test_maliciously_bad_generator(rnd, seed): @run_to_buffer def x(data): for _ in range(rnd.randint(1, 100)): data.draw_bytes(rnd.randint(1, 10)) if rnd.randint(0, 1): data.mark_invalid() else: data.mark_interesting() def test_garbage_collects_the_database():
@given(st.lists(st.integers()), schroedintegers) def test_bisection_agrees_with_eventual_answer(ls, x): i = bisect_left(ls, x) assert i == bisect_left(ls, int(x)) @given(st.lists(schroedintegers)) def test_sorting_produces_eventual_sort(ls): ls.sort() forced = list(map(int, ls)) assert forced == sorted(forced) @given(st.random_module(), st.lists(st.integers(), min_size=1)) def test_can_produce_different_results(rnd, ls): assume(len(set(bisect_left(ls, i) for i in ls)) > 1) seen = set() for _ in range(100): x = schroedinteger(ls) seen.add(bisect_left(ls, x)) if len(seen) > 1: return assert False @given(schroedintegers, schroedintegers) def test_equal_integers_give_equal_values(x, y): assume(x == y) assert int(x) == int(y)
import numpy as np from nbody.forces.numpy_forces import calculate_forces from hypothesis import given from hypothesis.extra.numpy import arrays from hypothesis.strategies import floats, random_module from nbody.integrators import verlet_step, kinetic_energy N = 6 N_iterations = 50 @given( random=random_module(), v=arrays( float, (N, 3), floats(min_value=-1e1, max_value=1e1, allow_infinity=False, allow_nan=False), ), ) def test_verlet_integrator_reversible(random, v): dt = 1e-6 r = np.random.random(size=v.shape) * 2 m = np.ones((r.shape[0], 1), dtype=float) p = m * v forces = calculate_forces(r, m=m) r_init = r.copy() p_init = p.copy() kinetic_init = kinetic_energy(p_init, m)
@composite def single_bool_lists(draw): n = draw(integers(0, 20)) result = [False] * (n + 1) result[n] = True return result @example([True, False, False, False], [3], None,) @example([False, True, False, False], [3], None,) @example([False, False, True, False], [3], None,) @example([False, False, False, True], [3], None,) @settings(max_examples=0) @given( lists(booleans(), average_size=20) | single_bool_lists(), lists(integers(1, 3), average_size=20), random_module()) def test_failure_sequence_inducing(building, testing, rnd): buildit = iter(building) testit = iter(testing) def build(x): try: assume(not next(buildit)) except StopIteration: pass return x @given(integers().map(build)) @settings( verbosity=Verbosity.quiet, database=None, perform_health_check=False, max_shrinks=0
assert all( distance(center, average_coords(get_coords(object_, points) for object_ in objects)) < 5e-8 for center, objects in clustered ) @given(point_lists(), thresholds()) def test_points_are_in_exactly_one_cluster_each(points, threshold): clustered = cluster(points, threshold) clusters = [objects for center, objects in clustered] assert all( len(list(filter(lambda objects: object_ in objects, clusters))) == 1 for (coords, object_) in points) @given(point_lists(min_size=2, max_size=6).filter(lambda point_list: point_distance(*point_list[:2]) < 40), random_module()) def test_two_points_cannot_be_in_singleton_clusters_both_if_they_are_close(points, rand_module): points_shuffled = points.copy() random.shuffle(points_shuffled) clustered = list(cluster(points_shuffled, 40)) assert any( len(next(objects for center, objects in clustered if object_ in objects)) > 1 for coords, object_ in points[:2] ) @given(point_lists(), thresholds(), random_module()) def test_clustering_is_deterministic(points, threshold, rand_module): assert list(cluster(points, threshold)) == list(cluster(points, threshold))
from hypothesis import strategies as st from schroedinteger import schroedinteger schroedintegers = st.builds( lambda x, _: schroedinteger(x), st.lists(st.integers(), min_size=1, average_size=5), st.random_module() ) mixed_integers = schroedintegers | st.integers()
@given(integers()) def test(x): if first_call[0]: first_call[0] = False assert False with pytest.raises(Flaky): test() class SatisfyMe(Exception): pass @given(lists(booleans()), lists(integers(1, 3)), random_module()) def test_failure_sequence_inducing(building, testing, rnd): buildit = iter(building) testit = iter(testing) def build(x): try: assume(not next(buildit)) except StopIteration: pass return x @given(integers().map(build), settings=Settings( verbosity=Verbosity.quiet, database=None, perform_health_check=False, ))
# # Most of this work is copyright (C) 2013-2016 David R. MacIver # ([email protected]), but it contains contributions by others. See # CONTRIBUTING.rst for a full list of people who may hold copyright, and # consult the git log if you need to determine who owns an individual # contribution. # # This Source Code Form is subject to the terms of the Mozilla Public License, # v. 2.0. If a copy of the MPL was not distributed with this file, You can # obtain one at http://mozilla.org/MPL/2.0/. # # END HEADER from __future__ import division, print_function, absolute_import from hypothesis import strategies as st from hypothesis import find, note, given, settings @given(st.streaming(st.integers(min_value=0)), st.random_module()) @settings(buffer_size=200, max_shrinks=5, max_examples=10) def test_can_eval_stream_inside_find(stream, rnd): x = find( st.lists(st.integers(min_value=0), min_size=10), lambda t: any(t > s for (t, s) in zip(t, stream)), settings=settings(database=None, max_shrinks=2000, max_examples=2000), ) note("x: %r" % (x,)) note("Evalled: %r" % (stream,)) assert len([1 for i, v in enumerate(x) if stream[i] < v]) == 1
from hypothesis import given, reporting from tests.common.utils import capture_out def test_can_seed_random(): with capture_out() as out: with reporting.with_reporter(reporting.default): with pytest.raises(AssertionError): @given(st.random_module()) def test(r): assert False test() assert 'random.seed(0)' in out.getvalue() @given(st.random_module(), st.random_module()) def test_seed_random_twice(r, r2): assert repr(r) == repr(r2) @given(st.random_module()) def test_does_not_fail_health_check_if_randomness_is_used(r): import random random.getrandbits(128) def test_reports_non_zero_seed(): random.seed(0) zero_value = random.randint(0, 10) with capture_out() as out:
@composite def single_bool_lists(draw): n = draw(integers(0, 20)) result = [False] * (n + 1) result[n] = True return result @example([True, False, False, False], [3], None) @example([False, True, False, False], [3], None) @example([False, False, True, False], [3], None) @example([False, False, False, True], [3], None) @settings(deadline=None) @given(lists(booleans()) | single_bool_lists(), lists(integers(1, 3)), random_module()) def test_failure_sequence_inducing(building, testing, rnd): buildit = iter(building) testit = iter(testing) def build(x): try: assume(not next(buildit)) except StopIteration: pass return x @given(integers().map(build)) @settings( verbosity=Verbosity.quiet, database=None,
import re import time import pytest from hypothesis import given, strategies as st from tests import utils as test_utils from pytest_localstack import constants, exceptions, session @given(random=st.random_module()) def test_generate_container_name(random): """Test pytest_localstack.session.generate_container_name.""" result = session.generate_container_name() assert re.match(r"^pytest-localstack-[\w]{6}$", result) @pytest.mark.parametrize("service_name", sorted(constants.SERVICE_PORTS.keys())) def test_LocalstackSession_map_port(service_name): """Test pytest_localstack.session.LocalstackSession.map_port.""" test_session = test_utils.make_test_LocalstackSession() port = constants.SERVICE_PORTS[service_name] with pytest.raises(exceptions.ContainerNotStartedError): test_session.map_port(port) test_session.start() result = test_session.map_port(port) assert result == port # see tests.utils.make_mock_docker_client()
class TestAuxiliary(unittest.TestCase): def test_seed(self): ciw.seed(5) a1 = random.expovariate(5) b1 = ciw.random_choice([4, 5, 6, 1]) c1 = random.random() ciw.seed(5) a2 = random.expovariate(5) b2 = ciw.random_choice([4, 5, 6, 1]) c2 = random.random() self.assertEqual(a1, a2) self.assertEqual(b1, b2) self.assertEqual(c1, c2) @given(choices=lists(integers(min_value=0, max_value=10000), min_size=1, max_size=100), lmbda=floats(min_value=0.0001, max_value=10000), s=integers(min_value=0, max_value=10000), rm=random_module()) def test_seedh(self, choices, lmbda, s, rm): ciw.seed(s) a1 = random.expovariate(lmbda) b1 = ciw.random_choice(choices) c1 = random.random() ciw.seed(s) a2 = random.expovariate(lmbda) b2 = ciw.random_choice(choices) c2 = random.random() self.assertEqual(a1, a2) self.assertEqual(b1, b2) self.assertEqual(c1, c2) def test_randomchoice(self): ciw.seed(1) array = [1, 2, 3, 4, 5, 6, 7, 8] probs = [0.4, 0.2, 0.1, 0.1, 0.05, 0.05, 0.05, 0.05] choices = [ciw.random_choice(array, probs) for _ in range(200)] choice_counts = Counter(choices) self.assertEqual(choice_counts, { 1: 79, 2: 49, 3: 14, 4: 22, 5: 11, 6: 11, 7: 5, 8: 9 }) ciw.seed(2) array = [ 'A', 'B', 'C', 'Ch', 'D', 'Dd', 'E', 'F', 'Ff', 'G', 'Ng', 'H' ] probs = [0.0, 0.1, 0.0, 0.3, 0.0, 0.2, 0.0, 0.1, 0.1, 0.0, 0.2, 0.0] choices = [ciw.random_choice(array, probs) for _ in range(300)] choice_counts = Counter(choices) self.assertEqual(choice_counts, { 'B': 34, 'Ch': 83, 'Dd': 68, 'F': 26, 'Ff': 31, 'Ng': 58 }) ciw.seed(3) array = 'Geraint' probs = [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0] choices = [ciw.random_choice(array, probs) for _ in range(100)] choice_counts = Counter(choices) self.assertEqual(choice_counts, {'i': 100}) ciw.seed(4) array = [111, 222, 333, 444] choices = [ciw.random_choice(array) for _ in range(800)] choice_counts = Counter(choices) self.assertEqual(choice_counts, { 111: 209, 222: 186, 333: 180, 444: 225 }) # Test that no random numbers used in this case: ciw.seed(5) r1 = random.random() ciw.seed(5) array = ['Node 1', 'Node 2', 'Exit Node'] probs = [0.0, 0.0, 1.0] choices = [ciw.random_choice(array, probs) for _ in range(100)] r2 = random.random() choice_counts = Counter(choices) self.assertEqual(choice_counts, {'Exit Node': 100}) self.assertEqual(r1, r2) def test_flatten_list(self): for seed in range(20): random.seed(seed) all_classes = [[ random.random() for _ in range(random.randrange(3, 30, 1)) ] for _ in range(random.randrange(5, 20, 1))] A = [i for priority in all_classes for i in priority] B = ciw.flatten_list(all_classes) self.assertEqual(A, B) def test_no_routing(self): ind = ciw.Individual(22) self.assertEqual(ciw.no_routing(ind), [])
import pytest from hypothesis import given, settings from hypothesis.strategies import binary, composite, integers, random_module from subrosa import Share, add_share, recover_secret, split_secret @composite def threshold_and_shares(draw): threshold = draw(integers(min_value=2, max_value=255)) shares = draw(integers(min_value=threshold, max_value=255)) return threshold, shares @pytest.mark.ci_only @given(random_module(), binary(min_size=1), threshold_and_shares()) @settings(timeout=-1, max_examples=5) def test_split_and_recover(_, secret, threshold_and_number_of_shares): """ Tests whether the secret can be split and recovered for some random secret, threshold and share. This can take a long time to run (several minutes), for large thresholds or shares. For this reason this test is only executed when running on continous integration by default. Take a look at `test_split_and_recover_fast`, which always runs for a fast version of this test. """ threshold, number_of_shares = threshold_and_number_of_shares shares = split_secret(secret, threshold, number_of_shares) subset = random.sample(shares, threshold)
@composite def single_bool_lists(draw): n = draw(integers(0, 20)) result = [False] * (n + 1) result[n] = True return result @example([True, False, False, False], [3], None,) @example([False, True, False, False], [3], None,) @example([False, False, True, False], [3], None,) @example([False, False, False, True], [3], None,) @settings(max_examples=0) @given( lists(booleans()) | single_bool_lists(), lists(integers(1, 3)), random_module()) def test_failure_sequence_inducing(building, testing, rnd): buildit = iter(building) testit = iter(testing) def build(x): try: assume(not next(buildit)) except StopIteration: pass return x @given(integers().map(build)) @settings( verbosity=Verbosity.quiet, database=None, suppress_health_check=HealthCheck.all(), phases=no_shrink
random=rnd, settings=settings( database=None, max_examples=5000, max_shrinks=1000)) lvs = leaves(r) assert lvs == [False] * 3 assert all(isinstance(v, bool) for v in lvs), repr(lvs) def test_can_clone_same_length_items(): ls = find( lists(frozensets(integers(), min_size=10, max_size=10)), lambda x: len(x) >= 20 ) assert len(set(ls)) == 1 @given(random_module(), integers(min_value=0)) @example(None, 62677) @settings(max_examples=100, max_shrinks=0) def test_minimize_down_to(rnd, i): j = find( integers(), lambda x: x >= i, settings=settings(max_examples=1000, database=None, max_shrinks=1000)) assert i == j @flaky(max_runs=2, min_passes=1) def test_can_find_quite_deep_lists(): def depth(x): if x and isinstance(x, list): return 1 + max(map(depth, x)) else:
from structureshrink import shrink from hypothesis import given, strategies as st import hashlib @given(st.binary(), st.random_module()) def test_partition_by_length(b, _): shrunk = shrink(b, len) assert len(shrunk) == len(b) + 1 @given( st.lists(st.binary(min_size=1, max_size=4), min_size=1, max_size=5), st.random_module() ) def test_shrink_to_any_substring(ls, _): shrunk = shrink( b''.join(ls), lambda x: sum(l in x for l in ls) ) assert len(shrunk) >= len(ls) def test_partition_by_last_byte(): seed = b''.join(bytes([i, j]) for i in range(256) for j in range(256)) shrunk = shrink( seed, lambda s: hashlib.sha1(s).digest()[-1] & 127 ) assert len(shrunk) == 128
class TestSampling(unittest.TestCase): def test_sampling_uniform_dist(self): params = { 'Arrival_distributions': [['Uniform', 2.2, 3.3]], 'Service_distributions': [['Uniform', 2.2, 3.3]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nu = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Nu.simulation.service_times[Nu.id_number][0](), 2), 2.89) self.assertEqual(round( Nu.simulation.service_times[Nu.id_number][0](), 2), 3.02) self.assertEqual(round( Nu.simulation.service_times[Nu.id_number][0](), 2), 3.07) self.assertEqual(round( Nu.simulation.service_times[Nu.id_number][0](), 2), 3.24) self.assertEqual(round( Nu.simulation.service_times[Nu.id_number][0](), 2), 3.01) self.assertEqual(round( Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.21) self.assertEqual(round( Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.23) self.assertEqual(round( Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.71) self.assertEqual(round( Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 3.24) self.assertEqual(round( Nu.simulation.inter_arrival_times[Nu.id_number][0](), 2), 2.91) @given(u=lists(floats(min_value=0.0, max_value=10000), min_size=2, max_size=2, unique=True).map(sorted), rm=random_module()) def test_sampling_uniform_dist_hypothesis(self, u, rm): ul, uh = u[0], u[1] params = { 'Arrival_distributions': [['Uniform', ul, uh]], 'Service_distributions': [['Uniform', ul, uh]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nu = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(ul <= Nu.simulation.service_times[Nu.id_number][0]() <= uh) self.assertTrue(ul <= Nu.simulation.inter_arrival_times[Nu.id_number][0]() <= uh) def test_error_uniform_dist(self): Arrival_distributions = [['Uniform', 2.2, 3.3]] Arrival_distributions_E = [['Uniform', -2.2, 3.3]] Arrival_distributions_EE = [['Uniform', 3.3, 2.2]] Service_distributions = [['Uniform', 2.2, 3.3]] Service_distributions_E = [['Uniform', 2.2, -3.3]] Service_distributions_EE = [['Uniform', 3.3, 2.2]] Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions_EE, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_EE, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) def test_sampling_deterministic_dist(self): params = { 'Arrival_distributions': [['Deterministic', 4.4]], 'Service_distributions': [['Deterministic', 4.4]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nd = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.service_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) self.assertEqual(round( Nd.simulation.inter_arrival_times[Nd.id_number][0](), 2), 4.40) @given(d=floats(min_value=0.0, max_value=10000), rm=random_module()) def test_sampling_deterministic_dist_hypothesis(self, d, rm): params = { 'Arrival_distributions': [['Deterministic', d]], 'Service_distributions': [['Deterministic', d]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nd = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertEqual(Nd.simulation.service_times[Nd.id_number][0](), d) self.assertEqual(Nd.simulation.inter_arrival_times[Nd.id_number][0](), d) def test_error_deterministic_dist(self): Arrival_distributions = [['Deterministic', 2.2]] Arrival_distributions_E = [['Deterministic', -2.2]] Service_distributions = [['Deterministic', 3.3]] Service_distributions_E = [['Deterministic', -3.3]] Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) def test_sampling_triangular_dist(self): params = { 'Arrival_distributions': [['Triangular', 1.1, 6.6, 1.5]], 'Service_distributions': [['Triangular', 1.1, 6.6, 1.5]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nt = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Nt.simulation.service_times[Nt.id_number][0](), 2), 3.35) self.assertEqual(round( Nt.simulation.service_times[Nt.id_number][0](), 2), 3.91) self.assertEqual(round( Nt.simulation.service_times[Nt.id_number][0](), 2), 4.20) self.assertEqual(round( Nt.simulation.service_times[Nt.id_number][0](), 2), 5.33) self.assertEqual(round( Nt.simulation.service_times[Nt.id_number][0](), 2), 3.90) self.assertEqual(round( Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.12) self.assertEqual(round( Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 1.35) self.assertEqual(round( Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 2.73) self.assertEqual(round( Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 5.34) self.assertEqual(round( Nt.simulation.inter_arrival_times[Nt.id_number][0](), 2), 3.46) @given(t=lists(floats(min_value=0.0, max_value=10000), min_size=3, max_size=3, unique=True).map(sorted), rm=random_module()) def test_sampling_triangular_dist_hypothesis(self, t, rm): tl, tm, th = t[0], t[1], t[2] params = { 'Arrival_distributions': [['Triangular', tl, th, tm]], 'Service_distributions': [['Triangular', tl, th, tm]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nt = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(tl <= Nt.simulation.service_times[Nt.id_number][0]() <= th) self.assertTrue(tl <= Nt.simulation.inter_arrival_times[Nt.id_number][0]() <= th) def test_error_triangular_dist(self): Arrival_distributions = [['Triangular', 2.2, 3.3, 2.8]] Arrival_distributions_E = [['Triangular', -2.2, 3.3, 2.8]] Arrival_distributions_EE = [['Triangular', 3.3, 2.2, 2.1]] Service_distributions = [['Triangular', 2.2, 3.3, 2.8]] Service_distributions_E = [['Triangular', 2.2, -3.3, 2.8]] Service_distributions_EE = [['Triangular', 2.2, 2.6, 2.9]] Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions_EE, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_EE, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) def test_sampling_exponential_dist(self): params = { 'Arrival_distributions': [['Exponential', 4.4]], 'Service_distributions': [['Exponential', 4.4]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Ne = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Ne.simulation.service_times[Ne.id_number][0](), 2), 0.22) self.assertEqual(round( Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31) self.assertEqual(round( Ne.simulation.service_times[Ne.id_number][0](), 2), 0.36) self.assertEqual(round( Ne.simulation.service_times[Ne.id_number][0](), 2), 0.65) self.assertEqual(round( Ne.simulation.service_times[Ne.id_number][0](), 2), 0.31) self.assertEqual(round( Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.58) self.assertEqual(round( Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.01) self.assertEqual(round( Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.14) self.assertEqual(round( Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.65) self.assertEqual(round( Ne.simulation.inter_arrival_times[Ne.id_number][0](), 2), 0.24) @given(e=floats(min_value=0.001, max_value=10000), rm=random_module()) def test_sampling_exponential_dist_hypothesis(self, e, rm): params = { 'Arrival_distributions': [['Exponential', e]], 'Service_distributions': [['Exponential', e]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Ne = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(Ne.simulation.service_times[Ne.id_number][0]() >= 0.0) self.assertTrue(Ne.simulation.inter_arrival_times[Ne.id_number][0]() >= 0.0) def test_sampling_gamma_dist(self): params = { 'Arrival_distributions': [['Gamma', 0.6, 1.2]], 'Service_distributions': [['Gamma', 0.6, 1.2]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Ng = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Ng.simulation.service_times[Ng.id_number][0](), 2), 0.00) self.assertEqual(round( Ng.simulation.service_times[Ng.id_number][0](), 2), 2.59) self.assertEqual(round( Ng.simulation.service_times[Ng.id_number][0](), 2), 1.92) self.assertEqual(round( Ng.simulation.service_times[Ng.id_number][0](), 2), 0.47) self.assertEqual(round( Ng.simulation.service_times[Ng.id_number][0](), 2), 0.61) self.assertEqual(round( Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00) self.assertEqual(round( Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.07) self.assertEqual(round( Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 1.15) self.assertEqual(round( Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.75) self.assertEqual(round( Ng.simulation.inter_arrival_times[Ng.id_number][0](), 2), 0.00) @given(ga=floats(min_value=0.001, max_value=10000), gb=floats(min_value=0.001, max_value=10000), rm=random_module()) def test_sampling_gamma_dist_hypothesis(self, ga, gb, rm): params = { 'Arrival_distributions': [['Gamma', ga, gb]], 'Service_distributions': [['Gamma', ga, gb]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Ng = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(Ng.simulation.service_times[Ng.id_number][0]() >= 0.0) self.assertTrue(Ng.simulation.inter_arrival_times[Ng.id_number][0]() >= 0.0) def test_sampling_lognormal_dist(self): params = { 'Arrival_distributions': [['Lognormal', 0.8, 0.2]], 'Service_distributions': [['Lognormal', 0.8, 0.2]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nl = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Nl.simulation.service_times[Nl.id_number][0](), 2), 2.62) self.assertEqual(round( Nl.simulation.service_times[Nl.id_number][0](), 2), 1.64) self.assertEqual(round( Nl.simulation.service_times[Nl.id_number][0](), 2), 2.19) self.assertEqual(round( Nl.simulation.service_times[Nl.id_number][0](), 2), 2.31) self.assertEqual(round( Nl.simulation.service_times[Nl.id_number][0](), 2), 2.48) self.assertEqual(round( Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.51) self.assertEqual(round( Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.33) self.assertEqual(round( Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 1.96) self.assertEqual(round( Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.32) self.assertEqual(round( Nl.simulation.inter_arrival_times[Nl.id_number][0](), 2), 2.70) @given(lm=floats(min_value=-200, max_value=200), lsd=floats(min_value=0.001, max_value=80), rm=random_module()) def test_sampling_lognormal_dist_hypothesis(self, lm, lsd, rm): params = { 'Arrival_distributions': [['Lognormal', lm, lsd]], 'Service_distributions': [['Lognormal', lm, lsd]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nl = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(Nl.simulation.service_times[Nl.id_number][0]() >= 0.0) self.assertTrue(Nl.simulation.inter_arrival_times[Nl.id_number][0]() >= 0.0) def test_sampling_weibull_dist(self): params = { 'Arrival_distributions': [['Weibull', 0.9, 0.8]], 'Service_distributions': [['Weibull', 0.9, 0.8]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nw = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Nw.simulation.service_times[Nw.id_number][0](), 2), 0.87) self.assertEqual(round( Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31) self.assertEqual(round( Nw.simulation.service_times[Nw.id_number][0](), 2), 1.60) self.assertEqual(round( Nw.simulation.service_times[Nw.id_number][0](), 2), 3.34) self.assertEqual(round( Nw.simulation.service_times[Nw.id_number][0](), 2), 1.31) self.assertEqual(round( Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 2.91) self.assertEqual(round( Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.01) self.assertEqual(round( Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.50) self.assertEqual(round( Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 3.36) self.assertEqual(round( Nw.simulation.inter_arrival_times[Nw.id_number][0](), 2), 0.95) @given(wa=floats(min_value=0.01, max_value=200), wb=floats(min_value=0.01, max_value=200), rm=random_module()) def test_sampling_weibull_dist_hypothesis(self, wa, wb, rm): params = { 'Arrival_distributions': [['Weibull', wa, wb]], 'Service_distributions': [['Weibull', wa, wb]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nw = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(Nw.simulation.service_times[Nw.id_number][0]() >= 0.0) self.assertTrue(Nw.simulation.inter_arrival_times[Nw.id_number][0]() >= 0.0) def test_sampling_empirical_dist(self): my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3] params = { 'Arrival_distributions': [['Empirical', 'ciw/tests/testing_parameters/sample_empirical_dist.csv']], 'Service_distributions': [['Empirical', my_empirical_dist]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nem = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Nem.simulation.service_times[Nem.id_number][0](), 2), 8.8) self.assertEqual(round( Nem.simulation.service_times[Nem.id_number][0](), 2), 12.3) self.assertEqual(round( Nem.simulation.service_times[Nem.id_number][0](), 2), 8.0) self.assertEqual(round( Nem.simulation.service_times[Nem.id_number][0](), 2), 8.0) self.assertEqual(round( Nem.simulation.service_times[Nem.id_number][0](), 2), 8.0) self.assertEqual(round( Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7) self.assertEqual(round( Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7) self.assertEqual(round( Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.1) self.assertEqual(round( Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.1) self.assertEqual(round( Nem.simulation.inter_arrival_times[Nem.id_number][0](), 2), 7.7) @given(dist=lists(floats(min_value=0.001, max_value=10000), min_size=1, max_size=20), rm=random_module()) def test_sampling_empirical_dist_hypothesis(self, dist, rm): my_empirical_dist = dist params = { 'Arrival_distributions': [['Empirical', my_empirical_dist]], 'Service_distributions': [['Empirical', 'ciw/tests/testing_parameters/sample_empirical_dist.csv']], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nem = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(Nem.simulation.service_times[ Nem.id_number][0]() in set([7.0, 7.1, 7.2, 7.3, 7.7, 7.8])) self.assertTrue(Nem.simulation.inter_arrival_times[ Nem.id_number][0]() in set(my_empirical_dist)) def test_error_empirical_dist(self): my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3] my_empirical_dist_E = [8.0, 8.0, 8.0, -8.8, 8.8, 12.3] Arrival_distributions = [['Empirical', my_empirical_dist]] Arrival_distributions_E = [['Empirical', my_empirical_dist_E]] Service_distributions = [['Empirical', my_empirical_dist]] Service_distributions_E = [['Empirical', my_empirical_dist_E]] Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions': Arrival_distributions_E, 'Service_distributions': Service_distributions, 'Number_of_servers': Number_of_servers, 'Transition_matrices': Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions': Arrival_distributions, 'Service_distributions': Service_distributions_E, 'Number_of_servers': Number_of_servers, 'Transition_matrices': Transition_matrices}) def test_sampling_custom_dist(self): my_custom_dist = [[0.2, 3.7], [0.5, 3.8], [0.3, 4.1]] params = { 'Arrival_distributions': [['Custom', my_custom_dist]], 'Service_distributions': [['Custom', my_custom_dist]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nc = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(round( Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) self.assertEqual(round( Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1) self.assertEqual(round( Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) self.assertEqual(round( Nc.simulation.service_times[Nc.id_number][0](), 2), 4.1) self.assertEqual(round( Nc.simulation.service_times[Nc.id_number][0](), 2), 3.8) self.assertEqual(round( Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) self.assertEqual(round( Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 4.1) self.assertEqual(round( Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) self.assertEqual(round( Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.8) self.assertEqual(round( Nc.simulation.inter_arrival_times[Nc.id_number][0](), 2), 3.7) @given(custs=lists(floats(min_value=0.001, max_value=10000), min_size=2, unique=True), rm=random_module()) def test_sampling_custom_dist_hypothesis(self, custs, rm): cust_vals = [round(i, 10) for i in custs] numprobs = len(cust_vals) probs = [1.0/numprobs for i in range(numprobs)] my_custom_dist = [list(i) for i in (zip(probs, cust_vals))] params = { 'Arrival_distributions': [['Custom', my_custom_dist]], 'Service_distributions': [['Custom', my_custom_dist]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nc = Q.transitive_nodes[0] for itr in range(10): # Because repition happens in the simulation self.assertTrue(Nc.simulation.service_times[ Nc.id_number][0]() in set(cust_vals)) self.assertTrue(Nc.simulation.inter_arrival_times[ Nc.id_number][0]() in set(cust_vals)) def test_error_custom_dist(self): my_custom_dist = [[0.2, 3.7], [0.5, 3.8], [0.3, 4.1]] my_custom_dist_E = [[0.2, 3.7], [0.5, -3.8], [0.3, 4.1]] my_custom_dist_EE = [[0.2, 3.7], [-0.5, 3.8], [0.3, 4.1]] Arrival_distributions = [['Custom', my_custom_dist]] Arrival_distributions_E = [['Custom', my_custom_dist_E]] Arrival_distributions_EE = [['Custom', my_custom_dist_EE]] Service_distributions = [['Custom', my_custom_dist]] Service_distributions_E = [['Custom', my_custom_dist_E]] Service_distributions_EE = [['Custom', my_custom_dist_EE]] Number_of_servers = [1] Transition_matrices = [[0.1]] Simulation_time = 2222 self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions_E, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions_EE, 'Service_distributions':Service_distributions, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_E, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) self.assertRaises(ValueError, ciw.create_network, {'Arrival_distributions':Arrival_distributions, 'Service_distributions':Service_distributions_EE, 'Number_of_servers':Number_of_servers, 'Transition_matrices':Transition_matrices}) def test_sampling_function_dist(self): params = { 'Arrival_distributions': [['UserDefined', lambda : random()], ['UserDefined', lambda : custom_function()]], 'Service_distributions': [['UserDefined', lambda : random()], ['UserDefined', lambda : custom_function()]], 'Number_of_servers': [1, 1], 'Transition_matrices': [[0.1, 0.1], [0.1, 0.1]] } Q = ciw.Simulation(ciw.create_network(params)) N1 = Q.transitive_nodes[0] N2 = Q.transitive_nodes[1] ciw.seed(5) self.assertEqual(round( N1.simulation.service_times[N1.id_number][0](), 2), 0.62) self.assertEqual(round( N1.simulation.service_times[N1.id_number][0](), 2), 0.74) self.assertEqual(round( N1.simulation.service_times[N1.id_number][0](), 2), 0.80) self.assertEqual(round( N1.simulation.service_times[N1.id_number][0](), 2), 0.94) self.assertEqual(round( N1.simulation.service_times[N1.id_number][0](), 2), 0.74) self.assertEqual(round( N2.simulation.service_times[N2.id_number][0](), 2), 0.46) self.assertEqual(round( N2.simulation.service_times[N2.id_number][0](), 2), 0.06) self.assertEqual(round( N2.simulation.service_times[N2.id_number][0](), 2), 0.93) self.assertEqual(round( N2.simulation.service_times[N2.id_number][0](), 2), 0.47) self.assertEqual(round( N2.simulation.service_times[N2.id_number][0](), 2), 1.30) self.assertEqual(round( N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.90) self.assertEqual(round( N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.11) self.assertEqual(round( N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.47) self.assertEqual(round( N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.25) self.assertEqual(round( N1.simulation.inter_arrival_times[N1.id_number][0](), 2), 0.54) self.assertEqual(round( N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.29) self.assertEqual(round( N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.03) self.assertEqual(round( N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.43) self.assertEqual(round( N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.56) self.assertEqual(round( N2.simulation.inter_arrival_times[N2.id_number][0](), 2), 0.46) @given(const=floats(min_value = 0.02, max_value=200), dist=lists(floats(min_value=0.001, max_value=10000), min_size=1, max_size=20), rm=random_module()) def test_sampling_function_dist_hypothesis(self, const, dist, rm): my_empirical_dist = [8.0, 8.0, 8.0, 8.8, 8.8, 12.3] params = { 'Arrival_distributions': [['UserDefined', lambda : choice(my_empirical_dist)], ['UserDefined', lambda : const]], 'Service_distributions': [['UserDefined', lambda : random()], ['UserDefined', lambda : custom_function()]], 'Number_of_servers': [1, 1], 'Transition_matrices': [[0.1, 0.1], [0.1, 0.1]] } Q = ciw.Simulation(ciw.create_network(params)) N1 = Q.transitive_nodes[0] N2 = Q.transitive_nodes[1] ciw.seed(5) for itr in range(10): # Because repition happens in the simulation self.assertTrue(N1.simulation.inter_arrival_times[N1.id_number][0]() in set(my_empirical_dist)) self.assertTrue(N2.simulation.inter_arrival_times[N2.id_number][0]() == const) self.assertTrue(0.0 <= N1.simulation.service_times[N1.id_number][0]() <= 1.0) self.assertTrue(0.0 <= N2.simulation.service_times[N2.id_number][0]() <= 2.0) def test_no_arrivals_dist(self): params = { 'Arrival_distributions': ['NoArrivals'], 'Service_distributions': [['Deterministic', 6.6]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]] } Q = ciw.Simulation(ciw.create_network(params)) Nna = Q.transitive_nodes[0] ciw.seed(5) self.assertEqual(Nna.simulation.inter_arrival_times[Nna.id_number][0](), float('Inf')) def test_error_dist(self): params = {'Arrival_distributions': ['NoArrivals'], 'Service_distributions': [['dlkjdlksj', 9]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]], 'Simulation_time': 2222} self.assertRaises(ValueError, ciw.create_network, params) params = {'Arrival_distributions': [['skjfhkjsfhjk']], 'Service_distributions': [['Exponential', 9.5]], 'Number_of_servers': [1], 'Transition_matrices': [[0.1]], 'Simulation_time': 2222} self.assertRaises(ValueError, ciw.create_network, params) @given(positive_float=floats(min_value=0.0, max_value=100.0), negative_float=floats(min_value=-100.0, max_value=0.0), word=text(), rm=random_module()) def test_check_userdef_dist(self, positive_float, negative_float, word, rm): assume(negative_float < 0) Q = ciw.Simulation(ciw.create_network('ciw/tests/testing_parameters/params.yml')) self.assertEqual(Q.check_userdef_dist(lambda : positive_float), positive_float) self.assertRaises(ValueError, Q.check_userdef_dist, lambda : negative_float) self.assertRaises(ValueError, Q.check_userdef_dist, lambda : word)
digraph g { label="Command graph"; graph [splines=line]; """) for i in range(len(example[0])): print(" c%03d [shape=triangle];" % i) for provides in example[0][i]: print(" c%03d -> r%03d;" % (i, provides)) for requires in example[1][i]: print(" r%03d -> c%03d;" % (requires, i)) print("}") @test.hypothesis_min_ver @given(provide_require_st(), st.random_module()) def test_graph_basic(tree, rnd): """Test our test method, create a basic graph using hypthesis and run some basic tests against it.""" run_graph(tree) @test.hypothesis_min_ver @given(provide_require_st(False), st.random_module()) def test_graph_cycles(tree, rnd): """Test reacts correctly on trees with cycles.""" try: run_graph(tree) except ValueError as e: # pragma: no cover if "Commands with unresolved deps" not in e.args[0]: raise e