def test_union():
u = Union({1, 2, 3}, {3, 4, 5})
assert u._children == [SetWrapper({1, 2, 3}), SetWrapper({3, 4, 5})]
assert set(u.enumerate()) == {1, 2, 3, 4, 5}
assert set(u.enumerate(lazy=True)) == {1, 2, 3, 4, 5}
assert u.size() == 5
assert u.size_limits() == (3, 6)
assert feq(u.expected_size(), 4.5)
assert u.hasmember(1)
assert u.hasmember(5)
assert not u.hasmember(6)
for k in range(SAMPLES):
item = u.sample()
with on_error(elog, u.hasmember, (u, item)):
assert u.hasmember(item)
item = u.sample(lazy=True)
assert u.hasmember(item)
assert u.to_set() == {1, 2, 3, 4, 5}
u2 = Union(Range(1, 3), Range(5, 7), Range(6, 9), NULL, {10}, {13})
assert u2.to_set() == {1, 2, 3, 5, 6, 7, 8, 9, 10, 13}
assert sorted(u2.enumerate()) == [1, 2, 3, 5, 6, 7, 8, 9, 10, 13]
assert len(list(u2.enumerate(max_enumerate = 2))) == 2
for k in range(SAMPLES):
item = u2.sample()
with on_error(elog, u2.hasmember, (u2, item)):
assert u2.hasmember(item)
assert u2.display() == '([1, 3] | [5, 7] | [6, 9] | {} | {10} | {13})'
# Sanity Check
class Foo(object): pass
class F1(Foo): pass
u = Union(range(10), Range(10, 20), ClassWrapper(Foo))
assert u.size() == 23
assert feq(u.expected_size(), 17)
us = u.to_set()
assert len(us) == 23
assert us == set(range(10)) | set(range(10, 21)) | set([Foo, F1])
# Edge Cases
assert list(Union().enumerate()) == []
assert Union().to_set() == set()
assert Union(Range(1, 2)).to_set() == {1, 2}
assert Union({2, 4}).to_set() == {2, 4}
def test_range():
r1 = Range(1, 5)
r2 = Range(2, 5)
assert r1.display() == '[1, 5]'
assert r1.size() == 5
assert r2.issubset(r1)
assert r1.issuperset(r2)
assert not r1.issubset(r2)
assert not r2.issuperset(r1)
assert r1.hasmember(3)
assert r2.hasmember(3)
assert r1.hasmember(4)
assert r1.hasmember(5)
assert not r1.hasmember(0)
assert not r2.hasmember(1)
for k in range(SAMPLES):
samp = r1.sample()
with on_error(elog, r1.hasmember, (r1, samp)):
assert r1.hasmember(samp)
assert sorted(list(r1.enumerate())) == [1, 2, 3, 4, 5]
assert r1.to_set() == {1, 2, 3, 4, 5}
assert len(list(r1.enumerate(max_enumerate=3))) == 3
r1.validate()
r2.validate()
assert_raises(ValueError, Range(2, 1).validate)
def test_sequence():
int_seq = Sequence(int)
assert int_seq == Sequence(int)
assert int_seq != Sequence(float)
assert int_seq.query([1, 2, 3])
assert not int_seq.query([1.2, 2, 3])
assert int_seq.query((1, 2, 3))
assert not int_seq.query(1)
int_list = List(int)
assert int_list.query([1, 2, 3])
assert not int_list.query([1.2, 2, 3])
assert not int_list.query((1, 2, 3))
for k in xrange(SAMPLES):
l = int_list.generate()
with on_error(elog, int_list.check, (l, )):
int_list.check(l)
bad_list = (1.2, '3', 4)
good_list = [1, 2, 3]
assert int_list.coerce(bad_list) == [1, 3, 4]
assert int_list.coerce(good_list) is good_list
assert int_list.display() == 'list(int)'
assert int_list.rst() == '*list* (*int*)'
def test_iteration_length():
from syn.base_utils import iteration_length
assert iteration_length(5) == 5
assert iteration_length(5, 0) == 5
assert iteration_length(5, 1) == 4
assert iteration_length(5, 0, 2) == 3
for k in range(SAMPLES):
N = rand_int(0, 20)
start = rand_int(0, 20)
step = rand_int(1, 5)
with on_error(elog, iteration_length, (N, start, step)):
assert iteration_length(N, start, step) == \
len(list(range(start, N, step)))
assert iteration_length(0) == 0
assert iteration_length(10, 10) == 0
assert iteration_length(10, 20) == 0
assert_raises(ValueError, iteration_length, -1)
assert_raises(ValueError, iteration_length, 10, 20, -1)
assert iteration_length(10, -1, 1) == 1
assert iteration_length(10, -1, 10) == 1
assert iteration_length(10, -1, -1) == 10
assert iteration_length(10, -1, -3) == 4
assert iteration_length(10, 1, 3) == 3
assert iteration_length(10, 5, -1) == 6
assert_raises(ValueError, iteration_length, 10, -11)
def test_sequence():
int_seq = Sequence(int)
assert int_seq == Sequence(int)
assert int_seq != Sequence(float)
assert int_seq.query([1, 2, 3])
assert not int_seq.query([1.2, 2, 3])
assert int_seq.query((1, 2, 3))
assert not int_seq.query(1)
int_list = List(int)
assert int_list.query([1, 2, 3])
assert not int_list.query([1.2, 2, 3])
assert not int_list.query((1, 2, 3))
for k in xrange(SAMPLES):
l = int_list.generate()
with on_error(elog, int_list.check, (l,)):
int_list.check(l)
bad_list = (1.2, '3', 4)
good_list = [1, 2, 3]
assert int_list.coerce(bad_list) == [1, 3, 4]
assert int_list.coerce(good_list) is good_list
assert int_list.display() == 'list(int)'
assert int_list.rst() == '*list* (*int*)'
def test_classwrapper():
class Foo(object): pass
class F1(Foo): pass
class F2(F1): pass
cw = ClassWrapper(Foo)
assert cw.display() == 'ClassWrapper(Foo)'
assert cw.size() == 3
for k in range(SAMPLES):
item = cw.sample()
with on_error(elog, cw.hasmember, (cw, item)):
assert cw.hasmember(item)
cwset = cw.to_set()
assert len(cwset) >= 3
assert Foo in cwset
assert F1 in cwset
assert F2 in cwset
cwlist = list(cw.enumerate(max_enumerate = 2))
assert len(cwlist) == 2
assert all(issubclass(x, Foo) for x in cwlist)
assert all(issubclass(x, Foo) for x in cw.to_set())
def test_range():
r1 = Range(1, 5)
r2 = Range(2, 5)
assert r1.display() == '[1, 5]'
assert r1.size() == 5
assert r2.issubset(r1)
assert r1.issuperset(r2)
assert not r1.issubset(r2)
assert not r2.issuperset(r1)
assert r1.hasmember(3)
assert r2.hasmember(3)
assert r1.hasmember(4)
assert r1.hasmember(5)
assert not r1.hasmember(0)
assert not r2.hasmember(1)
for k in range(SAMPLES):
samp = r1.sample()
with on_error(elog, r1.hasmember, (r1, samp)):
assert r1.hasmember(samp)
assert sorted(list(r1.enumerate())) == [1, 2, 3, 4, 5]
assert r1.to_set() == {1, 2, 3, 4, 5}
assert len(list(r1.enumerate(max_enumerate = 3))) == 3
r1.validate()
r2.validate()
assert_raises(ValueError, Range(2, 1).validate)
def test_classwrapper():
class Foo(object):
pass
class F1(Foo):
pass
class F2(F1):
pass
cw = ClassWrapper(Foo)
assert cw.display() == 'ClassWrapper(Foo)'
assert cw.size() == 3
for k in range(SAMPLES):
item = cw.sample()
with on_error(elog, cw.hasmember, (cw, item)):
assert cw.hasmember(item)
cwset = cw.to_set()
assert len(cwset) >= 3
assert Foo in cwset
assert F1 in cwset
assert F2 in cwset
cwlist = list(cw.enumerate(max_enumerate=2))
assert len(cwlist) == 2
assert all(issubclass(x, Foo) for x in cwlist)
assert all(issubclass(x, Foo) for x in cw.to_set())
def test_iteration_length():
from syn.base_utils import iteration_length
assert iteration_length(5) == 5
assert iteration_length(5, 0) == 5
assert iteration_length(5, 1) == 4
assert iteration_length(5, 0, 2) == 3
for k in range(SAMPLES):
N = rand_int(0, 20)
start = rand_int(0, 20)
step = rand_int(1, 5)
with on_error(elog, iteration_length, (N, start, step)):
assert iteration_length(N, start, step) == \
len(list(range(start, N, step)))
assert iteration_length(0) == 0
assert iteration_length(10, 10) == 0
assert iteration_length(10, 20) == 0
assert_raises(ValueError, iteration_length, -1)
assert_raises(ValueError, iteration_length, 10, 20, -1)
assert iteration_length(10, -1, 1) == 1
assert iteration_length(10, -1, 10) == 1
assert iteration_length(10, -1, -1) == 10
assert iteration_length(10, -1, -3) == 4
assert iteration_length(10, 1, 3) == 3
assert iteration_length(10, 5, -1) == 6
assert_raises(ValueError, iteration_length, 10, -11)
def test_rand_hashable():
from syn.base_utils import rand_hashable
for k in xrange(SAMPLES):
x = rand_hashable()
with on_error(elog, is_hashable, (x,)):
assert is_hashable(x)
def test_sequence():
l = [1, 2.3, 'abc']
t = Type.dispatch(l)
assert isinstance(t, Sequence)
assert type(t) is List
if PY2:
assert set(hashable(l)) == set(t.hashable()) == \
{'__builtin__.list', 1, 2.3, 'abc'}
else:
assert set(hashable(l)) == set(t.hashable()) == \
{'builtins.list', 1, 2.3, 'abc'}
assert not is_hashable(l)
assert is_hashable(hashable(l))
l1 = [1, 2, 3]
l2 = [1, 2, 3, 4]
l3 = [1, 2, 4]
assert find_ne(l1, l2) == DifferentLength(l1, l2)
assert find_ne(l2, l1) == DifferentLength(l2, l1)
assert find_ne(l1, l3) == DiffersAtIndex(l1, l3, 2)
e1 = eval(estr(l1))
assert_equivalent(e1, l1)
tup = tuple(l)
examine_sequence(List, l)
examine_sequence(Tuple, tup)
examine_sequence(Tuple, ([
-1839677305294322342, b'', b'\x05l\xbf', b'0\xcfXp\xaa',
-8468204163727415930
], True))
for cls in subclasses(Sequence):
for k in xrange(SAMPLES):
val = cls.generate()
with on_error(elog, examine_sequence, (cls, val)):
hangwatch(1, examine_sequence, cls, val)
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10, step=100):
assert type(item) is cls.type
assert item != last
buf.append(item)
last = item
assert is_unique(buf)
assert list(visit(l, enumerate=True)) == [(0, 1), (1, 2.3), (2, 'abc')]
assert list(visit([])) == []
l = [1, 2, (3, 4)]
assert primitive_form(l) == [1, 2, [3, 4]]
assert collect(l) == primitive_form(l)
def test_sequence():
l = [1, 2.3, 'abc']
t = Type.dispatch(l)
assert isinstance(t, Sequence)
assert type(t) is List
if PY2:
assert set(hashable(l)) == set(t.hashable()) == \
{'__builtin__.list', 1, 2.3, 'abc'}
else:
assert set(hashable(l)) == set(t.hashable()) == \
{'builtins.list', 1, 2.3, 'abc'}
assert not is_hashable(l)
assert is_hashable(hashable(l))
l1 = [1, 2, 3]
l2 = [1, 2, 3, 4]
l3 = [1, 2, 4]
assert find_ne(l1, l2) == DifferentLength(l1, l2)
assert find_ne(l2, l1) == DifferentLength(l2, l1)
assert find_ne(l1, l3) == DiffersAtIndex(l1, l3, 2)
e1 = eval(estr(l1))
assert_equivalent(e1, l1)
tup = tuple(l)
examine_sequence(List, l)
examine_sequence(Tuple, tup)
examine_sequence(Tuple, ([-1839677305294322342, b'', b'\x05l\xbf',
b'0\xcfXp\xaa', -8468204163727415930], True))
for cls in subclasses(Sequence):
for k in xrange(SAMPLES):
val = cls.generate()
with on_error(elog, examine_sequence, (cls, val)):
hangwatch(1, examine_sequence, cls, val)
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10, step=100):
assert type(item) is cls.type
assert item != last
buf.append(item)
last = item
assert is_unique(buf)
assert list(visit(l, enumerate=True)) == [(0, 1), (1, 2.3), (2, 'abc')]
assert list(visit([])) == []
l = [1, 2, (3, 4)]
assert primitive_form(l) == [1, 2, [3, 4]]
assert collect(l) == primitive_form(l)
def test_rand_list():
from syn.base_utils import rand_list, is_flat
lists = [rand_list() for k in xrange(SAMPLESIII)]
assert all(isinstance(l, list) for l in lists)
for k in xrange(SAMPLESII):
l = rand_list(max_depth=0)
with on_error(elog, is_flat, (l,)):
assert is_flat(l)
def test_setwrapper():
s1 = SetWrapper([1, 2, 3])
s2 = {3, 4, 5}
s3 = SetWrapper(s2)
s4 = SetWrapper(set([1]))
assert s4.display() == '{1}'
assert s1.size() == s3.size() == 3
assert s1.size_limits() == (3, 3)
assert s1.union(s3) == SetWrapper([1, 2, 3, 4, 5])
assert s1.union(s2) == SetWrapper([1, 2, 3, 4, 5])
assert s1.union(s2, NULL) == SetWrapper([1, 2, 3, 4, 5])
assert_raises(TypeError, s1.union, [3, 4])
assert s1.intersection(s3) == SetWrapper([3])
assert s1.intersection(s2) == SetWrapper([3])
assert_raises(TypeError, s1.intersection, [3, 4])
assert s1.difference(s3) == SetWrapper([1, 2])
assert s1.difference(s2) == SetWrapper([1, 2])
assert_raises(TypeError, s1.difference, [3, 4])
universe = {1, 2, 3, 4, 5}
assert s1.complement(universe) == SetWrapper([4, 5])
assert s1.complement(SetWrapper(universe)) == SetWrapper([4, 5])
assert_raises(TypeError, s1.complement, [3, 4])
assert s1.issubset(universe)
assert not s1.issubset(s3)
assert_raises(TypeError, s1.issubset, [3, 4])
assert SetWrapper(universe).issuperset(s1)
assert not s1.issuperset(s3)
assert_raises(TypeError, s1.issuperset, [3, 4])
assert s1.hasmember(3)
assert not s1.hasmember(4)
for k in range(SAMPLES):
samp = s1.sample()
with on_error(elog, s1.hasmember, (s1, samp)):
assert s1.hasmember(samp)
item = s1.get_one()
assert s1.hasmember(item)
assert sorted(list(s1.enumerate())) == [1, 2, 3]
assert s1.to_set() == {1, 2, 3}
assert len(list(s1.enumerate(max_enumerate=2))) == 2
def test_string():
s = u'abc'
t = Type.dispatch(s)
assert isinstance(t, String)
if PY2:
assert type(t) is Unicode
examine_string(Unicode, s)
else:
assert type(t) is String
examine_string(String, s)
assert hashable(s) == t.hashable() == s
assert is_hashable(s)
assert is_hashable(hashable(s))
assert find_ne('abc', 'abcd') == DifferentLength('abc', 'abcd')
assert find_ne('abcd', 'abc') == DifferentLength('abcd', 'abc')
assert find_ne('abc', 'abd') == DiffersAtIndex('abc', 'abd', 2)
for cls in subclasses(String, [String]):
if cls.type is None or cls is Basestring:
continue
for k in xrange(SAMPLES):
val = generate(cls.type)
with on_error(elog, examine_string, (cls, val)):
examine_string(cls, val)
x = 0
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10, step=100):
assert type(item) is cls.type
assert item != last
buf.append(item)
last = item
x += 100
assert is_unique(buf)
# estr potential edge cases
cases = [
"abc'de\r7fghi", "\x00", "\\", "\'", '\"', '\a', '\b', '\t', '\v',
u'\u2013', '\\u2'
]
for case in cases:
assert eval(estr(case)) == case
def test_setwrapper():
s1 = SetWrapper([1, 2, 3])
s2 = {3, 4, 5}
s3 = SetWrapper(s2)
s4 = SetWrapper(set([1]))
assert s4.display() == '{1}'
assert s1.size() == s3.size() == 3
assert s1.size_limits() == (3, 3)
assert s1.union(s3) == SetWrapper([1,2,3,4,5])
assert s1.union(s2) == SetWrapper([1,2,3,4,5])
assert s1.union(s2, NULL) == SetWrapper([1,2,3,4,5])
assert_raises(TypeError, s1.union, [3, 4])
assert s1.intersection(s3) == SetWrapper([3])
assert s1.intersection(s2) == SetWrapper([3])
assert_raises(TypeError, s1.intersection, [3, 4])
assert s1.difference(s3) == SetWrapper([1, 2])
assert s1.difference(s2) == SetWrapper([1, 2])
assert_raises(TypeError, s1.difference, [3, 4])
universe = {1, 2, 3, 4, 5}
assert s1.complement(universe) == SetWrapper([4, 5])
assert s1.complement(SetWrapper(universe)) == SetWrapper([4,5])
assert_raises(TypeError, s1.complement, [3, 4])
assert s1.issubset(universe)
assert not s1.issubset(s3)
assert_raises(TypeError, s1.issubset, [3, 4])
assert SetWrapper(universe).issuperset(s1)
assert not s1.issuperset(s3)
assert_raises(TypeError, s1.issuperset, [3, 4])
assert s1.hasmember(3)
assert not s1.hasmember(4)
for k in range(SAMPLES):
samp = s1.sample()
with on_error(elog, s1.hasmember, (s1, samp)):
assert s1.hasmember(samp)
item = s1.get_one()
assert s1.hasmember(item)
assert sorted(list(s1.enumerate())) == [1, 2, 3]
assert s1.to_set() == {1, 2, 3}
assert len(list(s1.enumerate(max_enumerate = 2))) == 2
def test_typewrapper():
tw = TypeWrapper(int)
assert tw.display() == 'TypeWrapper(int)'
assert tw.size() == float('inf')
for k in range(SAMPLES):
item = tw.sample()
with on_error(elog, tw.hasmember, (tw, item)):
assert tw.hasmember(item)
twlist = list(tw.enumerate(max_enumerate = 30))
assert len(twlist) == 30
assert all(isinstance(x, int) for x in twlist)
assert all(isinstance(x, int) for x in tw.to_set())
def test_typewrapper():
tw = TypeWrapper(int)
assert tw.display() == 'TypeWrapper(int)'
assert tw.size() == float('inf')
for k in range(SAMPLES):
item = tw.sample()
with on_error(elog, tw.hasmember, (tw, item)):
assert tw.hasmember(item)
twlist = list(tw.enumerate(max_enumerate=30))
assert len(twlist) == 30
assert all(isinstance(x, int) for x in twlist)
assert all(isinstance(x, int) for x in tw.to_set())
def test_string():
s = u'abc'
t = Type.dispatch(s)
assert isinstance(t, String)
if PY2:
assert type(t) is Unicode
examine_string(Unicode, s)
else:
assert type(t) is String
examine_string(String, s)
assert hashable(s) == t.hashable() == s
assert is_hashable(s)
assert is_hashable(hashable(s))
assert find_ne('abc', 'abcd') == DifferentLength('abc', 'abcd')
assert find_ne('abcd', 'abc') == DifferentLength('abcd', 'abc')
assert find_ne('abc', 'abd') == DiffersAtIndex('abc', 'abd', 2)
for cls in subclasses(String, [String]):
if cls.type is None or cls is Basestring:
continue
for k in xrange(SAMPLES):
val = generate(cls.type)
with on_error(elog, examine_string, (cls, val)):
examine_string(cls, val)
x = 0
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10, step=100):
assert type(item) is cls.type
assert item != last
buf.append(item)
last = item
x += 100
assert is_unique(buf)
# estr potential edge cases
cases = ["abc'de\r7fghi", "\x00", "\\", "\'", '\"', '\a', '\b', '\t', '\v',
u'\u2013', '\\u2']
for case in cases:
assert eval(estr(case)) == case
def test_mapping():
d = dict(a = 1, b = 2.3)
t = Type.dispatch(d)
assert isinstance(t, Mapping)
assert type(t) is Dict
if PY2:
assert set(hashable(d)) == set(t.hashable()) == \
{'__builtin__.dict', ('a', 1), ('b', 2.3)}
else:
assert set(hashable(d)) == set(t.hashable()) == \
{'builtins.dict', ('a', 1), ('b', 2.3)}
d1 = dict(a=1, b=2)
d2 = dict(a=1, b=2, c=3)
d3 = dict(a=1, b=3)
assert find_ne(d1, d2) == KeyDifferences(d1, d2)
assert find_ne(d2, d1) == KeyDifferences(d2, d1)
assert find_ne(d1, d3) == DiffersAtKey(d1, d3, 'b')
e1 = eval(estr(d1))
assert_equivalent(e1, d1)
assert not is_hashable(d)
assert is_hashable(hashable(d))
examine_mapping(Dict, d)
for cls in subclasses(Mapping):
for k in xrange(SAMPLES):
val = cls.generate()
with on_error(elog, examine_mapping, (cls, val)):
hangwatch(1, examine_mapping, cls, val)
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10, step=100):
assert type(item) is cls.type
assert item != last
buf.append(item)
last = item
assert is_unique(buf)
d = dict(a=1, b=[1, 2, (3, 4)])
assert primitive_form(d) == dict(a=1, b=[1, 2, [3, 4]])
assert collect(d) == primitive_form(d)
def test_strrange():
s = StrRange('a', u'c')
assert s.lb == 97
assert s.ub == 99
assert s.display() == '[a, c]'
assert s.hasmember('a')
assert s.hasmember(u'a')
assert not s.hasmember('d')
assert_raises(TypeError, s.hasmember, 97)
for k in range(SAMPLES):
item = s.sample()
with on_error(elog, s.hasmember, (s, item)):
assert s.hasmember(item)
assert sorted(s.enumerate()) == ['a', 'b', 'c']
assert s.to_set() == {'a', 'b', 'c'}
def test_strrange():
s = StrRange('a', u'c')
assert s.lb == 97
assert s.ub == 99
assert s.display() == '[a, c]'
assert s.hasmember('a')
assert s.hasmember(u'a')
assert not s.hasmember('d')
assert_raises(TypeError, s.hasmember, 97)
for k in range(SAMPLES):
item = s.sample()
with on_error(elog, s.hasmember, (s, item)):
assert s.hasmember(item)
assert sorted(s.enumerate()) == ['a', 'b', 'c']
assert s.to_set() == {'a', 'b', 'c'}
def test_difference():
d = Difference({1, 2, 3}, {2, 3, 4})
assert d._children == [SetWrapper({1, 2, 3}), SetWrapper({2, 3, 4})]
assert set(d.enumerate()) == {1}
assert set(d.lazy_enumerate()) == {1}
assert d.size() == 1
assert d.size_limits() == (0, 3)
assert Difference({1, 2}, {1, 2, 3}).size_limits() == (0, 2)
assert d.hasmember(1)
assert not d.hasmember(2)
assert not d.hasmember(4)
for k in range(SAMPLES):
item = d.sample()
with on_error(elog, d.hasmember, (d, item)):
assert d.hasmember(item)
item = d.lazy_sample()
assert d.hasmember(item)
assert d.to_set() == {1}
d = Difference(Range(1, 5), Range(2, 3))
assert d.to_set() == {1, 4, 5}
assert d.display() == '([1, 5] - [2, 3])'
d = Difference(Range(1, 5), Range(3, 7))
assert d.to_set() == {1, 2}
d = Difference(Range(1, 5), {4, 5, 6})
assert d.to_set() == {1, 2, 3}
d = Difference({1, 2}, {1, 2, 3})
assert d.to_set() == set()
assert_raises(ValueError, d.lazy_sample)
# Test lazy_enumerate
d = Difference(Range(0, 100000), Range(100, 200))
assert list(d.lazy_enumerate(max_enumerate=10)) == range(10)
def test_product():
p = Product(Range(1, 5), Range(6, 10), Range(11, 15))
ps = p.to_set()
assert (1, 6, 11) in ps
assert (5, 6, 11) in ps
assert (5, 10, 11) in ps
assert (5, 10, 15) in ps
assert p.display() == '([1, 5] x [6, 10] x [11, 15])'
assert feq(p.expected_size(), 125)
assert not p.hasmember((0, 6, 11))
for k in range(SAMPLES):
item = p.sample()
with on_error(elog, p.hasmember, (p, item)):
assert p.hasmember(item)
p = Product({1}, {2}, {3})
assert p.to_set() == set([(1, 2, 3)])
assert p.sample() == (1, 2, 3)
def test_numeric():
x = 1
t = Type.dispatch(x)
assert isinstance(t, Numeric)
assert type(t) is Int
assert hashable(x) == x
examine_numeric(Int, x)
for cls in subclasses(Numeric):
if cls.type is None:
continue
for k in xrange(SAMPLES):
val = generate(cls.type)
with on_error(elog, examine_numeric, (cls, val)):
examine_numeric(cls, val)
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10):
assert type(item) is cls.type
assert item != last
buf.append(item)
if last is None:
# These need to be here under enumerate_ b/c of float equality issues
eitem = eval(estr(item))
assert eitem == item
assert type(eitem) is cls.type
last = item
if cls.type not in {
bool,
}:
assert is_unique(buf)
else:
assert not is_unique(buf)
def test_set():
s = frozenset([1, 2.3, 'abc'])
t = Type.dispatch(s)
assert isinstance(t, Set)
assert type(t) is FrozenSet
assert hashable(s) == t.hashable() == s
assert is_hashable(s)
assert is_hashable(hashable(s))
s1 = {1, 2, 3}
s2 = {2, 3, 4}
assert find_ne(s1, s2) == SetDifferences(s1, s2)
e1 = eval(estr(s1))
assert_equivalent(e1, s1)
examine_set(Set, set(s))
examine_set(FrozenSet, s)
for cls in subclasses(Set, [Set]):
for k in xrange(SAMPLES):
val = cls.generate()
with on_error(elog, examine_set, (cls, val)):
hangwatch(1, examine_set, cls, val)
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10, step=100):
assert type(item) is cls.type
assert item != last
buf.append(item)
last = item
assert is_unique(buf)
s = {1, 2, (3, 4)}
assert primitive_form(s) == [1, 2, [3, 4]]
assert collect(s) == primitive_form(s)
def test_set():
s = frozenset([1, 2.3, 'abc'])
t = Type.dispatch(s)
assert isinstance(t, Set)
assert type(t) is FrozenSet
assert hashable(s) == t.hashable() == s
assert is_hashable(s)
assert is_hashable(hashable(s))
s1 = {1, 2, 3}
s2 = {2, 3, 4}
assert find_ne(s1, s2) == SetDifferences(s1, s2)
e1 = eval(estr(s1))
assert_equivalent(e1, s1)
examine_set(Set, set(s))
examine_set(FrozenSet, s)
for cls in subclasses(Set, [Set]):
for k in xrange(SAMPLES):
val = cls.generate()
with on_error(elog, examine_set, (cls, val)):
hangwatch(1, examine_set, cls, val)
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10, step=100):
assert type(item) is cls.type
assert item != last
buf.append(item)
last = item
assert is_unique(buf)
s = {1, 2, (3, 4)}
assert primitive_form(s) == [1, 2, [3, 4]]
assert collect(s) == primitive_form(s)
def test_set():
from syn.sets.b import Range
t = Set(Range(1, 5))
assert t == Set(Range(1, 5))
assert t != Set(Range(0, 5))
assert Type.dispatch(t) is t
assert t.query(1)
assert not t.query(0)
t.validate(1)
assert_raises(TypeError, t.validate, 0)
assert t.coerce(1) == 1
assert_raises(TypeError, t.coerce, 0)
s = set(xrange(1, 6))
for k in xrange(SAMPLES):
val = t.generate()
with on_error(elog, s.__contains__, (val, )):
assert val in s
assert t.display() == t.rst() == '<Set>'
def test_set():
from syn.sets.b import Range
t = Set(Range(1, 5))
assert t == Set(Range(1, 5))
assert t != Set(Range(0, 5))
assert Type.dispatch(t) is t
assert t.query(1)
assert not t.query(0)
t.validate(1)
assert_raises(TypeError, t.validate, 0)
assert t.coerce(1) == 1
assert_raises(TypeError, t.coerce, 0)
s = set(xrange(1, 6))
for k in xrange(SAMPLES):
val = t.generate()
with on_error(elog, s.__contains__, (val,)):
assert val in s
assert t.display() == t.rst() == '<Set>'
def test_numeric():
x = 1
t = Type.dispatch(x)
assert isinstance(t, Numeric)
assert type(t) is Int
assert hashable(x) == x
examine_numeric(Int, x)
for cls in subclasses(Numeric):
if cls.type is None:
continue
for k in xrange(SAMPLES):
val = generate(cls.type)
with on_error(elog, examine_numeric, (cls, val)):
examine_numeric(cls, val)
buf = []
last = None
for item in enumerate_(cls.type, max_enum=SAMPLES * 10):
assert type(item) is cls.type
assert item != last
buf.append(item)
if last is None:
# These need to be here under enumerate_ b/c of float equality issues
eitem = eval(estr(item))
assert eitem == item
assert type(eitem) is cls.type
last = item
if cls.type not in {bool,}:
assert is_unique(buf)
else:
assert not is_unique(buf)
def test_intersection():
i = Intersection({1, 2, 3}, {2, 3, 4})
assert i._children == [SetWrapper({1, 2, 3}), SetWrapper({2, 3, 4})]
assert set(i.enumerate()) == {2, 3}
assert set(i.lazy_enumerate()) == {2, 3}
assert i.size() == 2
assert i.size_limits() == (0, 3)
assert not i.hasmember(1)
assert i.hasmember(2)
assert not i.hasmember(4)
for k in range(SAMPLES):
item = i.sample()
with on_error(elog, i.hasmember, (i, item)):
assert i.hasmember(item)
item = i.lazy_sample()
assert i.hasmember(item)
item = i.get_one()
assert i.hasmember(item)
assert i.to_set() == {2, 3}
assert Intersection({1, 2}, NULL).to_set() == set()
i2 = Intersection(range(10), range(8), Range(2, 7), Range(3, 8))
assert i2.to_set() == set(range(3,8))
assert sorted(list(i2.enumerate())) == range(3, 8)
assert sorted(list(i2.enumerate(lazy=True))) == range(3, 8)
for k in range(SAMPLES):
item = i2.sample()
with on_error(elog, i2.hasmember, (i2, item)):
assert i2.hasmember(item)
assert Intersection(Range(1, 5), Range(2, 6)).to_set() == {2, 3, 4, 5}
assert Intersection(Range(1, 5), {2, 3}).to_set() == {2, 3}
assert Intersection(Range(1, 5), Union({2}, Range(4,5))).to_set() == {2, 4, 5}
assert Intersection(NULL, Union({2}, Range(4,5))).to_set() == set()
i3 = Intersection({1, 2, 3}, {1, 2, 3})
assert len(list(i3.enumerate(max_enumerate = 2))) == 2
i4 = Intersection({1, 2}, {3, 4})
assert i4.to_set() == set()
assert_raises(ValueError, i4.lazy_sample)
# Advantages of lazy_enumerate()
i5 = Intersection(Range(-10000000000, 10000000000), range(10))
assert set(i5.lazy_enumerate()) == set(range(10))
# Test max_enumerate
i6 = Intersection(Range(0, 100), Range(10, 90))
assert list(i6.lazy_enumerate(max_enumerate=10)) == range(10, 20)
assert i6.display() == '([0, 100] & [10, 90])'
# Sanity check
i7 = Intersection(range(10), Range(0, 50))
assert i7.to_set() == set(range(10))
# Edge Cases
assert Intersection().to_set() == set()
assert list(Intersection().lazy_enumerate()) == []
assert Intersection(Range(1, 5)).to_set() == set(range(1,6))
def test():
with on_error(add, 2, ___suppress_global=False):
raise RuntimeError
def test2():
with on_error(add, 3, ___suppress_errors=True):
raise RuntimeError
