def _tensor_splits(draw):
lengths = draw(st.lists(st.integers(1, 5), min_size=1, max_size=10))
batch_size = draw(st.integers(1, 5))
element_pairs = [
(batch, r) for batch in range(batch_size) for r in range(len(lengths))
]
perm = draw(st.permutations(element_pairs))
perm = perm[:-1] # skip one range
ranges = [[(0, 0)] * len(lengths) for _ in range(batch_size)]
offset = 0
for pair in perm:
ranges[pair[0]][pair[1]] = (offset, lengths[pair[1]])
offset += lengths[pair[1]]
data = draw(st.lists(
st.floats(min_value=-1.0, max_value=1.0),
min_size=offset,
max_size=offset
))
key = draw(st.permutations(range(offset)))
return (
np.array(data).astype(np.float32), np.array(ranges),
np.array(lengths), np.array(key).astype(np.int64)
)
def _tensor_splits(draw):
lengths = draw(st.lists(st.integers(1, 5), min_size=1, max_size=10))
batch_size = draw(st.integers(1, 5))
element_pairs = [
(batch, r) for batch in range(batch_size) for r in range(len(lengths))
]
perm = draw(st.permutations(element_pairs))
perm = perm[:-1] # skip one range
ranges = [[(0, 0)] * len(lengths) for _ in range(batch_size)]
offset = 0
for pair in perm:
ranges[pair[0]][pair[1]] = (offset, lengths[pair[1]])
offset += lengths[pair[1]]
data = draw(st.lists(
st.floats(min_value=-1.0, max_value=1.0),
min_size=offset,
max_size=offset
))
key = draw(st.permutations(range(offset)))
return (
np.array(data).astype(np.float32), np.array(ranges),
np.array(lengths), np.array(key).astype(np.int64)
)
def test_stack(data, x):
perm = data.draw(permutations(x.dims))
print(perm)
y = x.transpose(*perm)
n = data.draw(name(x))
z = ntorch.stack([x, y], n)
assert set(z.dims) == set(x.dims) | set([n])
def python(draw):
interesting = draw(st.lists(composite_statement, min_size=1))
boring = draw(st.lists(statement, min_size=0))
padding_lines = [""] * draw(st.integers(0, 100))
return ("\n".join(
draw(st.permutations(interesting + boring + padding_lines))).strip() +
"\n")
def complete_ranked_ballots(min_cands=3,
max_cands=256,
min_voters=1,
max_voters=1000):
n_cands = integers(min_value=min_cands, max_value=max_cands)
return n_cands.flatmap(lambda n: lists(
permutations(range(n)), min_size=min_voters, max_size=max_voters))
def invalid_rgb(draw: Callable[[Any], Any]) -> Tuple[int, int, int]:
v0 = draw(
st.one_of(st.integers(max_value=-1), st.integers(min_value=0x100)))
v1 = draw(st.integers(min_value=0, max_value=0xFF))
v2 = draw(st.integers(min_value=0, max_value=0xFF))
[r, g, b] = draw(st.permutations([v0, v1, v2]))
return (r, g, b)
def mask_strategy(draw):
dimension = draw(hyp_st.integers(min_value=0, max_value=4))
mask_strats = []
shape_strats = []
default_origin_strats = []
for i in range(dimension):
shape_strats = shape_strats + [
hyp_st.integers(min_value=1, max_value=64)
]
mask_strats = mask_strats + [hyp_st.booleans()]
shape = draw(hyp_st.tuples(*shape_strats))
for i in range(dimension):
default_origin_strats = default_origin_strats + [
hyp_st.integers(min_value=0, max_value=min(32, shape[i] - 1))
]
default_origin = draw(hyp_st.tuples(*default_origin_strats))
mask = draw(
hyp_st.one_of(
hyp_st.just(None),
hyp_st.tuples(*mask_strats),
hyp_st.permutations(([True] * dimension) + (
[False] * draw(hyp_st.integers(min_value=0, max_value=10)))),
))
return dict(shape=shape, default_origin=default_origin, mask=mask)
def circuits(draw,
min_qubits,
max_qubits,
min_length,
max_length,
allowed_gates=allowed_gates,
use_all_allowed_gates=False):
length = draw(integers(min_value=min_length, max_value=max_length))
num_qubits = draw(integers(min_value=min_qubits, max_value=max_qubits))
if use_all_allowed_gates:
circuit_gates = draw(permutations(allowed_gates))
assert min_length >= len(allowed_gates)
max_gate_qubits = max((x.nqubit for x in circuit_gates))
assert min_qubits >= max_gate_qubits
circuit_gates = draw(
lists(gates(allowed_gates), min_size=length, max_size=length).filter(
lambda x: all([y.nqubit <= num_qubits for y in x])))
result = Circuit()
for gate in circuit_gates:
qubits = draw(
lists(integers(min_value=0, max_value=num_qubits - 1),
min_size=gate.nqubit,
max_size=gate.nqubit,
unique=True))
result.add_gate(gate, tuple(qubits))
return result
def hier_object_data(draw, param_list=None, total_bbox=None):
"""
Pseudo randomly generate data than models annotations
of objects.
DRAW is provided by the hypothesis library and is used
to choose parameters.
PARAM_LIST is a list of lists of ObjectStrategyParam namedtuples or a list
of lists of tuples of ObjectStrategyParam namedtuples.
The default for PARAM_LIST is HIERARCHY_PARAM.
TOTAL_BBOX is a bounding box of all objects and defaults to
(0.0, 0.0, 1.0, 1.0).
See README.md for more explanation.
"""
if param_list is None:
param_list = HIERARCHY_PARAM
# for consistency, make always param_list be a list of lists of tuples
param_list = [[
tuple([j]) if isinstance(j, ObjectStrategyParam) else j for j in i
] for i in param_list]
params = draw(st.one_of([st.just(i) for i in param_list]))
if total_bbox is None:
total_bbox = (0.0, 0.0, 1.0, 1.0)
objects = []
parents_children = defaultdict(list)
create_parents_and_children(draw, params, total_bbox, objects,
parents_children)
find_parents_children(objects, parents_children, params)
find_additional_duplicates(objects, parents_children)
objects = draw(st.permutations(objects)) # shuffle
return objects
def gen_rewrite(draw, hypergraph, signature=DEFAULT_SIGNATURE,
num_add_nodes=(0, 5), num_add_hyperedges=(0, 20),
num_remove=(0, 10), num_merge=(0, 10)):
add_nodes = [Node() for i in range(draw(gen_number(num_add_nodes)))]
nodes = list(hypergraph.nodes())
hyperedges = list(hypergraph.hyperedges())
add_hyperedges = []
remove = []
merge = []
if nodes or add_nodes:
add_hyperedges = draw(gen_list(gen_hyperedge(add_nodes + nodes,
signature=signature),
num_add_hyperedges))
if nodes or hyperedges:
remove = draw(gen_list(hyperedges, num_remove))
if nodes:
merge = draw(gen_list(strategies.tuples(strategies.sampled_from(nodes),
strategies.sampled_from(nodes)),
num_merge))
if draw(strategies.booleans()):
add_size = len(add_nodes) + len(add_hyperedges)
add = draw(gen_list(add_nodes + add_hyperedges, add_size))
else:
add = draw(strategies.permutations(add_nodes + add_hyperedges))
return {'remove': remove, 'add': add, 'merge': merge}
def test_permute(data, t1):
permutation = data.draw(permutations(range(len(t1.shape))))
def permute(a):
return a.permute(*permutation)
grad_check(permute, t1)
def complete_graph_fundamental_cycles(draw):
n = draw(integers(3, 12))
G = EdgeLabelledGraph(graphs.CompleteGraph(n))
u = draw(sampled_from(G))
found = {u}
tree_edges = set()
while len(found) < len(G):
v = draw(sampled_from(G.neighbors(u)))
if not v in found:
found.add(v)
e = G.edge_label(u, v)
tree_edges.add((u, v, e))
u = v
tree_edge_labels = {e for _, _, e in tree_edges}
def find_cycle(e):
return [
label for _, _, label in G.subgraph(
edges=tree_edges
| {e}).is_forest(certificate=True, output='edge')[1]
]
cycles = [find_cycle(e) for e in G.edges() if e[2] not in tree_edge_labels]
cycles = draw(permutations(cycles))
return G, cycles
def test_cat(data, x):
perm = data.draw(permutations(x.dims))
y = x.transpose(*perm)
for s in set(x.dims) & set(y.dims):
c = ntorch.cat([x, y], dim=s)
c = ntorch.cat([x, c], dim=s)
c = ntorch.cat([c, x, y], dim=s)
print(c)
def sub_lists(sequence: Sequence[Domain],
*,
min_size: int = 0,
max_size: Optional[int] = None) -> SearchStrategy[List[Domain]]:
if max_size is None:
max_size = len(sequence)
return strategies.builds(
getitem, strategies.permutations(sequence),
strategies.builds(slice, strategies.integers(min_size, max_size)))
def enabled_runtime_settings_names(draw):
shared = draw(shared_config())
names = configurable_names(shared)
if names:
mixed = draw(st.permutations(names))
cutoff = draw(st.integers(min_value=1, max_value=len(mixed)))
return mixed[:cutoff]
else:
return []
def test_permute(backend, data):
"Check permutations for all backends."
t1 = data.draw(tensors(backend=shared[backend]))
permutation = data.draw(permutations(range(len(t1.shape))))
def permute(a):
return a.permute(*permutation)
minitorch.grad_check(permute, t1)
def io_pair_strat_comp(draw):
n, node_list, output_node_list = draw(sampled_from(NODE_MASTER_LIST))
output_strat = lists(sampled_from(output_node_list),
min_size=3,
max_size=10)
ordering = draw(permutations(node_list))
possible_edges = list(combinations(ordering, 2))
edges_strat = lists(sampled_from(possible_edges), min_size=2, unique=True)
dag_strat = builds(DAG, edge_tuples=edges_strat)
return draw(tuples(dag_strat, output_strat))
def test_simple_addition_twice(data):
for congruence in [True, False]:
h1 = Hypergraph(congruence=congruence)
h2 = Hypergraph(congruence=congruence)
to_add1 = data.draw(PE.gen_simple_addition())
to_add2 = data.draw(PE.gen_simple_addition())
h1.rewrite(add=to_add1)
h2.rewrite(add=data.draw(strategies.permutations(to_add1)))
h1.check_integrity()
h1.rewrite(add=to_add2)
h2.rewrite(add=data.draw(strategies.permutations(to_add2)))
h1.check_integrity()
assert h1.isomorphic(h2)
def multiarcs(draw, triangulation=None):
if triangulation is None: triangulation = draw(triangulations())
geometric = [0] * triangulation.zeta
permuted_indices = draw(st.permutations(triangulation.indices))
num_arcs = draw(st.integers(min_value=1, max_value=len(permuted_indices)))
for index in permuted_indices[:num_arcs]:
geometric[index] = draw(st.integers(max_value=-1))
return triangulation.lamination(geometric)
def two_strings(draw):
"""Generate two strings. Sometimes they are anagrams of each other"""
if draw(booleans()):
# Two random strings.
return draw(text()), draw(text())
else:
# Second string is permutation of first.
s1 = draw(text())
s2 = ''.join(draw(permutations(s1)))
return s1, s2
def fill(draw):
ds = draw(dims(x, max_size=2))
perm = draw(permutations(range(len(ds))))
def reorder(ls):
return [ls[perm[i]] for i in range(len(ls))]
shape = reorder([x.shape[d] for d in ds])
np = draw(arrays(dtype, shape, integers(min_value=0, max_value=1)))
return ntorch.tensor(np, names=reorder(ds)).byte()
def complete_ranked_ballots(min_cands=3,
max_cands=25,
min_voters=1,
max_voters=100):
"""
Strategy to generate complete ranked ballot arrays, like those produced by
elections.impartial_culture()
"""
n_cands = integers(min_value=min_cands, max_value=max_cands)
return n_cands.flatmap(lambda n: lists(
permutations(range(n)), min_size=min_voters, max_size=max_voters))
def reshapes_of(draw, shape, max_ndims=4):
"""Strategy for valid reshapes of the given shape, rank at most max_ndims."""
factors = draw(hps.permutations(
prime_factors(tensorshape_util.num_elements(shape))))
split_points = sorted(draw(
hps.lists(hps.integers(min_value=0, max_value=len(factors)),
min_size=0, max_size=max_ndims - 1)))
result = ()
for start, stop in zip([0] + split_points, split_points + [len(factors)]):
result += (int(np.prod(factors[start:stop])),)
return result
class TestParseFilenames:
def test_parses_prefix_correctly(self):
filenames = [
"xxxxOrg_nye_20210128_123742.csv",
"Org_nye_20210128_123742.csv",
"garbagebagasdasdads",
]
expected_filename = "Org_nye_20210128_123742.csv"
actual = los_files.parse_filenames(filenames, "Org_nye", datetime.min)
actual_filename, _ = one(actual)
assert expected_filename == actual_filename
def test_filters_dates_correctly(self):
filenames = [
"Org_nye_20200128_123742.csv",
"Org_nye_20201028_123742.csv",
"Org_nye_20210128_123742.csv",
]
expected = [
("Org_nye_20201028_123742.csv", datetime(2020, 10, 28, 12, 37,
42)),
("Org_nye_20210128_123742.csv", datetime(2021, 1, 28, 12, 37, 42)),
]
actual = los_files.parse_filenames(filenames, "Org_nye",
datetime(2020, 6, 1, 0, 0, 0))
assert expected == actual
@given(
st.permutations([
"Org_nye_20210101_000000.csv",
"Org_nye_20200101_000000.csv",
"Org_nye_20190101_000000.csv",
"Org_nye_20180101_000000.csv",
]))
def test_sorts_output(self, filenames):
expected_dates = [
datetime(2018, 1, 1),
datetime(2019, 1, 1),
datetime(2020, 1, 1),
datetime(2021, 1, 1),
]
actual = los_files.parse_filenames(filenames, "Org_nye", datetime.min)
actual_dates = list(map(itemgetter(1), actual))
assert expected_dates == actual_dates
def choices(seq, size, replace=True):
"""Randomly choose elements from `seq`, producing a tuple of length `size`."""
if size > len(seq) and not replace:
raise ValueError("`size` must not exceed the length of `seq` when `replace` is `False`")
if size > len(seq) and not seq:
raise ValueError("`size` must be 0, given an empty `seq`")
inds = list(range(len(seq)))
if replace:
strat = st.tuples(*[st.sampled_from(inds)]*size)
else:
strat = st.permutations(inds)
return strat.map(lambda x: tuple(seq[i] for i in x[:size]))
def tensor_data(draw, numbers=floats(), shape=None):
if shape is None:
shape = draw(shapes())
size = int(minitorch.prod(shape))
data = draw(lists(numbers, min_size=size, max_size=size))
permute = draw(permutations(range(len(shape))))
permute_shape = tuple([shape[i] for i in permute])
reverse_permute = [a[0] for a in sorted(enumerate(permute), key=lambda a: a[1])]
td = minitorch.TensorData(data, permute_shape)
ret = td.permute(*reverse_permute)
assert ret.shape[0] == shape[0]
return ret
def election(draw):
"""
Hypthesis strategy that returns an arbitrarily chosen election.
First chooses an arbitrary number of candidates between 2 and 10 inclusive.
Then chooses an arbitrary number of voters greater than 1. Then for each
voter chooses an arbitrary ranking of the candidates. Returns a list of
lists of the candidates ranked in order by each voter.
:rtype: list of list of int
"""
candidates = list(range(draw(st.integers(2, 10))))
return draw(st.lists(st.permutations(candidates), min_size=1))
def _vertices_and_sites(draw: Callable[[st.SearchStrategy[T]], T]
) -> Tuple[List[Point], Set[Requirement]]:
multipoint: Multipoint = draw(multipoints)
slice_ = draw(st.integers(min_value=0,
max_value=len(multipoint.points) - 1))
vertices_subset = [multipoint.points[0],
*draw(st.permutations(multipoint.points[1:]))[:slice_]]
requirements_ = draw(st.lists(st.fractions(min_value=MIN_REQUIREMENT),
min_size=slice_ + 1,
max_size=slice_ + 1))
sites = {Requirement(requirement, point=vertex)
for vertex, requirement in zip(vertices_subset, requirements_)}
return multipoint.points, sites
def _bad_tensor_splits(draw):
lengths = draw(st.lists(st.integers(4, 6), min_size=4, max_size=4))
batch_size = 4
element_pairs = [
(batch, r) for batch in range(batch_size) for r in range(len(lengths))
]
perm = draw(st.permutations(element_pairs))
ranges = [[(0, 0)] * len(lengths) for _ in range(batch_size)]
offset = 0
# Inject some bad samples depending on the batch.
# Batch 2: length is set to 0. This way, 25% of the samples are empty.
# Batch 0-1: length is set to half the original length. This way, 50% of the
# samples are of mismatched length.
for pair in perm:
if pair[0] == 2:
length = 0
elif pair[0] <= 1:
length = lengths[pair[1]] // 2
else:
length = lengths[pair[1]]
ranges[pair[0]][pair[1]] = (offset, length)
offset += length
data = draw(
st.lists(
st.floats(min_value=-1.0, max_value=1.0), min_size=offset, max_size=offset
)
)
key = draw(st.permutations(range(offset)))
return (
np.array(data).astype(np.float32),
np.array(ranges),
np.array(lengths),
np.array(key).astype(np.int64),
)
def _to_sizes(size: int, min_element_size: int,
limit: int) -> Strategy[List[int]]:
max_sizes = [min_element_size] * size
indices = cycle(range(size))
for _ in range(limit - size * min_element_size):
max_sizes[next(indices)] += 1
sizes_ranges = [
range(min_element_size, max_element_size + 1)
for max_element_size in max_sizes
]
return (strategies.permutations([
strategies.sampled_from(sizes_range)
for sizes_range in sizes_ranges
]).flatmap(pack(strategies.tuples)).map(list))
def io_pair_strat_trivial_comp(draw):
n, node_list, output_node_list = draw(sampled_from(NODE_LIST_TRIVIAL))
output_strat = lists(sampled_from(output_node_list),
min_size=MIN_OUTPUT_LEN_TRIVIAL,
max_size=MAX_OUTPUT_LEN)
if n < 2:
return (DAG([]), draw(output_strat))
ordering = draw(permutations(node_list))
possible_edges = list(combinations(ordering, 2))
edges_strat = lists(sampled_from(possible_edges),
min_size=MIN_DAG_EDGES_TRIVIAL,
unique=True)
dag_strat = builds(DAG, edge_tuples=edges_strat)
return draw(tuples(dag_strat, output_strat))
def closed_object_set(draw):
ids = {
'unit': int_keys(draw),
'organization': uuid_keys(draw),
'department': uuid_keys(draw),
'ontologyword': int_keys(draw),
'ontologytree': int_keys(draw)
}
resources = {}
for key, identifiers in ids.items():
resources[key] = list(map(make_resource[key](draw, ids), ids[key]))
resources['ontologyword_details'] = []
for unit in resources['unit']:
for oid in draw(permutations(ids['ontologyword'])):
resources['ontologyword_details'].append(make_ontologyword_details(draw, unit['id'], oid))
return resources
from __future__ import absolute_import, division, print_function
from hypothesis import given
from hypothesis.errors import InvalidArgument
from hypothesis.strategies import permutations
from tests.common.debug import minimal
from tests.common.utils import fails_with
def test_can_find_non_trivial_permutation():
x = minimal(permutations(list(range(5))), lambda x: x[0] != 0)
assert x == [1, 0, 2, 3, 4]
@given(permutations(list(u"abcd")))
def test_permutation_values_are_permutations(perm):
assert len(perm) == 4
assert set(perm) == set(u"abcd")
@given(permutations([]))
def test_empty_permutations_are_empty(xs):
assert xs == []
@fails_with(InvalidArgument)
def test_cannot_permute_non_sequence_types():
permutations(set()).example()
def _structure_and_messages(structure):
messages = ActionStructure.to_eliot(structure, MemoryLogger())
return st.permutations(messages).map(
lambda permuted: (structure, permuted))
def test_cannot_permute_non_sequence_types():
permutations(set()).example()
top_level_deps = [
('NoRedInk/top-1', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/top-2', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/top-3', '1.0.0 <= v <= 1.0.0'),
]
spec_deps = [
('NoRedInk/top-1', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/top-2', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/spec-1', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/spec-2', '1.0.0 <= v <= 1.0.0'),
]
@given(top_level_keys=st.permutations(package_skeleton.keys()),
top_level_deps=st.permutations(top_level_deps),
spec_keys=st.permutations(package_skeleton.keys()),
spec_deps=st.permutations(spec_deps))
def test_spec_order_is_preserved(
tmpdir,
top_level_keys,
top_level_deps,
spec_keys,
spec_deps):
top_level_file = tmpdir.join('elm-package.json')
spec_file = tmpdir.join('spec-elm-package.json')
top_level = _make_package(top_level_keys, top_level_deps)
top_level_file.write(json.dumps(top_level))
def test_non_sequence_types_are_deprecated(data, xs):
p = data.draw(permutations(xs))
assert xs == set(p)
top_level_deps = [
('NoRedInk/top-1', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/top-2', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/top-3', '1.0.0 <= v <= 1.0.0'),
]
spec_deps = [
('NoRedInk/top-1', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/top-2', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/spec-1', '1.0.0 <= v <= 1.0.0'),
('NoRedInk/spec-2', '1.0.0 <= v <= 1.0.0'),
]
@given(top_level_deps=st.permutations(top_level_deps),
spec_deps=st.permutations(spec_deps))
def test_spec_order_is_preserved(
tmpdir,
top_level_deps,
spec_deps):
top_level_file = tmpdir.join('elm-native-package.json')
spec_file = tmpdir.join('spec-elm-native-package.json')
top_level = OrderedDict(top_level_deps)
top_level_file.write(json.dumps(top_level))
spec = OrderedDict(spec_deps)
spec_file.write(json.dumps(spec))
native_deps_sync.sync_versions(
def make_unit(uid):
# Required fields
result = {
'id': uid,
'accessibility_viewpoints': accessibility_viewpoints(draw),
'dept_id': str(draw(sampled_from(resource_ids['department']))),
'org_id': str(draw(sampled_from(resource_ids['organization']))),
'ontologytree_ids': draw(permutations(resource_ids['ontologytree'])),
'provider_type': draw(sampled_from(PROVIDER_TYPES)),
'organizer_type': draw(sampled_from(ORGANIZER_TYPES)),
'manual_coordinates': draw(booleans()),
# TODO: cannot test is_public=False until there is a mechanism
# for getting non-public units from the API.
'is_public': True,
# TODO: map to another field
}
result.update(translated_field(draw, 'name', allow_missing=False))
def add_optional_field(name, strategy):
val = draw(one_of(none(), strategy))
if val is not None:
event('unit.{}: optional field given value'.format(name))
result[name] = val
else:
event('unit.{}: optional field missing'.format(name))
def add_optional_text_field(name):
add_optional_field(name, text(max_size=50))
add_optional_field('address_city', sampled_from(MUNICIPALITIES))
add_optional_field('address_zip', text(max_size=10))
add_optional_field('organizer_business_id', text(max_size=10))
add_optional_field('organizer_name', text(max_size=10))
for field in ['accessibility_email',
'accessibility_www',
'email',
'fax',
'phone',
'picture_entrance_url',
'picture_url',
'streetview_entrance_url']:
add_optional_text_field(field)
add_optional_field('data_source_url', text(max_size=30))
result.update(translated_field(draw, 'address_postal_full', allow_missing=True))
result.update(translated_field(draw, 'call_charge_info', allow_missing=True))
result.update(translated_field(draw, 'desc', allow_missing=True))
result.update(translated_field(draw, 'picture_caption', allow_missing=True))
# Extra searchwords
add_extra_searchwords(draw, result)
add_optional_field('sources',
lists(make_source(), min_size=1, max_size=2))
has_coordinates = draw(booleans())
if has_coordinates:
result['longitude'] = draw(floats(min_value=24, max_value=26))
result['latitude'] = draw(floats(min_value=58, max_value=62))
return result
def election(draw, max_candidates=10):
candidates = list(range(draw(st.integers(2, max_candidates))))
return draw(
st.lists(st.permutations(candidates), min_size=1)
)
def test_can_find_non_trivial_permutation():
x = find(
permutations(list(range(5))), lambda x: x[0] != 0
)
assert x == [1, 0, 2, 3, 4]
#
# 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 find, given
from hypothesis.strategies import permutations
def test_can_find_non_trivial_permutation():
x = find(
permutations(list(range(5))), lambda x: x[0] != 0
)
assert x == [1, 0, 2, 3, 4]
@given(permutations(list(u'abcd')))
def test_permutation_values_are_permutations(perm):
assert len(perm) == 4
assert set(perm) == set(u'abcd')
@given(permutations([]))
def test_empty_permutations_are_empty(xs):
assert xs == []
