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
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_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_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_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 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
