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 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_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_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 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_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 command_up(self, num='1'): num = int(num) for _ in xrange(num): self.up()