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_child_types(): CTTest(CT1()) assert_raises(TypeError, CTTest, CT1(), CT2()) for k in xrange(SAMPLES): val = generate(CTTest) 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_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_listwrapper_generation(): lw1 = generate(LWGT1) assert isinstance(lw1.a, int) assert len(lw1) == 0 lw2 = generate(LWGT2) assert isinstance(lw2.a, int) assert len(lw2) == 2 lw3 = generate(LWGT3) assert isinstance(lw2.a, int) assert len(lw3) == 3 assert isinstance(lw3[0], int) assert isinstance(lw3[1], float) assert isinstance(lw3[2], int) lw4 = generate(LWGT4) assert 2 <= len(lw4) <= 4 lw41 = generate(LWGT4, max_len=3) assert 2 <= len(lw41) <= 3 assert_raises(TypeError, LWGT1, [], a=1.2)
def test_custom_type(): b = Baz(1, 2.3) b2 = Baz(1, 2.4) b3 = Baz(2, 2.3) assert b != b2 assert_equivalent(Baz(1, 2.3), Baz(1, 2.3)) if PY3: assert not is_hashable(b) else: assert is_hashable(b) assert is_hashable(hashable(b)) assert find_ne(b, b) is None assert find_ne(b, b2) == DiffersAtAttribute(b, b2, 'b') assert find_ne(b, b3) == DiffersAtAttribute(b, b3, 'a') e1 = eval(estr(b)) assert_equivalent(e1, b) assert list(visit(b)) == [('a', 1), ('b', 2.3)] assert rstr(b) == 'Baz(1,2.3)' assert attrs(b) == ['a', 'b'] sval = deserialize(serialize(b)) assert_equivalent(sval, b) assert deep_feq(sval, b) assert Baz is deserialize(serialize(Baz)) assert primitive_form(Baz) is Baz assert primitive_form(b) == dict(a=1, b=2.3) val = generate(Baz) assert type(val) is Baz assert isinstance(val.a, int) assert isinstance(val.b, float) buf = [] last = None for item in enum(Baz, max_enum=SAMPLES * 10, step=100): assert type(item) is Baz assert item != last buf.append(item) last = item assert is_unique(buf)
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_int(): lst = list(enumerate_(int, max_enum=5)) assert lst == [0, 1, 2, 3, 4] lst = list(enumerate_(int, max_enum=5, start=1, step=3)) assert lst == [1, 4, 7, 10, 13] assert rstr(1) == estr(1) == '1' assert hashable(-1) == -1 gen = generate(int) assert isinstance(gen, int) assert find_ne(gen, gen+1) == NotEqual(gen, gen+1) assert serialize(-1) == -1 assert deserialize(-1) == -1
def test_bool(): lst = list(enumerate_(bool, max_enum=5)) assert lst == [False, True, False, True, False] lst = list(enumerate_(bool, max_enum=5, start=1)) assert lst == [True, False, True, False, True] assert rstr(True) == estr(True) == 'True' assert hashable(False) is False gen = generate(bool) assert gen is True or gen is False assert find_ne(gen, not gen) == NotEqual(gen, not gen) assert serialize(True) is True assert deserialize(True) is True
def test_complex(): lst = list(enumerate_(complex, max_enum=3)) assert collection_comp(lst, [0+0j, 0.1+0.05j, 0.2+0.1j], feq) c = 1+2j assert rstr(c) == estr(c) == '(1+2j)' assert eval(estr(c)) == c assert hashable(c) is c gen = generate(complex) assert isinstance(gen, complex) gen2 = 0+0j if gen != 0 else 1.0j assert find_ne(gen, gen2) == NotEqual(gen, gen2) assert_type_equivalent(deserialize(serialize(c)), c)
def test_int(): lst = list(enumerate_(int, max_enum=5)) assert lst == [0, 1, 2, 3, 4] lst = list(enumerate_(int, max_enum=5, start=1, step=3)) assert lst == [1, 4, 7, 10, 13] assert rstr(1) == estr(1) == '1' assert hashable(-1) == -1 gen = generate(int) assert isinstance(gen, int) assert find_ne(gen, gen + 1) == NotEqual(gen, gen + 1) assert serialize(-1) == -1 assert deserialize(-1) == -1
def test_complex(): lst = list(enumerate_(complex, max_enum=3)) assert collection_comp(lst, [0 + 0j, 0.1 + 0.05j, 0.2 + 0.1j], feq) c = 1 + 2j assert rstr(c) == estr(c) == '(1+2j)' assert eval(estr(c)) == c assert hashable(c) is c gen = generate(complex) assert isinstance(gen, complex) gen2 = 0 + 0j if gen != 0 else 1.0j assert find_ne(gen, gen2) == NotEqual(gen, gen2) assert_type_equivalent(deserialize(serialize(c)), c)
def test_float(): lst = list(enumerate_(float, max_enum=5)) assert collection_comp(lst, [0.0, 0.1, 0.2, 0.3, 0.4], feq) lst = list(enumerate_(float, max_enum=3, start=1, step=3, float_step=.2)) assert collection_comp(lst, [0.2, 0.8, 1.4], feq) assert rstr(1.1) == estr(1.1) == '1.1' assert hashable(1.1) == 1.1 gen = generate(float) assert isinstance(gen, float) gen2 = 0.0 if gen != 0 else 1.0 assert find_ne(gen, gen2) == NotEqual(gen, gen2) assert serialize(-1.1) == -1.1 assert deserialize(-1.1) == -1.1
def test_custom_object(): f = Foo(1, 1.2) f2 = Foo(1, 1.3) f3 = Foo(2, 1.2) assert f != f2 assert_equivalent(Foo(1, 2.3), Foo(1, 2.3)) assert not is_hashable(f) assert is_hashable(hashable(f)) assert find_ne(f, f) is None assert find_ne(f, f2) == DiffersAtAttribute(f, f2, 'b') assert find_ne(f, f3) == DiffersAtAttribute(f, f3, 'a') e1 = eval(estr(f)) assert_equivalent(e1, f) assert list(visit(f)) == [('a', 1), ('b', 1.2)] assert rstr(f) == 'Foo(1,1.2)' assert attrs(f) == ['a', 'b'] assert pairs(f) == [('a', 1), ('b', 1.2)] sval = deserialize(serialize(f)) assert_equivalent(sval, f) assert deep_feq(sval, f) assert Foo is deserialize(serialize(Foo)) assert primitive_form(Foo) is Foo assert primitive_form(f) == dict(a=1, b=1.2) assert collect(f) == primitive_form(f) val = generate(Foo) assert type(val) is Foo buf = [] last = None for item in enum(Foo, max_enum=SAMPLES * 10, step=100): assert type(item) is Foo assert item != last buf.append(item) last = item assert enumeration_value(Foo, 0) == first(enum(Foo, max_enum=1)) assert is_unique(buf)
def test_long(): if PY2: lst = list(enumerate_(long, max_enum=5)) assert lst == [0, 1, 2, 3, 4] x = long('1L') assert rstr(x) == '1' assert estr(x) == '1L' assert_equivalent(hashable(-x), -x) gen = generate(long) assert isinstance(gen, long) assert find_ne(gen, gen+1) == NotEqual(gen, gen+1) assert_type_equivalent(deserialize(serialize(x)), x) assert TYPE_REGISTRY[long] is Long assert Long in TYPE_REGISTRY.values() else: assert Long not in TYPE_REGISTRY.values()
def test_long(): if PY2: lst = list(enumerate_(long, max_enum=5)) assert lst == [0, 1, 2, 3, 4] x = long('1L') assert rstr(x) == '1' assert estr(x) == '1L' assert_equivalent(hashable(-x), -x) gen = generate(long) assert isinstance(gen, long) assert find_ne(gen, gen + 1) == NotEqual(gen, gen + 1) assert_type_equivalent(deserialize(serialize(x)), x) assert TYPE_REGISTRY[long] is Long assert Long in TYPE_REGISTRY.values() else: assert Long not in TYPE_REGISTRY.values()
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_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 _generate(cls, **kwargs): a = generate(int, **kwargs) b = generate(float, **kwargs) return cls(a, b)
def test_bytes(): if PY3: gen = generate(bytes) assert isinstance(gen, bytes)
def test_unicode(): if PY2: gen = generate(unicode) assert isinstance(gen, unicode) assert Unicode._enumeration_value(140) == u'\xab'
def test_misc(): w = generate(DictWrapper) assert isinstance(w, DictWrapper) assert isinstance(w.dct, dict)