def _test_set_by_type(self, current_type): import System from Merlin.Testing.FieldTest import EnumInt64 current_type.SetStaticFields() # pass correct values current_type.StaticByteField = 5 current_type.StaticSByteField = 10 current_type.StaticUInt16Field = 20 current_type.StaticInt16Field = 30 current_type.StaticUInt32Field = 40 current_type.StaticInt32Field = 50 current_type.StaticUInt64Field = 60 current_type.StaticInt64Field = 70 current_type.StaticDoubleField = 80 current_type.StaticSingleField = 90 current_type.StaticDecimalField = 100 current_type.StaticCharField = 'd' current_type.StaticBooleanField = False current_type.StaticStringField = 'testing'.upper() current_type.StaticObjectField = "number_to_string" current_type.StaticEnumField = EnumInt64.C current_type.StaticDateTimeField = System.DateTime(500000) current_type.StaticSimpleStructField = SimpleStruct(12340) current_type.StaticSimpleGenericStructField = SimpleGenericStruct[ System.UInt16](320) current_type.StaticNullableStructNotNullField = None current_type.StaticNullableStructNullField = SimpleStruct(650) current_type.StaticSimpleClassField = SimpleClass(540) current_type.StaticSimpleGenericClassField = SimpleGenericClass[str]( "string".upper()) current_type.StaticSimpleInterfaceField = ClassImplementSimpleInterface( 78) # verify self._test_verify(current_type) # set values which need conversion. current_type.StaticInt16Field = long(100) self.assertEqual(current_type.StaticInt16Field, 100) current_type.StaticBooleanField = 0 self.assertEqual(current_type.StaticBooleanField, False) # set bad values def f1(): current_type.StaticInt16Field = "abc" def f2(): current_type.StaticCharField = "abc" def f3(): current_type.StaticEnumField = EnumInt32.B for f in [f1, f2, f3]: self.assertRaises(TypeError, f)
def test_from_derived_type(self): from Merlin.Testing.Property import DerivedClass from Merlin.Testing.TypeSample import SimpleClass, SimpleStruct t = DerivedClass x = t() a, b, c = 8, SimpleStruct(7), SimpleClass(6) t.StaticInt32Property # read def f(): t.StaticInt32Property = a self.assertRaisesRegex( AttributeError, "'DerivedClass' object has no attribute 'StaticInt32Property'", f) # write x.InstanceInt32Property = a self.assertEqual(a, x.InstanceInt32Property) self.assertTrue('StaticSimpleStructProperty' not in t.__dict__) self.assertTrue('InstanceSimpleStructProperty' not in t.__dict__) p = t.__bases__[0].__dict__['InstanceSimpleStructProperty'] p.SetValue(x, b) self.assertEqual(b.Flag, p.GetValue(x).Flag) self.assertTrue('StaticSimpleClassProperty' not in t.__dict__) self.assertTrue('InstanceSimpleClassProperty' not in t.__dict__) p = t.__bases__[0].__dict__['InstanceSimpleClassProperty'] p.__set__(x, c) self.assertEqual(c, p.__get__(x))
def _test_set_by_descriptor(self, current_type): import System from Merlin.Testing.FieldTest import EnumInt64 current_type.SetStaticFields() o = current_type() # pass correct values current_type.__dict__['StaticByteField'].__set__(None, 5) current_type.__dict__['StaticSByteField'].__set__(None, 10) #current_type.__dict__['StaticSByteField'].__set__(o, 10) current_type.__dict__['StaticUInt16Field'].__set__(None, 20) current_type.__dict__['StaticInt16Field'].__set__(None, 30) current_type.__dict__['StaticUInt32Field'].__set__(None, 40) current_type.__dict__['StaticInt32Field'].__set__(None, 50) current_type.__dict__['StaticUInt64Field'].__set__(None, 60) current_type.__dict__['StaticInt64Field'].__set__(None, 70) current_type.__dict__['StaticDoubleField'].__set__(None, 80) current_type.__dict__['StaticSingleField'].__set__(None, 90) current_type.__dict__['StaticDecimalField'].__set__(None, 100) current_type.__dict__['StaticCharField'].__set__(None, 'd') current_type.__dict__['StaticBooleanField'].__set__(None, False) current_type.__dict__['StaticStringField'].__set__(None, 'TESTING') current_type.__dict__['StaticObjectField'].__set__( None, "number_to_string") current_type.__dict__['StaticEnumField'].__set__(None, EnumInt64.C) current_type.__dict__['StaticDateTimeField'].__set__( None, System.DateTime(500000)) current_type.__dict__['StaticSimpleStructField'].__set__( None, SimpleStruct(12340)) current_type.__dict__['StaticSimpleGenericStructField'].__set__( None, SimpleGenericStruct[System.UInt16](320)) current_type.__dict__['StaticNullableStructNotNullField'].__set__( None, None) current_type.__dict__['StaticNullableStructNullField'].__set__( None, SimpleStruct(650)) current_type.__dict__['StaticSimpleClassField'].__set__( None, SimpleClass(540)) current_type.__dict__['StaticSimpleGenericClassField'].__set__( None, SimpleGenericClass[str]("STRING")) current_type.__dict__['StaticSimpleInterfaceField'].__set__( None, ClassImplementSimpleInterface(78)) # verify self._test_verify(current_type)
def test_basic(self): from Merlin.Testing.Indexer import ClassWithIndexer, StructWithIndexer from Merlin.Testing.TypeSample import SimpleClass, SimpleStruct for t in [ ClassWithIndexer, StructWithIndexer, ]: x = t() x.Init() for y, z in zip(x, range(10)): self.assertEqual(y, z) a, b, c = 2, SimpleStruct(3), SimpleClass(4) x[1] = a self.assertEqual(x[1], a) x[2, "ab1"] = b self.assertEqual(x[12, "ab"].Flag, b.Flag) x['ab', 'c', 'd'] = c self.assertEqual(x['a', 'b', 'cd'], c) a, b, c = 5, SimpleStruct(6), SimpleClass(7) self.assertTrue(not hasattr(x, 'set_Item')) self.assertTrue(not hasattr(x, 'get_Item')) # bad arg count self.assertRaisesRegexp(TypeError, "expected int, got tuple", lambda: x[()]) self.assertRaisesRegexp( TypeError, "__getitem__\(\) takes at most 3 arguments \(4 given\)", lambda: x[1, 2, 3, 4]) # bad arg type self.assertRaisesRegexp(TypeError, "expected str, got int", lambda: x[1, 2, 3]) # bad value type def f(): x[1] = 'abc' self.assertRaisesRegexp(TypeError, "expected int, got str", f)
def test_selection(self): import System from Merlin.Testing.Call import Consumer from Merlin.Testing.TypeSample import EnumInt16, SimpleStruct f = Consumer.EatOmniTarget self.assertEqual(f(3.14), 10) self.assertEqual(f(314), 20) self.assertEqual(f(EnumInt16.A), 30) self.assertEqual(f(SimpleStruct(3)), 40) for x in [System.Byte.Parse("7"), True]: self.assertRaises(TypeError, f, x)
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_optional(self): import System from Merlin.Testing import Flag from Merlin.Testing.TypeSample import EnumInt32, SimpleClass, SimpleStruct #public void M231([Optional] int arg) { Flag.Set(arg); } // not reset any #public void M232([Optional] bool arg) { Flag<bool>.Set(arg); } #public void M233([Optional] object arg) { Flag<object>.Set(arg); } #public void M234([Optional] string arg) { Flag<string>.Set(arg); } #public void M235([Optional] EnumInt32 arg) { Flag<EnumInt32>.Set(arg); } #public void M236([Optional] SimpleClass arg) { Flag<SimpleClass>.Set(arg); } #public void M237([Optional] SimpleStruct arg) { Flag<SimpleStruct>.Set(arg); } ## testing the passed in value, and the default values self.o.M231(12); Flag.Check(12) self.o.M231(); Flag.Check(0) self.o.M232(True); Flag[bool].Check(True) self.o.M232(); Flag[bool].Check(False) def t(): pass self.o.M233(t); Flag[object].Check(t) self.o.M233(); Flag[object].Check(System.Type.Missing.Value) self.o.M234("ironpython"); Flag[str].Check("ironpython") self.o.M234(); Flag[str].Check(None) self.o.M235(EnumInt32.B); Flag[EnumInt32].Check(EnumInt32.B) self.o.M235(); Flag[EnumInt32].Check(EnumInt32.A) x = SimpleClass(23) self.o.M236(x); Flag[SimpleClass].Check(x) self.o.M236(); Flag[SimpleClass].Check(None) x = SimpleStruct(24) self.o.M237(x); Flag[SimpleStruct].Check(x) self.o.M237(); self.assertEqual(Flag[SimpleStruct].Value1.Flag, 0) ## testing the argument style f = self.o.M231 f(*()); Flag.Check(0) f(*(2, )); Flag.Check(2) f(arg = 3); Flag.Check(3) f(**{}); Flag.Check(0) f(*(), **{'arg':4}); Flag.Check(4) self.assertRaisesMessage(TypeError, "M231() takes at most 1 argument (2 given)", lambda: f(1, 2)) # msg self.assertRaisesMessage(TypeError, "M231() takes at most 1 argument (2 given)", lambda: f(1, **{'arg': 2})) # msg self.assertRaisesMessage(TypeError, "M231() takes at most 1 argument (2 given)", lambda: f(arg = 3, **{'arg': 4})) # msg self.assertRaisesMessage(TypeError, "M231() takes at most 1 argument (2 given)", lambda: f(arg = 3, **{'other': 4})) # msg
def f18(): t.__dict__['InstanceSimpleStructField'].__set__( v, SimpleStruct(12340))
def f18(): t.InstanceSimpleStructField.__set__(v, SimpleStruct(12340))
def f21(): t.InstanceNullableStructNullField.__set__(v, SimpleStruct(650))
def f18(): v.InstanceSimpleStructField = SimpleStruct(12340)
def f21(): v.InstanceNullableStructNullField = SimpleStruct(650)
def f20(): o.InitOnlyNullableStructField_Null = SimpleStruct(300)
def f21(): o.StaticNullableStructNullField = SimpleStruct(650)
def f21(): o.StaticNullableStructNullField = SimpleStruct(650) def f22(): o.StaticSimpleClassField = SimpleClass(540)
def f17(): current_type.InitOnlySimpleStructField = SimpleStruct(30) def f18(): current_type.InitOnlySimpleGenericStructField = SimpleGenericStruct[int](30) # instance has the wrong type
def f21(): v.InstanceNullableStructNullField = SimpleStruct(650) def f22(): v.InstanceSimpleClassField = SimpleClass(540)
def f20(): current_type.InitOnlyNullableStructField_Null = SimpleStruct(300)
def test_basic(self): from Merlin.Testing.Property import ClassWithProperties, StructWithProperties from Merlin.Testing.TypeSample import SimpleClass, SimpleStruct for t in [ ClassWithProperties, StructWithProperties, ]: # very basic: object.InstanceProperty, Type.StaticProperty x, y = t(), t() a, b, c = 1234, SimpleStruct(23), SimpleClass(45) self.assertEqual(x.InstanceInt32Property, 0) x.InstanceInt32Property = a self.assertEqual(x.InstanceInt32Property, a) self.assertTrue(x.InstanceSimpleStructProperty.Flag == 0) x.InstanceSimpleStructProperty = b self.assertTrue(b == x.InstanceSimpleStructProperty) self.assertEqual(b.Flag, x.InstanceSimpleStructProperty.Flag) self.assertEqual(x.InstanceSimpleClassProperty, None) x.InstanceSimpleClassProperty = c self.assertEqual(c, x.InstanceSimpleClassProperty) self.assertEqual(t.StaticInt32Property, 0) t.StaticInt32Property = a self.assertEqual(t.StaticInt32Property, a) t.StaticSimpleStructProperty = b self.assertEqual(b.Flag, t.StaticSimpleStructProperty.Flag) t.StaticSimpleClassProperty = c self.assertEqual(c, t.StaticSimpleClassProperty) # Type.InstanceProperty: SetValue/GetValue (on x), __set__/__get__ (on y) a, b, c = 34, SimpleStruct(56), SimpleClass(78) p = t.InstanceInt32Property self.assertEqual(p.SetValue(x, a), None) self.assertEqual(p.GetValue(x), a) p.__set__(y, a) #self.assertEqual(p.__get__(y), a) p = t.InstanceSimpleStructProperty p.SetValue(x, b) self.assertEqual(p.GetValue(x).Flag, b.Flag) p.__set__(y, b) #self.assertEqual(p.__get__(y).Flag, b.Flag) p = t.InstanceSimpleClassProperty p.SetValue(x, c) self.assertEqual(p.GetValue(x), c) p.__set__(y, c) #self.assertEqual(p.__get__(y), c) # instance.StaticProperty a, b, c = 21, SimpleStruct(32), SimpleClass(43) # can read static properties through instances... self.assertEqual(x.StaticInt32Property, 1234) self.assertEqual(type(x.StaticSimpleStructProperty), SimpleStruct) self.assertEqual(type(x.StaticSimpleClassProperty), SimpleClass) def w1(): x.StaticInt32Property = a def w2(): x.StaticSimpleStructProperty = b def w3(): x.StaticSimpleClassProperty = c for w in [w1, w2, w3]: self.assertRaisesRegex( AttributeError, "static property '.*' of '.*' can only be assigned to through a type, not an instance", w) # # type.__dict__['xxxProperty'] # x = t() a, b, c = 8, SimpleStruct(7), SimpleClass(6) p = t.__dict__['StaticInt32Property'] #p.SetValue(None, a) # bug 363241 #self.assertEqual(a, p.GetValue(None)) # static property against instance self.assertRaisesRegex(SystemError, "cannot set property", lambda: p.SetValue(x, a)) #self.assertRaisesRegex(SystemError, "cannot get property", lambda: p.GetValue(x)) # bug 363242 p = t.__dict__['InstanceInt32Property'] p.SetValue(x, a) #self.assertEqual(p.GetValue(x), a) # value type issue again # instance property against None self.assertRaisesRegex(SystemError, "cannot set property", lambda: p.SetValue(None, a)) #self.assertRaisesRegex(SystemError, "cannot get property", lambda: p.GetValue(None)) # bug 363247 p = t.__dict__['StaticSimpleStructProperty'] p.__set__(None, b) #self.assertEqual(b.Flag, p.__get__(None).Flag) # do we care??? #print p.__set__(x, b) #print p.__get__(x) p = t.__dict__['InstanceSimpleStructProperty'] p.__set__(x, b) #self.assertEqual(b.Flag, p.__get__(x).Flag) # do we care? #print p.__set__(None, b) #print p.__get__(None) p = t.__dict__['StaticSimpleClassProperty'] p.__set__(None, c) # similar to bug 363241 #self.assertEqual(c, p.__get__(None)) p = t.__dict__['InstanceSimpleClassProperty'] p.__set__(x, c)
def f18(): t.__dict__['InstanceSimpleStructField'].__set__(v, SimpleStruct(12340)) def f19(): t.__dict__['InstanceSimpleGenericStructField'].__set__(v, SimpleGenericStruct[System.UInt16](320))
def f21(): t.__dict__['InstanceNullableStructNullField'].__set__(v, SimpleStruct(650)) def f22(): t.__dict__['InstanceSimpleClassField'].__set__(v, SimpleClass(540))
def f21(): t.__dict__['InstanceNullableStructNullField'].__set__( v, SimpleStruct(650))
def f20(): current_type.InitOnlyNullableStructField_Null = SimpleStruct(300) def f21(): current_type.InitOnlySimpleClassField = SimpleClass(3000)
def f17(): o.InitOnlySimpleStructField = SimpleStruct(30)
def f18(): v.InstanceSimpleStructField = SimpleStruct(12340) def f19(): v.InstanceSimpleGenericStructField = SimpleGenericStruct[System.UInt16](320)
def f17(): current_type.InitOnlySimpleStructField = SimpleStruct(30)
def f18(): o.StaticSimpleStructField = SimpleStruct(12340)
def f20(): o.InitOnlyNullableStructField_Null = SimpleStruct(300) def f21(): o.InitOnlySimpleClassField = SimpleClass(3000)
def f18(): o.StaticSimpleStructField = SimpleStruct(12340) def f19(): o.StaticSimpleGenericStructField = SimpleGenericStruct[System.UInt16](320)