def hostnames(draw,
allow_leading_digit=True,
allow_idn=True): # pragma: no cover
# type: (DrawCallable, bool, bool) -> Text
"""
A strategy which generates host names.
@param allow_leading_digit: Whether to allow a leading digit in host names;
they were not allowed prior to RFC 1123.
@param allow_idn: Whether to allow non-ASCII characters as allowed by
internationalized domain names (IDNs).
"""
labels = draw(
lists(hostname_labels(allow_idn=allow_idn), min_size=1,
max_size=5).filter(
lambda ls: sum(len(l) for l in ls) + len(ls) - 1 <= 252))
name = u".".join(labels)
# Filter names that are not IDNA-encodable.
# We try pretty hard not to generate bogus names in the first place... but
# catching all cases is not trivial.
try:
idna_encode(name)
except IDNAError:
assume(False)
return name
def test_flip(self, cls, values, start, end, cow):
st.assume(start < end)
bm_before = cls(values, copy_on_write=cow)
bm_copy = cls(bm_before)
bm_after = bm_before.flip(start, end)
self.assertEqual(bm_before, bm_copy)
self.check_flip(bm_before, bm_after, start, end)
def test_constructor_copy(self, values, other_value):
st.assume(other_value not in values)
bitmap1 = BitMap(values)
bitmap2 = BitMap(bitmap1)
self.assertEqual(bitmap1, bitmap2)
bitmap1.add(other_value)
self.assertNotEqual(bitmap1, bitmap2)
def test_flip(self, cls, values, start, end, cow):
st.assume(start < end)
bm_before = cls(values, copy_on_write=cow)
bm_copy = cls(bm_before)
bm_after = bm_before.flip(start, end)
self.assertEqual(bm_before, bm_copy)
self.check_flip(bm_before, bm_after, start, end)
def test_flip_empty(self, values, start, end, cow):
st.assume(start >= end)
bm_before = BitMap(values, copy_on_write=cow)
bm_copy = BitMap(bm_before)
bm_after = bm_before.flip(start, end)
self.assertEqual(bm_before, bm_copy)
self.assertEqual(bm_before, bm_after)
def test_flip(self, values, start, end):
st.assume(start < end)
bm_before = BitMap(values)
bm_copy = BitMap(bm_before)
bm_after = bm_before.flip(start, end)
self.assertEqual(bm_before, bm_copy)
self.check_flip(bm_before, bm_after, start, end)
def test_points_from_polygon_and_line(pair):
"""A Line through the centre of a polygon should have two intersections"""
p, rp = pair
centre = rp.args[0]
assume(p != centre)
line = Line(p, centre)
assert len(EuclideanWorld([rp, line]).get_points()) == 2 + rp.args[2]
def test_serialization(self, values, other_value):
st.assume(other_value not in values)
old_bm = BitMap(values)
buff = old_bm.serialize()
new_bm = BitMap.deserialize(buff)
self.assertEqual(old_bm, new_bm)
old_bm.add(other_value)
self.assertNotEqual(old_bm, new_bm)
def test_slice_select(self, values, start, stop, step, cow):
st.assume(step != 0)
bitmap = BitMap(values, copy_on_write=cow)
values = list(bitmap) # enforce sorted order
expected = values[start:stop:step]
expected.sort()
observed = list(bitmap[start:stop:step])
self.assertEqual(expected, observed)
def test_jaccard_index(self, cls1, cls2, values1, values2, cow):
st.assume(len(values1) > 0 or len(values2) > 0)
self.bitmap1 = cls1(values1, copy_on_write=cow)
self.bitmap2 = cls2(values2, copy_on_write=cow)
real_value = float(len(self.bitmap1 & self.bitmap2)) / \
float(max(1, len(self.bitmap1 | self.bitmap2)))
estimated_value = self.bitmap1.jaccard_index(self.bitmap2)
self.assertAlmostEqual(real_value, estimated_value)
def test_jaccard_index(self, cls1, cls2, values1, values2, cow):
st.assume(len(values1) > 0 or len(values2) > 0)
self.bitmap1 = cls1(values1, copy_on_write=cow)
self.bitmap2 = cls2(values2, copy_on_write=cow)
real_value = float(len(self.bitmap1 & self.bitmap2)) / \
float(max(1, len(self.bitmap1 | self.bitmap2)))
estimated_value = self.bitmap1.jaccard_index(self.bitmap2)
self.assertAlmostEqual(real_value, estimated_value)
def test_constructor_copy(self, values, other_value, cow1, cow2):
st.assume(other_value not in values)
bitmap1 = BitMap(values, copy_on_write=cow1)
bitmap2 = BitMap(
bitmap1,
copy_on_write=cow2) # should be robust even if cow2 != cow1
self.assertEqual(bitmap1, bitmap2)
bitmap1.add(other_value)
self.assertNotEqual(bitmap1, bitmap2)
def geometry_collection(draw):
"""
To Do
-----
* bbox and foreign members
"""
geoms = draw(lists(geometries())) # can be empty
assume(len(geoms) != 1) # avoid single geom
return {'type': 'GeometryCollection', 'geometries': geoms}
def test_all_circles_two_points(p1, p2):
"""
Check whether `all_circles` yields all expected circles with two points
"""
assume(p1 != p2)
two_circles = EuclideanWorld.all_circles([p1, p2])
assert len(two_circles) == 2
r = p1.distance(p2)
assert Circle(p1, r) in two_circles
assert Circle(p2, r) in two_circles
def test_check_userdef_dist(self, positive_float, negative_float, word, rm):
assume(negative_float < 0)
Q = ciw.Simulation(
ciw.create_network_from_yml(
'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)
def test_check_userdef_dist(self, positive_float, negative_float, word,
rm):
assume(negative_float < 0)
Q = ciw.Simulation(
ciw.create_network_from_yml(
'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)
def test_check_userdef_dist(self, positive_float, negative_float, word,
rm):
assume(negative_float < 0)
Q = ciw.Simulation(
ciw.load_parameters(
'ciw/tests/datafortesting/logs_test_for_simulation/parameters.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)
def test_stochastic(self, p):
assume(0 < p < 1)
p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
match = axelrod.Match((p1, p2), 5)
self.assertFalse(match._stochastic)
match = axelrod.Match((p1, p2), 5, noise=p)
self.assertTrue(match._stochastic)
p1 = axelrod.Random()
match = axelrod.Match((p1, p2), 5)
self.assertTrue(match._stochastic)
def test_stochastic(self, p):
assume(0 < p < 1)
p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
match = axelrod.Match((p1, p2), 5)
self.assertFalse(match._stochastic)
match = axelrod.Match((p1, p2), 5, noise=p)
self.assertTrue(match._stochastic)
p1 = axelrod.Random()
match = axelrod.Match((p1, p2), 5)
self.assertTrue(match._stochastic)
def test_cache_update_required(self, p):
assume(0 < p < 1)
p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
match = axelrod.Match((p1, p2), 5, noise=p)
self.assertFalse(match._cache_update_required)
cache = DeterministicCache()
cache.mutable = False
match = axelrod.Match((p1, p2), 5, deterministic_cache=cache)
self.assertFalse(match._cache_update_required)
match = axelrod.Match((p1, p2), 5)
self.assertTrue(match._cache_update_required)
p1 = axelrod.Random()
match = axelrod.Match((p1, p2), 5)
self.assertFalse(match._cache_update_required)
def test_cache_update_required(self, p):
assume(0 < p < 1)
p1, p2 = axelrod.Cooperator(), axelrod.Cooperator()
match = axelrod.Match((p1, p2), 5, noise=p)
self.assertFalse(match._cache_update_required)
cache = DeterministicCache()
cache.mutable = False
match = axelrod.Match((p1, p2), 5, deterministic_cache=cache)
self.assertFalse(match._cache_update_required)
match = axelrod.Match((p1, p2), 5)
self.assertTrue(match._cache_update_required)
p1 = axelrod.Random()
match = axelrod.Match((p1, p2), 5)
self.assertFalse(match._cache_update_required)
def hostname_labels(draw, allow_idn=True): # pragma: no cover
# type: (DrawCallable, bool) -> Text
"""
A strategy which generates host name labels.
@param allow_idn: Whether to allow non-ASCII characters as allowed by
internationalized domain names (IDNs).
"""
if allow_idn:
label = draw(idna_text(min_size=1, max_size=63))
try:
label.encode("ascii")
except UnicodeEncodeError:
# If the label doesn't encode to ASCII, then we need to check the
# length of the label after encoding to punycode and adding the
# xn-- prefix.
while len(label.encode("punycode")) > 63 - len("xn--"):
# Rather than bombing out, just trim from the end until it is
# short enough, so hypothesis doesn't have to generate new
# data.
label = label[:-1]
else:
label = draw(
text(min_size=1,
max_size=63,
alphabet=unicode(ascii_letters + digits + u"-")))
# Filter invalid labels.
# It would be better not to generate bogus labels in the first place... but
# that's not trivial.
try:
check_label(label)
except UnicodeError:
assume(False)
return label
def test_all_circles_two_points(p1, p2, p3):
"""
Check whether `all_circles` yields all expected circles with three points
"""
assume(p1 != p2)
assume(p2 != p3)
assume(p3 != p1)
two_circles = list(EuclideanWorld.all_circles([p1, p2, p3]))
assert len(two_circles) <= 6
assert len(two_circles) >= 3
assert Circle(p1, p1.distance(p2)) in two_circles
assert Circle(p1, p1.distance(p3)) in two_circles
assert Circle(p2, p2.distance(p1)) in two_circles
assert Circle(p2, p2.distance(p3)) in two_circles
assert Circle(p3, p3.distance(p1)) in two_circles
assert Circle(p3, p3.distance(p2)) in two_circles
def test_flip_inplace(self, values, start, end):
st.assume(start < end)
bm_before = BitMap(values)
bm_after = BitMap(bm_before)
bm_after.flip_inplace(start, end)
self.check_flip(bm_before, bm_after, start, end)
def test_slice_select_none(self, cls, values, start, stop, step, cow):
st.assume(step != 0)
self.check_slice(cls, values, start, stop, step, cow)
def test_flip_inplace_empty(self, values, start, end):
st.assume(start >= end)
bm_before = BitMap(values)
bm_after = BitMap(bm_before)
bm_after.flip_inplace(start, end)
self.assertEqual(bm_before, bm_after)
def test_flip_inplace_empty(self, values, start, end, cow):
st.assume(start >= end)
bm_before = BitMap(values, copy_on_write=cow)
bm_after = BitMap(bm_before)
bm_after.flip_inplace(start, end)
self.assertEqual(bm_before, bm_after)
def test_max(self, cls, values, cow):
st.assume(len(values) > 0)
bitmap = cls(values, copy_on_write=cow)
self.assertEqual(bitmap.max(), max(values))
def test_check_userdef_dist(self, positive_float, negative_float, word, rm):
assume(negative_float < 0)
Q = ciw.Simulation(ciw.load_parameters('ciw/tests/datafortesting/logs_test_for_simulation/parameters.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)
def testArgs(self, data, endpoint, resource_id):
assume(data != dict())
cache.save(data, endpoint, resource_id)
self.assertEqual(data, cache.load(endpoint, resource_id))
def test_hash_uneq(self, values1, values2):
"""This test as a non null (but extremly low) probability to fail."""
bitmap1 = FrozenBitMap(values1)
bitmap2 = FrozenBitMap(values2)
st.assume(bitmap1 != bitmap2)
self.assertNotEqual(hash(bitmap1), hash(bitmap2))
def test_hash_uneq(self, values1, values2):
"""This test as a non null (but extremly low) probability to fail."""
bitmap1 = FrozenBitMap(values1)
bitmap2 = FrozenBitMap(values2)
st.assume(bitmap1 != bitmap2)
self.assertNotEqual(hash(bitmap1), hash(bitmap2))
def test_max(self, cls, values, cow):
st.assume(len(values) > 0)
bitmap = cls(values, copy_on_write=cow)
self.assertEqual(bitmap.max(), max(values))
def testArg_resource_id_Text(self, data, endpoint, resource_id):
assume(data != dict())
with self.assertRaises(ValueError):
cache.save(data, endpoint, resource_id)
def test_slice_select_none(self, cls, values, start, stop, step, cow):
st.assume(step != 0)
self.check_slice(cls, values, start, stop, step, cow)
def test_slice_select_empty(self, cls, values, start, stop, step, cow):
st.assume(step != 0)
st.assume(len(range(start, stop, step)) == 0)
self.check_slice(cls, values, start, stop, step, cow)
def test_bitmap_unequality(self, cls1, cls2, values1, values2, cow):
st.assume(set(values1) != set(values2))
bitmap1 = cls1(values1, copy_on_write=cow)
bitmap2 = cls2(values2, copy_on_write=cow)
self.assertNotEqual(bitmap1, bitmap2)
def test_slice_select_empty(self, cls, values, start, stop, step, cow):
st.assume(step != 0)
st.assume(len(range(start, stop, step)) == 0)
self.check_slice(cls, values, start, stop, step, cow)
def test_flip_inplace(self, values, start, end, cow):
st.assume(start < end)
bm_before = BitMap(values, copy_on_write=cow)
bm_after = BitMap(bm_before)
bm_after.flip_inplace(start, end)
self.check_flip(bm_before, bm_after, start, end)
def test_bitmap_unequality(self, cls1, cls2, values1, values2, cow):
st.assume(set(values1) != set(values2))
bitmap1 = cls1(values1, copy_on_write=cow)
bitmap2 = cls2(values2, copy_on_write=cow)
self.assertNotEqual(bitmap1, bitmap2)
def test_bitmap_unequality(self, values1, values2):
st.assume(set(values1) != set(values2))
bitmap1 = BitMap(values1)
bitmap2 = BitMap(values2)
self.assertNotEqual(bitmap1, bitmap2)
def testArg_subresource_Text(self, data, endpoint, resource_id,
subresource):
assume(data != dict())
cache.save(data, endpoint, resource_id, subresource)
self.assertEqual(data, cache.load(endpoint, resource_id, subresource))
def testEnv_CacheFileNotFound(self, data, endpoint, resource_id):
assume(data != dict())
os.remove(cache.API_CACHE)
self.assertIsNone(cache.save(data, endpoint, resource_id))
