def test_pass_in_value(self): import System from Merlin.Testing import Flag from Merlin.Testing.TypeSample import EnumInt16 from Merlin.Testing.Call import Consumer for (call1, call2, value, flag) in [ (Consumer.EatByteClass, Consumer.EatByteStruct, System.Byte.Parse("2"), 100), (Consumer.EatSByteClass, Consumer.EatSByteStruct, System.SByte.Parse("12"), 110), (Consumer.EatUInt16Class, Consumer.EatUInt16Struct, System.UInt16.Parse("22"), 120), (Consumer.EatInt16Class, Consumer.EatInt16Struct, System.Int16.Parse("32"), 130), (Consumer.EatUInt32Class, Consumer.EatUInt32Struct, System.UInt32.Parse("42"), 140), (Consumer.EatInt32Class, Consumer.EatInt32Struct, System.Int32.Parse("52"), 150), (Consumer.EatUInt64Class, Consumer.EatUInt64Struct, System.UInt64.Parse("62"), 160), (Consumer.EatInt64Class, Consumer.EatInt64Struct, System.Int64.Parse("72"), 170), (Consumer.EatDoubleClass, Consumer.EatDoubleStruct, System.Double.Parse("82"), 180), (Consumer.EatSingleClass, Consumer.EatSingleStruct, System.Single.Parse("92"), 190), (Consumer.EatDecimalClass, Consumer.EatDecimalStruct, System.Decimal.Parse("102"), 200), (Consumer.EatCharClass, Consumer.EatCharStruct, System.Char.Parse("b"), 210), (Consumer.EatBooleanClass, Consumer.EatBooleanStruct, False, 220), (Consumer.EatStringClass, Consumer.EatStringStruct, "nohtyp", 230), (Consumer.EatEnumClass, Consumer.EatEnumStruct, EnumInt16.C, 240), ]: self.assertEqual(call1(value), value) Flag.Check(flag) self.assertEqual(call2(value), value) Flag.Check(flag)
def test_overload1(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor50 class C(CCtor50): def __new__(cls, arg): return super(C, cls).__new__(cls, arg) C(1) Flag.Check(1) self.assertRaises(TypeError, C, 1, 2) class C(CCtor50): def __new__(cls, arg): return super(C, cls).__new__(cls, arg, 10) C(2) Flag.Check(12) class C(CCtor50): def __new__(cls, arg1, arg2): return super(C, cls).__new__(cls, arg1 + arg2) C(3, 4) Flag.Check(7) self.assertRaises(TypeError, C, 3) class C(CCtor50): def __new__(cls, arg1, arg2): return super(C, cls).__new__(cls, arg1, arg2) C(5, 6) Flag.Check(11)
def test_pass_in_wrapper(self): from Merlin.Testing import Flag from Merlin.Testing.Call import BooleanWrapperClass, BooleanWrapperStruct, ByteWrapperClass, ByteWrapperStruct, CharWrapperClass, CharWrapperStruct, \ Consumer, DoubleWrapperClass, DoubleWrapperStruct, DecimalWrapperClass, DecimalWrapperStruct, EnumWrapperClass, EnumWrapperStruct, \ Int16WrapperClass, Int16WrapperStruct, Int32WrapperClass, Int32WrapperStruct, Int64WrapperClass, Int64WrapperStruct, SByteWrapperClass, SByteWrapperStruct, \ SingleWrapperClass, SingleWrapperStruct, StringWrapperClass, StringWrapperStruct, UInt16WrapperClass, UInt16WrapperStruct, UInt32WrapperClass, UInt32WrapperStruct, \ UInt64WrapperClass, UInt64WrapperStruct from Merlin.Testing.TypeSample import EnumInt16 for (call, type1, type2, value, flag) in [ (Consumer.EatByte, ByteWrapperClass, ByteWrapperStruct, 1, 500), (Consumer.EatSByte, SByteWrapperClass, SByteWrapperStruct, 11, 510), (Consumer.EatUInt16, UInt16WrapperClass, UInt16WrapperStruct, 21, 520), (Consumer.EatInt16, Int16WrapperClass, Int16WrapperStruct, 31, 530), (Consumer.EatUInt32, UInt32WrapperClass, UInt32WrapperStruct, 41, 540), (Consumer.EatInt32, Int32WrapperClass, Int32WrapperStruct, 51, 550), (Consumer.EatUInt64, UInt64WrapperClass, UInt64WrapperStruct, 61, 560), (Consumer.EatInt64, Int64WrapperClass, Int64WrapperStruct, 71, 570), (Consumer.EatDouble, DoubleWrapperClass, DoubleWrapperStruct, 81, 580), (Consumer.EatSingle, SingleWrapperClass, SingleWrapperStruct, 91, 590), (Consumer.EatDecimal, DecimalWrapperClass, DecimalWrapperStruct, 101, 600), (Consumer.EatChar, CharWrapperClass, CharWrapperStruct, 'a', 610), (Consumer.EatBoolean, BooleanWrapperClass, BooleanWrapperStruct, True, 620), (Consumer.EatString, StringWrapperClass, StringWrapperStruct, 'python', 630), (Consumer.EatEnum, EnumWrapperClass, EnumWrapperStruct, EnumInt16.B, 640), ]: x = type1(value) self.assertEqual(call(x), value) Flag.Check(flag) x = type2(value) self.assertEqual(call(x), value) Flag.Check(flag)
def test_5_args(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor40 class C(CCtor40): pass C(1, 2, arg4=4, *(3, ), **{'arg5': 5}) Flag.Check(12345) class C(CCtor40): def __new__(cls, *args): return super(cls, C).__new__(cls, *args) #self.assertRaisesMessage(TypeError, "CCtor40() takes exactly 6 arguments (2 given)", C, 2) # bug 374515 C(2, 1, 3, 5, 4) Flag.Check(21354) class C(CCtor40): def __new__(cls, arg1, arg2, *arg3, **arg4): return super(cls, C).__new__(cls, arg1, arg2, *arg3, **arg4) self.assertRaisesMessage( TypeError, "__new__() got multiple values for keyword argument 'arg2'", eval, "C(3, arg2=1, *(2, 5), **{'arg5' : 4})", globals(), locals()) C(3, 1, *(2, 5), **{'arg5': 4}) Flag.Check(31254)
def test_long_hierarchy(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import Callback, CType11, CType21 class C(CType11): pass x = C() x.m1() Flag.Check(10) Flag.Reset() Callback.On(x) Flag.Check(10) class C(CType11): def m1(self): Flag.Set(20) x = C() Callback.On(x) Flag.Check(20) class C(CType21): pass x = C() self.assertRaises(AttributeError, Callback.On, x) class C(CType21): def m1(self): Flag.Set(30) x = C() Callback.On(x) Flag.Check(30)
def test_1_normal(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor20 class C(CCtor20): pass C(1) Flag.Check(1) self.assertRaises(TypeError, C) self.assertRaises(TypeError, C, 1, 2) class C(CCtor20): def __new__(cls, arg): return super(C, cls).__new__(cls, arg) C(2) Flag.Check(2) class C(CCtor20): def __new__(cls, arg): return super(C, cls).__new__(cls) self.assertRaises(TypeError, C, 2) class C(CCtor20): def __new__(cls): return super(C, cls).__new__(cls, 3) C() Flag.Check(3)
def test_boxing_conversion(self): from Merlin.Testing import Flag from Merlin.Testing.Call import AnyStruct, Consumer, StructBase from Merlin.Testing.TypeSample import EnumInt16, EnumUInt32 for x in [AnyStruct(), EnumInt16.B, None, StructBase()]: Consumer.EatValueType(x) Flag.Check(809) for x in [EnumInt16.A, EnumUInt32.C, None]: Consumer.EatEnumType(x) Flag.Check(810)
def test_methods_from_value_type(self): from Merlin.Testing import Flag from Merlin.Testing.Delegate import StructWithTargetMethods, VoidInt32Delegate d = VoidInt32Delegate target = StructWithTargetMethods() x = d(target.MVoidInt32) x(123) Flag.Check(246) x = d(StructWithTargetMethods.SMVoidInt32) x(321) Flag.Check(963)
def test_0(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor10 class C(CCtor10): pass C() Flag.Check(42) self.assertRaisesMessage(TypeError, "object.__new__() takes no parameters", C, 1) class C(CCtor10): def __new__(cls, arg1, arg2): return super(C, cls).__new__(cls) C(1, 2) Flag.Check(42)
def test_readonly_writeonly_derivation(self): from Merlin.Testing import Flag from Merlin.Testing.Property import ReadOnlyBase, WriteOnlyDerived x = WriteOnlyDerived() x.Number = 100 Flag.Check(100) self.assertRaisesMessage(AttributeError, "Number", lambda: x.Number) self.assertEqual(ReadOnlyBase.Number.GetValue(x), 21) x.Number = 101 Flag.Check(101) self.assertEqual(ReadOnlyBase.Number.GetValue(x), 21)
def test_overloads2(self): from Merlin.Testing import Flag from Merlin.Testing.Delegate import A100, B100, C100, ClassWithTargetMethods, VoidB100Delegate d = VoidB100Delegate target = ClassWithTargetMethods() y = d(target.MOverload8) a, b, c = A100(), B100(), C100() y(None) Flag.Check(820) #!!! 810 is what C# expects. y(b) Flag.Check(810) y(c) Flag.Check(820) #!!!
def test_generic_delegate(self): from Merlin.Testing import Flag from Merlin.Testing.Delegate import ClassWithTargetMethods, VoidTDelegate d = VoidTDelegate target = ClassWithTargetMethods() d(target.MVoidInt32)(1) Flag.Check(1) d[()](target.MVoidInt32)(-3) Flag.Check(-3) d[int](target.MVoidInt32)(5) Flag.Check(5)
def test_special_name(self): from Merlin.Testing import Flag #// keyword argument name, or **dict style #public void M800(int True) { } #public void M801(int def) { } f = self.o.M800 self.assertRaises(SyntaxError, eval, "f(True=9)") f(**{"True": 19}); Flag.Check(19) self.assertEqual(str(True), "True") f = self.o.M801 self.assertRaises(SyntaxError, eval, "f(def = 3)") f(**{"def": 8}); Flag.Check(8)
def test_cs_scenarios(self): from Merlin.Testing import Flag from Merlin.Testing.DefaultMemberSample import ClassWithItem, ClassWithget_Item, ClassWithset_Item, ClassWithDefaultMemberCtor x = ClassWithItem() self.assertRaises(TypeError, lambda: x[1]) x.Item = 2 self.assertEqual(x.Item, 2) x = ClassWithset_Item() def f(): x[10] = 20 self.assertRaises(TypeError, f) x.set_Item(3) Flag.Check(3) x = ClassWithget_Item() def f(): return x[10] self.assertRaises(TypeError, f) self.assertEqual(x[10, 20], 30) self.assertRaises(TypeError, x.get_Item, 10) self.assertEqual(x.get_Item(10, 20), 30) # try other types x = ClassWithDefaultMemberCtor(1)
def test_implicit_enum_conversion(self): import System from Merlin.Testing import Flag from Merlin.Testing.Call import Consumer Consumer.EatEnum(System.Int16(0)) Flag.Check(640) # tracking as 316744 self.assertRaises(TypeError, Consumer.EatEnum, 1)
def test_overload2(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor51 class C1(CCtor51): def __new__(cls, *args): return super(cls, C1).__new__(cls, *args) class C2(CCtor51): def __new__(cls, arg1, *arg2): return super(cls, C2).__new__(cls, arg1, *arg2) # more? for C in [C1, C2]: C(1); Flag.Check(10) C(1, 2); Flag.Check(20) C(self.array_int([1, 2, 3])); Flag.Check(20)
def test_overloads(self): from Merlin.Testing import Flag from Merlin.Testing.Delegate import ClassWithTargetMethods, VoidInt32Delegate d = VoidInt32Delegate target = ClassWithTargetMethods() y = d(target.MOverload1) y(1) Flag.Check(110) y = d(target.MOverload2) y(2) Flag.Check(200) y = d(target.MOverload3) y(3) Flag.Check(300)
def test_1_array(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor30 class C1(CCtor30): pass class C2(CCtor30): def __new__(cls, arg): return super(cls, C2).__new__(cls, arg) for C in [C1, C2]: self.assertRaises(TypeError, C) self.assertRaises(TypeError, C, 1) C(self.array_int([])) Flag.Check(0) C(self.array_int([1, 2])) Flag.Check(3)
def test_1_param_array(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor31 class C1(CCtor31): pass class C2(CCtor31): def __new__(cls, *arg): return super(cls, C2).__new__(cls, *arg) for C in [C1, C2]: C() Flag.Check(-20) #C(None); Flag.Check(-40) C(1) Flag.Check(1) C(2, 3) Flag.Check(5) C(self.array_int([])) Flag.Check(-20) C(self.array_int([4, 5, 6])) Flag.Check(15) self.assertRaises(TypeError, lambda: C([4, 5, 6])) class C3(CCtor31): def __new__(cls, arg): return super(cls, C3).__new__(cls, *arg) C3([1, 2]) Flag.Check(3) C(self.array_int([4, 5, 6])) Flag.Check(15)
def test_writeonly(self): from Merlin.Testing import Flag from Merlin.Testing.Property import ClassWithWriteOnly x = ClassWithWriteOnly() self.assertRaisesMessage(AttributeError, "InstanceProperty", lambda: x.InstanceProperty) # msg x.InstanceProperty = 1; Flag.Check(11) #ClassWithWriteOnly.StaticProperty # bug 362862 ClassWithWriteOnly.StaticProperty = "dlr" Flag.Check(12) self.assertRaisesRegexp(AttributeError, "unreadable property", lambda: ClassWithWriteOnly.__dict__['InstanceProperty'].__get__(x)) self.assertRaisesRegexp(AttributeError, "unreadable property", lambda: ClassWithWriteOnly.__dict__['InstanceProperty'].GetValue(x))
def test_relaxed_delegate_binding(self): from Merlin.Testing import Flag from Merlin.Testing.Delegate import Base, BaseDerivedDelegate, ClassWithTargetMethods, Derived, DerivedBaseDelegate b, d = Base(), Derived() target = ClassWithTargetMethods() x = BaseDerivedDelegate(target.MDerivedBase) x(d) Flag.Check(345) self.assertRaises(TypeError, lambda: x(b)) x = DerivedBaseDelegate(target.MBaseDerivedReturnNull) x(d) Flag.Check(678) x = DerivedBaseDelegate(target.MBaseDerived) self.assertRaises(TypeError, lambda: x(d)) self.assertRaises(TypeError, lambda: x(b))
def test_explicitly_call(self): from Merlin.Testing import Flag from Merlin.Testing.Call import AllOpsClass x = AllOpsClass(1) y = AllOpsClass(2) # binary z = AllOpsClass.op_Comma(x, y) self.assertEqual(z.Count, 2) self.assertEqual(z[1].Value, 2) Flag.Check(490) # unary z = AllOpsClass.op_LogicalNot(x) self.assertEqual(z, False) Flag.Check(130) self.AreValueFlagEqual(AllOpsClass.op_Increment(x), 2, 150) self.AreValueFlagEqual(AllOpsClass.op_Decrement(x), 0, 160)
def test_static_instance_methods(self): from Merlin.Testing import Flag from Merlin.Testing.Delegate import ClassWithTargetMethods, VoidInt32Delegate, VoidSelfInt32Delegate target = ClassWithTargetMethods() x = VoidInt32Delegate(ClassWithTargetMethods.SMVoidInt32) x(2) Flag.Check(20) x = VoidSelfInt32Delegate(ClassWithTargetMethods.MVoidInt32) x(target, 3) Flag.Check(3) x = VoidInt32Delegate(target.SMVoidInt32) x(4) Flag.Check(40) x = VoidSelfInt32Delegate(target.MVoidInt32) self.assertRaises(TypeError, lambda: x(target, 5))
def test_related_to_init(self): from Merlin.Testing import Flag from Merlin.Testing.BaseClass import CCtor20 class C(CCtor20): def __new__(cls, arg): x = super(C, cls).__new__(cls, arg) Flag.Check(arg) Flag.Set(arg * 2) return x def __init__(self, arg): Flag.Check(arg * 2) Flag.Set(arg * 3) C(4) Flag.Check(12) C.__init__ = lambda self, arg1, arg2: None self.assertRaises(TypeError, C, 4) C.__init__ = lambda self, arg: arg #self.assertRaises(TypeError, C, 4) # bug 374136 class C(CCtor20): def __new__(cls, arg): super(C, cls).__new__(cls, arg) # no return def __init__(self, arg): Flag.Set(2) # then not called here C(5) Flag.Check(5) class C(CCtor20): # no explicit __new__ def __init__(self, arg): Flag.Check(6) Flag.Set(7) C(6) Flag.Check(7)
def test_writeonly(self): from Merlin.Testing.Indexer import WriteOnlyIndexer from Merlin.Testing import Flag x = WriteOnlyIndexer() Flag.Set(0) x[1] = 10 Flag.Check(11) self.assertRaisesRegexp( TypeError, "'WriteOnlyIndexer' object is not subscriptable", lambda: x[1])
def test_add_method_descriptor(self): from Merlin.Testing import Flag from Merlin.Testing.Event import ClassWithSimpleEvent, TargetClass x = ClassWithSimpleEvent() x.OnAction += TargetClass.s_Negate x.OnAction += TargetClass.i_Double # method Flag.Set(0) self.assertRaisesMessage( TypeError, "i_Double() takes exactly 2 arguments (1 given)", lambda: x.CallInside(4)) Flag.Check(10)
def test_explicitly_implemented_property(self): from Merlin.Testing import Flag from Merlin.Testing.Property import ClassExplicitlyImplement, ClassExplicitlyReadOnly, IData, IReadOnlyData, IWriteOnlyData, StructExplicitlyImplement, StructExplicitlyWriteOnly from Merlin.Testing.TypeSample import SimpleClass, SimpleStruct for t in [ ClassExplicitlyImplement, StructExplicitlyImplement, ]: x = t() self.assertTrue(hasattr(x, 'Number')) d = IData.Number d.SetValue(x, 20) self.assertEqual(d.GetValue(x), 20) d.__set__(x, 30) self.assertEqual(d.__get__(x), 30) x = ClassExplicitlyReadOnly() d = IReadOnlyData.Number self.assertRaisesMessage(SystemError, "cannot set property", lambda: d.SetValue(x, "abc")) self.assertEqual(d.GetValue(x), "python") #self.assertRaisesMessage(AttributeError, "ddd", lambda: d.__set__(x, "abc")) # bug 362857 self.assertEqual(d.__get__(x), "python") x = StructExplicitlyWriteOnly() d = IWriteOnlyData.Number d.SetValue(x, SimpleStruct(3)) Flag.Check(13) self.assertRaisesMessage(AttributeError, "unreadable property", lambda: d.GetValue(x)) d.__set__(x, SimpleStruct(4)) Flag.Check(14) self.assertRaisesMessage(AttributeError, "unreadable property", lambda: d.__get__(x))
def test_create_from_another_delegate_object(self): from Merlin.Testing import Flag from Merlin.Testing.Delegate import ClassWithTargetMethods, VoidInt32Delegate, VoidInt32Int32Delegate, VoidInt32ParamsArrayDelegate d = VoidInt32Delegate target = ClassWithTargetMethods() y = d(target.MVoidInt32) y(-1) Flag.Check(-1) # positive z = d(y) z(2) Flag.Check(2) # negative self.assertRaisesMessage(TypeError, "Cannot cast Merlin.Testing.Delegate.VoidInt32Delegate to Merlin.Testing.Delegate.VoidInt32Int32Delegate.", VoidInt32Int32Delegate, y) self.assertRaisesMessage(TypeError, "Cannot cast Merlin.Testing.Delegate.VoidInt32Delegate to Merlin.Testing.Delegate.VoidInt32ParamsArrayDelegate.", VoidInt32ParamsArrayDelegate, y)
def test_2_byref_args(self): from Merlin.Testing import Flag from Merlin.Testing.Call import ByRefParameters obj = ByRefParameters() #public void M200(int arg1, ref int arg2) { Flag.Reset(); Flag.Value1 = arg1 * 10 + arg2; arg2 = 10; } f = obj.M200 self.assertEqual(f(1, 2), 10); Flag.Check(12) self.assertEqual(f(3, arg2 = 4), 10); Flag.Check(34) self.assertEqual(f(arg2 = 6, arg1 = 5), 10); Flag.Check(56) self.assertEqual(f(*(7, 8)), 10); Flag.Check(78) self.assertEqual(f(9, *(1,)), 10); Flag.Check(91) x = self.box_int(5); self.assertEqual(f(1, x), None); self.assertEqual(x.Value, 10); Flag.Check(15) x = self.box_int(6); f(2, x); self.assertEqual(x.Value, 10); Flag.Check(26) x = self.box_int(7); f(3, *(x,)); self.assertEqual(x.Value, 10); Flag.Check(37) x = self.box_int(8); f(**{'arg1': 4, 'arg2' : x}); self.assertEqual(x.Value, 10); Flag.Check(48) #public void M201(ref int arg1, int arg2) { Flag.Reset(); Flag.Value1 = arg1 * 10 + arg2; arg1 = 20; } f = obj.M201 self.assertEqual(f(1, 2), 20) x = self.box_int(2); f(x, *(2,)); self.assertEqual(x.Value, 20); Flag.Check(22) #public void M202(ref int arg1, ref int arg2) { Flag.Reset(); Flag.Value1 = arg1 * 10 + arg2; arg1 = 30; arg2 = 40; } f = obj.M202 self.assertEqual(f(1, 2), (30, 40)) self.assertEqual(f(arg2 = 1, arg1 = 2), (30, 40)); Flag.Check(21) self.assertRaisesMessage(TypeError, "expected int, got StrongBox[int]", lambda: f(self.box_int(3), 4)) # bug 311239 x = self.box_int(3) y = self.box_int(4) #f(arg2 = y, *(x,)); Flag.Check(34) # bug 311169 self.assertRaisesMessage(TypeError, "M202() got multiple values for keyword argument 'arg1'", lambda: f(arg1 = x, *(y,))) # msg # just curious x = y = self.box_int(5) f(x, y); self.assertEqual(x.Value, 40); self.assertEqual(y.Value, 40); Flag.Check(55)
def test_implicit_reference_conversions(self): import System from Merlin.Testing import Flag from Merlin.Testing.Call import AnyStruct, AnyReference, ClassBase, ClassDerived, Consumer, \ First, Int32WrapperClass, Int32WrapperStruct, Second, Source1, StructBase, StructDerived, Third from Merlin.Testing.TypeSample import VoidVoidDelegate, Int32Int32Delegate for x in [AnyStruct(), AnyReference(), None]: # boxing conversion for AnyStruct Consumer.EatObject(x); Flag.Check(801) for x in [First(), Second(), Third(), ClassDerived(), None]: Consumer.EatFirst(x); Flag.Check(808) for x in [ StructBase(), ClassBase(), StructDerived(), ClassDerived() ]: # boxing conversion for StructXXX Consumer.EatIBase(x); Flag.Check(802) a = System.Array[Source1]([Source1(), Source1()]) self.assertRaises(TypeError, Consumer.EatTarget1Array, a) self.assertRaises(TypeError, Consumer.EatTarget2Array, a) c = System.Array[int]([1, 2, 3]) d = System.Array[Int32WrapperClass]([Int32WrapperClass(1),]) e = System.Array[Int32WrapperStruct]([Int32WrapperStruct(2),]) self.assertRaisesMessage(TypeError, "expected Array[Int32WrapperClass], got Array[int]", Consumer.EatInt32WrapperClassArray, c) self.assertRaisesMessage(TypeError, "expected Array[Int32WrapperStruct], got Array[int]", Consumer.EatInt32WrapperStructArray, c) for x in [d, e]: self.assertRaises(TypeError, Consumer.EatInt32Array, x) f = System.Array[Second]([Second(), Second()]) g = System.Array[Third]([Third(), ]) for x in [f, g]: Consumer.EatFirstArray(f); Flag.Check(815) for x in [None, a, c, d, e, f, g]: Consumer.EatArray(x); Flag.Check(806) for x in [VoidVoidDelegate(Consumer.MVoidVoid), Int32Int32Delegate(Consumer.MInt32Int32)]: Consumer.EatDelegate(x); Flag.Check(807) a = AnyStruct() Consumer.EatAnyStruct(a); Flag.Check(850) self.assertRaisesMessage(TypeError, 'expected AnyStruct, got NoneType', Consumer.EatAnyStruct, None) for x in [a, None]: Consumer.EatNullableAnyStruct(a); Flag.Check(851)