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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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)
