def test_schema_attrs():
SchemaTest(SA1(), SA2(), a=1)
assert_raises(TypeError, SchemaTest, SA1(), SA3(), a=2)
for k in xrange(SAMPLES):
val = generate(SchemaTest)
assert type(val) is SchemaTest
assert isinstance(val.a, int)
assert type(val[0]) is SA1
assert type(val[1]) is SA2
assert len(val) == 2
def bad():
class SchemaTest2(Node):
schema = Sequence(SA1, SA2)
types = (SA1, SA1)
assert_raises(TypeError, bad)
ST2(SA1(), SA4(SA2()))
SA4(SA3()).validate()
assert_raises(TypeError, ST2, SA1(), SA4(SA3()))
for k in xrange(SAMPLES):
val = generate(ST2)
assert type(val) is ST2
assert type(val[0]) is SA1
assert type(val[1]) is SA4
assert len(val) == 2
def test_schema_attrs():
SchemaTest(SA1(), SA2(), a=1)
assert_raises(TypeError, SchemaTest, SA1(), SA3(), a=2)
for k in xrange(SAMPLES):
val = generate(SchemaTest)
assert type(val) is SchemaTest
assert isinstance(val.a, int)
assert type(val[0]) is SA1
assert type(val[1]) is SA2
assert len(val) == 2
def bad():
class SchemaTest2(Node):
schema = Sequence(SA1, SA2)
types = (SA1, SA1)
assert_raises(TypeError, bad)
ST2(SA1(), SA4(SA2()))
SA4(SA3()).validate()
assert_raises(TypeError, ST2, SA1(), SA4(SA3()))
for k in xrange(SAMPLES):
val = generate(ST2)
assert type(val) is ST2
assert type(val[0]) is SA1
assert type(val[1]) is SA4
assert len(val) == 2
def emit3(self, **kwargs):
with setitem(kwargs, 'indent_level', 0):
n_defs = len(self.defaults)
N = len(self.args) - n_defs
strs = [self.args[k].emit(**kwargs) for k in xrange(N)]
strs += [
'{}={}'.format(self.args[k + N].emit(**kwargs),
self.defaults[k].emit(**kwargs))
for k in xrange(n_defs)
]
if self.vararg:
strs.append('*' + self.vararg.emit(**kwargs))
for kwonly, kwonlydef in zip(self.kwonlyargs, self.kw_defaults):
if kwonlydef is not None:
strs.append('{}={}'.format(kwonly.emit(**kwargs),
kwonlydef.emit(**kwargs)))
else:
strs.append(kwonly.emit(**kwargs))
if self.kwarg:
strs.append('**' + self.kwarg.emit(**kwargs))
return ', '.join(strs)
def test_rand_complex():
from syn.base_utils import rand_complex
comps = [rand_complex() for k in xrange(SAMPLESIII)]
assert all(isinstance(s, complex) for s in comps)
comps = [rand_complex(imag_only=True) for k in xrange(SAMPLESII)]
assert all(isinstance(s, complex) for s in comps)
assert all(s.real == 0 for s in comps)
def generate(self, **kwargs):
min_len = kwargs.get('min_len', MIN_SEQLEN)
max_len = kwargs.get('max_len', MAX_SEQLEN)
N = randint(min_len, max_len)
values = [self.value_type.generate(**kwargs) for k in xrange(N)]
keys = [rand_str(min_len=5, max_len=10) for k in xrange(N)]
ret = dict(zip(keys, values))
return self.map_type.coerce(ret)
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_randfloat():
from syn.base_utils import rand_float
floats = [rand_float() for k in xrange(SAMPLESII)]
assert all(isinstance(f, float) for f in floats)
if len(floats) > 2:
assert any(f != 0 for f in floats)
floats = [rand_float(ub = 3) for k in xrange(SAMPLESII)]
assert all(MIN_FLOAT <= f <= 3 for f in floats)
floats = [rand_float(2, 3) for k in xrange(SAMPLESII)]
assert all(2 <= f <= 3 for f in floats)
def emit2(self, **kwargs):
with setitem(kwargs, 'indent_level', 0):
n_defs = len(self.defaults)
N = len(self.args) - n_defs
strs = [self.args[k].emit(**kwargs) for k in xrange(N)]
strs += ['{}={}'.format(self.args[k + N].emit(**kwargs),
self.defaults[k].emit(**kwargs))
for k in xrange(n_defs)]
if self.vararg:
strs.append('*' + self.vararg)
if self.kwarg:
strs.append('**' + self.kwarg)
return ', '.join(strs)
def test_generation():
from syn.base_utils.rand import PRIMITIVE_TYPES
from syn.types import Type as Type_
anys = [AnyType().generate() for k in xrange(SAMPLES)]
if len(anys) > 2:
assert any(x is not None for x in anys)
class Foo(object): pass
assert isinstance(AnyType().generate(types=[Foo]), tuple(PRIMITIVE_TYPES))
class Bar(object):
@classmethod
def _generate(cls, **kwargs):
return cls()
class BarType(Type_): type = Bar
assert isinstance(TypeType(int).generate(), int)
assert isinstance(TypeType(Bar).generate(), Bar)
assert_raises(NotImplementedError, TypeType(Foo).generate)
assert ValuesType([1, 2, 3]).generate() in {1, 2, 3}
t = MultiType([int, float])
assert isinstance(t.generate(), (int, float))
assert isinstance(t.generate(exclude_types=[float]), int)
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_randstr():
from syn.base_utils import rand_str
strs = [rand_str() for k in xrange(SAMPLESII)]
assert all(isinstance(s, str) for s in strs)
if len(strs) > 2:
assert any(len(s) > 0 for s in strs)
def test_generation():
from syn.base_utils.rand import PRIMITIVE_TYPES
from syn.types import Type as Type_
anys = [AnyType().generate() for k in xrange(SAMPLES)]
if len(anys) > 2:
assert any(x is not None for x in anys)
class Foo(object):
pass
assert isinstance(AnyType().generate(types=[Foo]), tuple(PRIMITIVE_TYPES))
class Bar(object):
@classmethod
def _generate(cls, **kwargs):
return cls()
class BarType(Type_):
type = Bar
assert isinstance(TypeType(int).generate(), int)
assert isinstance(TypeType(Bar).generate(), Bar)
assert_raises(NotImplementedError, TypeType(Foo).generate)
assert ValuesType([1, 2, 3]).generate() in {1, 2, 3}
t = MultiType([int, float])
assert isinstance(t.generate(), (int, float))
assert isinstance(t.generate(exclude_types=[float]), int)
def emit2(self, **kwargs):
with setitem(kwargs, 'indent_level', 0):
n_defs = len(self.defaults)
N = len(self.args) - n_defs
strs = [self.args[k].emit(**kwargs) for k in xrange(N)]
strs += [
'{}={}'.format(self.args[k + N].emit(**kwargs),
self.defaults[k].emit(**kwargs))
for k in xrange(n_defs)
]
if self.vararg:
strs.append('*' + self.vararg)
if self.kwarg:
strs.append('**' + self.kwarg)
return ', '.join(strs)
def test_child_types():
CTTest(CT1())
assert_raises(TypeError, CTTest, CT1(), CT2())
for k in xrange(SAMPLES):
val = generate(CTTest)
val.validate()
def list_enumval(x, **kwargs):
top_level = kwargs.get('top_level', True)
if top_level:
if x == 0:
return []
kwargs['top_level'] = False
return list_enumval(x - 1, **kwargs)
depth = kwargs.get('depth', 0)
max_depth = kwargs.get('max_depth', MAX_DEPTH)
types = kwargs.get('types', SEQ_TYPES)
if depth >= max_depth:
types = [t for t in types if t in PRIMITIVE_TYPES]
kwargs['depth'] = depth + 1
N = len(types)
i = x % N
j = x // N
l = j + 1
ret = []
for k in xrange(l):
i_k = (i + k) % N
x_k = j + (k // N)
item = Type.type_dispatch(types[i_k])._enumeration_value(x_k, **kwargs)
ret.append(item)
return ret
def test_child_types():
CTTest(CT1())
assert_raises(TypeError, CTTest, CT1(), CT2())
for k in xrange(SAMPLES):
val = generate(CTTest)
val.validate()
def list_enumval(x, **kwargs):
top_level = kwargs.get('top_level', True)
if top_level:
if x == 0:
return []
kwargs['top_level'] = False
return list_enumval(x - 1, **kwargs)
depth = kwargs.get('depth', 0)
max_depth = kwargs.get('max_depth', MAX_DEPTH)
types = kwargs.get('types', SEQ_TYPES)
if depth >= max_depth:
types = [t for t in types if t in PRIMITIVE_TYPES]
kwargs['depth'] = depth + 1
N = len(types)
i = x % N
j = x // N
l = j + 1
ret = []
for k in xrange(l):
i_k = (i + k) % N
x_k = j + (k // N)
item = Type.type_dispatch(types[i_k])._enumeration_value(x_k, **kwargs)
ret.append(item)
return ret
def test_randint():
from syn.base_utils import rand_int
ints = [rand_int() for k in xrange(SAMPLESII)]
assert all(isinstance(i, int) for i in ints)
if len(ints) > 2:
assert any(i != 0 for i in ints)
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 enumerate(self, **kwargs):
args = Args(**kwargs)
maxenum = args.max_enumerate
for k,item in enumerate(xrange(self.lb, self.ub + 1)):
if k >= maxenum:
break
yield item
def test_rand_unicode():
from syn.base_utils import rand_unicode
if PY2:
strs = [rand_unicode(min_len=1) for k in xrange(SAMPLESII)]
assert all(isinstance(s, unicode) for s in strs)
if len(strs) > 2:
assert any(len(s) > 0 for s in strs)
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_randlong():
from syn.base_utils import rand_long
if PY2:
longs = [rand_long() for k in xrange(SAMPLESII)]
assert all(isinstance(l, long) for l in longs)
if len(longs) > 2:
assert any(l != 0 for l in longs)
def _set(self, index, value):
if index < len(self):
raise IndexError('Invalid index: {}'.format(index))
n_fill = index - len(self)
for _ in xrange(n_fill):
self.append(self._default())
self.append(value)
def test_range():
r = range(5)
assert isinstance(r, list)
assert r == [0, 1, 2, 3, 4]
xr = xrange(5)
assert not isinstance(xr, list)
assert list(xr) == r
def enumerate(self, **kwargs):
args = Args(**kwargs)
maxenum = args.max_enumerate
for k, item in enumerate(xrange(self.lb, self.ub + 1)):
if k >= maxenum:
break
yield item
def test_iterablelist():
from syn.base_utils import IterableList
range = lambda *args: list(xrange(*args))
l = IterableList(range(0, 10))
assert len(l) == 10
assert l.position == 0
assert not l.empty()
assert_raises(ValueError, l.seek, 0, 3)
l.seek(0, 2)
assert not l.empty()
assert l.peek() == 9
assert l.position == 9
assert l.next() == 9
assert l.empty()
l.seek(1)
assert l.position == 1
l.mark()
l.seek(8)
assert l.next() == 8
assert next(l) == 9
assert_raises(StopIteration, l.next)
assert l.position == 10
assert l.peek() is None
assert_raises(StopIteration, l.peek, safe=False)
l.reset()
assert l.peek() == 1
assert l.next() == 1
assert l.displacement() == 1
assert l.peek() == 2
assert l.previous() == 1
assert l.displacement() == 0
assert l.peek(2) == 3
assert l.peek(-1) == 0
assert l.peek(-2) is None
assert l.peek() == 1
assert_raises(StopIteration, l.peek, -2, safe=False)
assert l.peek() is None
l.reset()
assert l.peek() == 1
l.consume(3)
assert l.peek() == 4
l2 = l.copy()
l2.reset()
assert l.peek() == 4
assert l2.peek() == 1
assert l2.take(3) == [1, 2, 3]
assert l2.peek() == 4
assert l2.take(0) == []
assert l2.peek() == 4
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_descendant_exclude():
DETest(DE1())
DETest(DE1(DE2(DE3())))
n = DE2(DE4())
assert_raises(TypeError, DETest, n)
for k in xrange(SAMPLES):
val = generate(DETest)
val.validate()
def test_descendant_exclude():
DETest(DE1())
DETest(DE1(DE2(DE3())))
n = DE2(DE4())
assert_raises(TypeError, DETest, n)
for k in xrange(SAMPLES):
val = generate(DETest)
val.validate()
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_graft():
lst = list(xrange(0, 5))
branch = [6, 7, 8]
g1 = graft(lst, branch, 2)
assert g1 == [0, 1, 6, 7, 8, 2, 3, 4]
g2 = graft(lst, branch, 5)
assert g2 == [0, 1, 2, 3, 4, 6, 7, 8]
g3 = graft(lst, branch, 0)
assert g3 == [6, 7, 8, 0, 1, 2, 3, 4]
def test_graft():
lst = list(xrange(0,5))
branch = [6,7,8]
g1 = graft(lst, branch, 2)
assert g1 == [0, 1, 6, 7, 8, 2, 3, 4]
g2 = graft(lst, branch, 5)
assert g2 == [0, 1, 2, 3, 4, 6, 7, 8]
g3 = graft(lst, branch, 0)
assert g3 == [6,7,8, 0,1,2,3,4]
def generate(self, **kwargs):
types = self.types
if self.uniform and self.length:
types = [types] * self.length
if not self.length:
min_len = kwargs.get('min_len', MIN_SEQLEN)
max_len = kwargs.get('max_len', MAX_SEQLEN)
N = randint(min_len, max_len)
ret = [self.types.generate(**kwargs) for k in xrange(N)]
else:
ret = [t.generate(**kwargs) for t in types]
return tuple(ret)
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 generate_set(self, **kwargs):
ub = self.ub if self.ub is not None else self.lb + 5
sets = []
for k in xrange(self.lb, ub + 1):
if k == 0:
sets.append(SetWrapper([()]))
elif k == 1:
sets.append(self.A.set)
else:
tmp = [self.A.set] * k
sets.append(Product(*tmp))
self.set = Union(*sets)
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 generate_set(self, **kwargs):
ub = self.ub if self.ub is not None else self.lb + 5
sets = []
for k in xrange(self.lb, ub + 1):
if k == 0:
sets.append(SetWrapper([()]))
elif k == 1:
sets.append(self.A.set)
else:
tmp = [self.A.set] * k
sets.append(Product(*tmp))
self.set = Union(*sets)
def emit3(self, **kwargs):
with setitem(kwargs, 'indent_level', 0):
n_defs = len(self.defaults)
N = len(self.args) - n_defs
strs = [self.args[k].emit(**kwargs) for k in xrange(N)]
strs += ['{}={}'.format(self.args[k + N].emit(**kwargs),
self.defaults[k].emit(**kwargs))
for k in xrange(n_defs)]
if self.vararg:
strs.append('*' + self.vararg.emit(**kwargs))
for kwonly, kwonlydef in zip(self.kwonlyargs, self.kw_defaults):
if kwonlydef is not None:
strs.append('{}={}'.format(kwonly.emit(**kwargs),
kwonlydef.emit(**kwargs)))
else:
strs.append(kwonly.emit(**kwargs))
if self.kwarg:
strs.append('**' + self.kwarg.emit(**kwargs))
return ', '.join(strs)
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_enumeration_values():
assert TypeType(int).enumeration_value(0) == 0
v = ValuesType([1, 2, 3])
assert v.enumeration_value(0) == 1
assert v.enumeration_value(1) == 2
assert v.enumeration_value(2) == 3
assert v.enumeration_value(3) == 1
m = MultiType([int, float])
assert m.enumeration_value(0) == 0
assert feq(m.enumeration_value(1), 0.1)
assert m.enumeration_value(2) == 2
assert feq(m.enumeration_value(3), 0.3)
anys = [AnyType().enumeration_value(k) for k in xrange(SAMPLES)]
if len(anys) > 2:
assert any(x is not None for x in anys)
class Foo(object): pass
assert AnyType().enumeration_value(0, types=[Foo]) == 0
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_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_enumeration_values():
assert TypeType(int).enumeration_value(0) == 0
v = ValuesType([1, 2, 3])
assert v.enumeration_value(0) == 1
assert v.enumeration_value(1) == 2
assert v.enumeration_value(2) == 3
assert v.enumeration_value(3) == 1
m = MultiType([int, float])
assert m.enumeration_value(0) == 0
assert feq(m.enumeration_value(1), 0.1)
assert m.enumeration_value(2) == 2
assert feq(m.enumeration_value(3), 0.3)
anys = [AnyType().enumeration_value(k) for k in xrange(SAMPLES)]
if len(anys) > 2:
assert any(x is not None for x in anys)
class Foo(object):
pass
assert AnyType().enumeration_value(0, types=[Foo]) == 0
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 command_up(self, num='1'):
num = int(num)
for _ in xrange(num):
self.up()
