def test_comparisons_equivalence(self): t = TupleOf(OneOf(None, str, bytes, float, int, bool, TupleOf(int)),) def lt(a,b): return a < b def le(a,b): return a <= b def eq(a,b): return a == b def ne(a,b): return a != b def gt(a,b): return a > b def ge(a,b): return a >= b funcs = [lt,le,eq,ne,gt,ge] tgroups = [ [1.0,2.0,3.0], [1,2,3], [True,False], ["a","b","ab","bb","ba","aaaaaaa","","asdf"], ["1","2","3","12","13","23","24","123123", "0", ""], [b"a",b"b",b"ab",b"bb",b"ba",b"aaaaaaa",b"",b"asdf"], [(1,2),(1,2,3),(),(1,1),(1,)] ] for ts in tgroups: for f in funcs: for t1 in ts: for t2 in ts: self.assertTrue(f(t1,t2) is f(t((t1,)),t((t2,))), (f, t1,t2, f(t1,t2), f(t((t1,)),t((t2,)))) )
def test_serialize_core_python_objects(self): self.check_idempotence(0) self.check_idempotence(10) self.check_idempotence(-10) self.check_idempotence(-0.0) self.check_idempotence(0.0) self.check_idempotence(10.5) self.check_idempotence(-10.5) self.check_idempotence(None) self.check_idempotence(True) self.check_idempotence(False) self.check_idempotence("") self.check_idempotence("a string") self.check_idempotence(b"") self.check_idempotence(b"some bytes") self.check_idempotence(()) self.check_idempotence((1,)) self.check_idempotence([]) self.check_idempotence({}) self.check_idempotence({"key": "value"}) self.check_idempotence({"key": "value", "key2": "value2"}) self.check_idempotence([]) self.check_idempotence([1, 2, 3]) self.check_idempotence(set()) self.check_idempotence({1, 2, 3}) self.check_idempotence(frozenset()) self.check_idempotence(frozenset({1, 2, 3})) self.check_idempotence(int) self.check_idempotence(object) self.check_idempotence(type) self.check_idempotence(TupleOf(int)) self.check_idempotence(TupleOf(int)([0x08]))
def test_tuple_of_float(self): def f(x: TupleOf(float), y: TupleOf(float)) -> float: j = 0 res = 0.0 i = 0 while j < len(y): i = 0 while i < len(x): res = res + x[i] * y[j] i = i + 1 j = j + 1 return res aTupleOfFloat = TupleOf(float)(list(range(1000))) aTupleOfFloat2 = TupleOf(float)(list(range(1000))) self.assertEqual(_types.refcount(aTupleOfFloat), 1) t_py, t_fast = self.checkFunction(f, [(aTupleOfFloat, aTupleOfFloat2)]) self.assertEqual(_types.refcount(aTupleOfFloat), 1) # I get around 150x self.assertTrue(t_py / t_fast > 50.0) print(t_py / t_fast, " speedup")
def test_one_of_composite(self): t = OneOf(TupleOf(str), TupleOf(float)) self.assertIsInstance(t((1.0,2.0)), TupleOf(float)) self.assertIsInstance(t(("1.0","2.0")), TupleOf(str)) with self.assertRaises(TypeError): t((1.0,"2.0"))
def test_deep_forwards_work(self): X = TupleOf(TupleOf(TupleOf(TupleOf(OneOf(None, lambda: X))))) xStr = str(X) anX = X(((((None, ), ), ), )) anotherX = X(((((anX, ), ), ), )) self.assertEqual(anotherX[0][0][0][0], anX)
def test_forward_type_resolution_sequential(self): F0 = Forward("f0") T0 = TupleOf(F0) F1 = Forward("f1") T1 = TupleOf(F1) F1.define(T0) F0.define(int) self.assertEqual(T1.__name__, "TupleOf(TupleOf(Int64))")
def test_serialize_stream_integers(self): for someInts in [(1, 2), TupleOf(int)((1, 2)), [1, 2]]: self.assertEqual( serializeStream(int, someInts), b"".join([serialize(int, x) for x in someInts]) ) self.assertEqual( deserializeStream(int, serializeStream(int, someInts)), TupleOf(int)(someInts) )
def test_deep_forwards_work(self): X = Forward("X") X = X.define(TupleOf(TupleOf(TupleOf(TupleOf(OneOf(None, X)))))) str(X) anX = X( ((((None,),),),) ) anotherX = X( ((((anX,),),),) ) self.assertEqual(anotherX[0][0][0][0], anX)
def test_recursive_oneof(self): OneOfTupleOfSelf = Forward("OneOfTupleOfSelf") OneOfTupleOfSelf = OneOfTupleOfSelf.define(OneOf(None, TupleOf(OneOfTupleOfSelf))) self.assertEqual(OneOfTupleOfSelf.__qualname__, "OneOfTupleOfSelf") self.assertEqual(OneOf(None, TupleOf(OneOfTupleOfSelf)).__qualname__, "OneOf(NoneType, TupleOf(OneOfTupleOfSelf))") TO = Forward("TO") TO = TO.define(TupleOf(OneOf(None, TO))) self.assertEqual(TO.__qualname__, "TO") self.assertIs(TO.ElementType.Types[1], TO) self.assertEqual(TO.ElementType.__qualname__, "OneOf(NoneType, TO)")
def test_embedded_messages(self): T = NamedTuple(x=TupleOf(int)) T_with_message = NamedTuple(x=EmbeddedMessage) T_with_two_messages = NamedTuple(x=EmbeddedMessage, y=EmbeddedMessage) T2 = NamedTuple(x=TupleOf(int), y=TupleOf(int)) t = T(x=(1, 2, 3, 4)) tm = deserialize(T_with_message, serialize(T, t)) tm2 = T_with_two_messages(x=tm.x, y=tm.x) t2 = deserialize(T2, serialize(T_with_two_messages, tm2)) self.assertEqual(t2.x, t.x) self.assertEqual(t2.y, t.x)
def f(x: TupleOf(float), y: TupleOf(float)) -> float: j = 0 res = 0.0 i = 0 while j < len(y): i = 0 while i < len(x): res = res + x[i] * y[j] i = i + 1 j = j + 1 return res
def test_serialization(self): ints = TupleOf(int)((1,2,3,4)) self.assertEqual( len(serialize(TupleOf(int), ints)), 36 ) while len(ints) < 1000000: ints = ints + ints t0 = time.time() self.assertEqual(len(serialize(TupleOf(int), ints)), len(ints) * 8 + 4) print(time.time() - t0, " for ", len(ints))
def test_list_resize(self): T = ListOf(TupleOf(int)) aTup = TupleOf(int)((1, 2, 3)) @Compiled def f(x: T, y: TupleOf(int)): x.resize(len(x) + 10, y) aList = T() aList.resize(10) f(aList, aTup) self.assertEqual(_types.refcount(aTup), 11)
def test_create_function_with_kwargs_and_star_args_and_defaults(self): @Function def f( x: int, y=30, z: None = None, *args: TupleOf(float), **kwargs: ConstDict(str, float) ) -> int: return x + 1 self.assertEqual(len(f.overloads), 1) o = f.overloads[0] self.assertEqual(len(o.args), 5) self.assertEqual([a.name for a in o.args], ['x', 'y', 'z', 'args', 'kwargs']) self.assertEqual( [a.typeFilter for a in o.args], [Int64, None, NoneType, TupleOf(float), ConstDict(str, float)]) self.assertEqual([a.defaultValue for a in o.args], [None, (30, ), (None, ), None, None]) self.assertEqual([a.isStarArg for a in o.args], [False, False, False, True, False]) self.assertEqual([a.isKwarg for a in o.args], [False, False, False, False, True])
def test_serializing_named_tuples_in_loop(self): NT = Forward("NT") NT = NT.define(NamedTuple(x=OneOf(int, float), y=OneOf(int, TupleOf(NT)))) context = SerializationContext({'NT': NT}) self.serializeInLoop(lambda: NT(x=10, y=(NT(x=20, y=2),)), context=context)
def test_subclassing(self): BaseTuple = NamedTuple(x=int,y=float) class NTSubclass(BaseTuple): def f(self): return self.x + self.y def __repr__(self): return "ASDF" inst = NTSubclass(x=10,y=20) self.assertTrue(isinstance(inst, BaseTuple)) self.assertTrue(isinstance(inst, NTSubclass)) self.assertTrue(type(inst) is NTSubclass) self.assertEqual(repr(inst), "ASDF") self.assertNotEqual(BaseTuple.__repr__(inst), "ASDF") self.assertEqual(inst.x, 10) self.assertEqual(inst.f(), 30) TupleOfSubclass = TupleOf(NTSubclass) instTup = TupleOfSubclass((inst,BaseTuple(x=20,y=20.0))) self.assertTrue(isinstance(instTup[0], NTSubclass)) self.assertTrue(isinstance(instTup[1], NTSubclass)) self.assertEqual(instTup[0].f(), 30) self.assertEqual(instTup[1].f(), 40) self.assertEqual(BaseTuple(inst).x, 10) self.assertTrue(OneOf(None, NTSubclass)(None) is None) self.assertTrue(OneOf(None, NTSubclass)(inst) == inst)
class LoginPlugin: name = Indexed(str) # auth plugin login_plugin_factory = object # factory for LoginPluginInterface objects auth_plugins = TupleOf(OneOf(None, AuthPluginBase)) codebase = OneOf(None, service_schema.Codebase) config = ConstDict(str, str)
def test_class_in_forward(self): class C(Class): x = Member(int) Fwd = Forward("Forward") Fwd = Fwd.define(OneOf(None, C, TupleOf(Fwd), ListOf(Fwd), ConstDict(str, Fwd))) Fwd(C())
def f( x: int, y=30, z: None = None, *args: TupleOf(float), **kwargs: ConstDict(str, float) ) -> int: return x + 1
def test_tuple_of_various_things(self): for thing, typeOfThing in [("hi", str), (b"somebytes", bytes), (1.0, float), (2, int), (None, type(None)) ]: tupleType = TupleOf(typeOfThing) t = tupleType((thing,)) self.assertTrue(type(t[0]) is typeOfThing) self.assertEqual(t[0], thing)
def test_tuple_of_one_of_fixed_size(self): t = TupleOf(OneOf(0,1,2,3,4)) ints = tuple([x % 5 for x in range(1000000)]) typedInts = t(ints) self.assertEqual(len(serialize(t, typedInts)), len(ints) + 4) self.assertEqual(tuple(typedInts), ints)
def test_add_tuple_of(self): tupleOfInt = TupleOf(int) tups = [(),(1,2),(1,),(1,2,3,4)] for tup1 in tups: for tup2 in tups: self.assertEqual(tupleOfInt(tup1) + tupleOfInt(tup2), tupleOfInt(tup1+tup2)) self.assertEqual(tupleOfInt(tup1) + tup2, tupleOfInt(tup1+tup2))
def test_add_transaction(self): for inType in [list, set, tuple, TupleOf(int)]: s = VersionedIdSet() s.addTransaction(100, inType([10]), inType([])) s.addTransaction(101, inType([]), inType([10])) self.assertTrue(s.isActive(100, 10)) self.assertFalse(s.isActive(101, 10))
def test_serializing_anonymous_recursive_types(self): NT = Forward("NT") NT = NT.define(TupleOf(NT)) # right now we don't allow this. When we move to a more proper model for declarint # forward types, this should work better. with self.assertRaises(Exception): ping_pong(NT)
def test_basic_forward_type_resolution(self): f = Forward("f") T = TupleOf(f) f.define(int) self.assertEqual(T.__name__, "TupleOf(Int64)") self.assertEqual(f.get(), Int64)
def test_tuple_assign(self): @Compiled def f(x: TupleOf(int)) -> TupleOf(int): y = x return y t = TupleOf(int)((1, 2, 3)) self.assertEqual(f(t), t) self.assertEqual(_types.refcount(t), 1)
def test_serialize_primitive_compound_types(self): class A: pass B = Alternative("B", X={'a': A}) ts = SerializationContext({'A': A, 'B': B}) for t in [ ConstDict(int, float), NamedTuple(x=int, y=str), TupleOf(bool), Tuple(int, int, bool), OneOf(int, float), OneOf(1, 2, 3, "hi", b"goodbye"), TupleOf(NamedTuple(x=int)), TupleOf(object), TupleOf(A), TupleOf(B) ]: self.assertIs(ping_pong(t, ts), t)
def test_class_dispatch_on_tuple_vs_list(self): class WithTwoFunctions(Class): def f(self, x: TupleOf(int)): return "Tuple" def f(self, x: ListOf(int)): # noqa: F811 return "List" c = WithTwoFunctions() self.assertEqual(c.f(TupleOf(int)((1, 2, 3))), "Tuple") self.assertEqual(c.f(ListOf(int)((1, 2, 3))), "Tuple")
def expr_concatenate(self, other): if self.matches.Constant: return other if self.matches.Sequence and other.matches.Sequence: return Expression.Sequence(vals=self.vals + other.vals) if self.matches.Sequence: return Expression.Sequence(vals=self.vals + (other, )) if other.matches.Sequence: return Expression.Sequence(vals=TupleOf(Expression)((self, )) + other.vals) return Expression.Sequence(vals=(self, other))
def test_one_of_with_refcounts(self): @Compiled def f(x: OneOf(None, TupleOf(int))) -> OneOf(None, TupleOf(int)): y = x return y self.assertIs(f(None), None) aTup = TupleOf(int)((1, 2, 3)) self.assertEqual(f(aTup), aTup) self.assertEqual(_types.refcount(aTup), 1)