def test_decimal_conversion():
"""Test decimal conversion."""
from System import Decimal
max_d = Decimal.Parse("79228162514264337593543950335")
min_d = Decimal.Parse("-79228162514264337593543950335")
assert Decimal.ToInt64(Decimal(10)) == long(10)
ob = ConversionTest()
assert ob.DecimalField == Decimal(0)
ob.DecimalField = Decimal(10)
assert ob.DecimalField == Decimal(10)
ob.DecimalField = Decimal.One
assert ob.DecimalField == Decimal.One
ob.DecimalField = Decimal.Zero
assert ob.DecimalField == Decimal.Zero
ob.DecimalField = max_d
assert ob.DecimalField == max_d
ob.DecimalField = min_d
assert ob.DecimalField == min_d
with pytest.raises(TypeError):
ConversionTest().DecimalField = None
with pytest.raises(TypeError):
ConversionTest().DecimalField = "spam"
with pytest.raises(TypeError):
ConversionTest().DecimalField = 1
def test_char_conversion(self):
"""Test char conversion."""
self.assertTrue(System.Char.MaxValue == unichr(65535))
self.assertTrue(System.Char.MinValue == unichr(0))
ob = ConversionTest()
self.assertTrue(ob.CharField == u'A')
ob.CharField = 'B'
self.assertTrue(ob.CharField == u'B')
ob.CharField = u'B'
self.assertTrue(ob.CharField == u'B')
ob.CharField = 67
self.assertTrue(ob.CharField == u'C')
with self.assertRaises(OverflowError):
ConversionTest().CharField = 65536
with self.assertRaises(OverflowError):
ConversionTest().CharField = -1
with self.assertRaises(TypeError):
ConversionTest().CharField = None
def test_double_conversion():
"""Test double conversion."""
assert System.Double.MaxValue == 1.7976931348623157e308
assert System.Double.MinValue == -1.7976931348623157e308
ob = ConversionTest()
assert ob.DoubleField == 0.0
ob.DoubleField = 1.7976931348623157e308
assert ob.DoubleField == 1.7976931348623157e308
ob.DoubleField = -1.7976931348623157e308
assert ob.DoubleField == -1.7976931348623157e308
ob.DoubleField = System.Double(1.7976931348623157e308)
assert ob.DoubleField == 1.7976931348623157e308
ob.DoubleField = System.Double(-1.7976931348623157e308)
assert ob.DoubleField == -1.7976931348623157e308
with pytest.raises(TypeError):
ConversionTest().DoubleField = "spam"
with pytest.raises(TypeError):
ConversionTest().DoubleField = None
def testCharConversion(self):
"""Test char conversion."""
self.failUnless(System.Char.MaxValue == unichr(65535))
self.failUnless(System.Char.MinValue == unichr(0))
object = ConversionTest()
self.failUnless(object.CharField == u'A')
object.CharField = 'B'
self.failUnless(object.CharField == u'B')
object.CharField = u'B'
self.failUnless(object.CharField == u'B')
object.CharField = 67
self.failUnless(object.CharField == u'C')
def test():
ConversionTest().CharField = 65536
self.failUnlessRaises(OverflowError, test)
def test():
ConversionTest().CharField = -1
self.failUnlessRaises(OverflowError, test)
def test():
ConversionTest().CharField = None
self.failUnlessRaises(TypeError, test)
def testCharConversion(self):
"""Test char conversion."""
self.assertTrue(System.Char.MaxValue == unichr(65535))
self.assertTrue(System.Char.MinValue == unichr(0))
object = ConversionTest()
self.assertTrue(object.CharField == six.u('A'))
object.CharField = 'B'
self.assertTrue(object.CharField == six.u('B'))
object.CharField = six.u('B')
self.assertTrue(object.CharField == six.u('B'))
object.CharField = 67
self.assertTrue(object.CharField == six.u('C'))
def test():
ConversionTest().CharField = 65536
self.assertRaises(OverflowError, test)
def test():
ConversionTest().CharField = -1
self.assertRaises(OverflowError, test)
def test():
ConversionTest().CharField = None
self.assertRaises(TypeError, test)
def testObjectConversion(self):
"""Test object conversion."""
from Python.Test import Spam
object = ConversionTest()
self.assertTrue(object.ObjectField == None)
object.ObjectField = Spam("eggs")
self.assertTrue(object.ObjectField.__class__.__name__ == "Spam")
self.assertTrue(object.ObjectField.GetValue() == "eggs")
object.ObjectField = None
self.assertTrue(object.ObjectField == None)
object.ObjectField = System.String("spam")
self.assertTrue(object.ObjectField == "spam")
object.ObjectField = System.Int32(1)
self.assertTrue(object.ObjectField == 1)
# need to test subclass here
def test():
object = ConversionTest()
object.ObjectField = self
self.assertRaises(TypeError, test)
def testInterfaceConversion(self):
"""Test interface conversion."""
from Python.Test import Spam, ISpam
object = ConversionTest()
self.assertTrue(ISpam(object.SpamField).GetValue() == "spam")
self.assertTrue(object.SpamField.GetValue() == "spam")
object.SpamField = Spam("eggs")
self.assertTrue(ISpam(object.SpamField).GetValue() == "eggs")
self.assertTrue(object.SpamField.GetValue() == "eggs")
# need to test spam subclass here.
object.SpamField = None
self.assertTrue(object.SpamField == None)
def test():
object = ConversionTest()
object.SpamField = System.String("bad")
self.assertRaises(TypeError, test)
def test():
object = ConversionTest()
object.SpamField = System.Int32(1)
self.assertRaises(TypeError, test)
def testInterfaceConversion(self):
"""Test interface conversion."""
from Python.Test import Spam, ISpam
object = ConversionTest()
self.assertTrue(ISpam(object.SpamField).GetValue() == "spam")
self.assertTrue(object.SpamField.GetValue() == "spam")
object.SpamField = Spam("eggs")
self.assertTrue(ISpam(object.SpamField).GetValue() == "eggs")
self.assertTrue(object.SpamField.GetValue() == "eggs")
# need to test spam subclass here.
object.SpamField = None
self.assertTrue(object.SpamField == None)
def test():
object = ConversionTest()
object.SpamField = System.String("bad")
self.assertRaises(TypeError, test)
def test():
object = ConversionTest()
object.SpamField = System.Int32(1)
self.assertRaises(TypeError, test)
def testCharConversion(self):
"""Test char conversion."""
self.assertTrue(System.Char.MaxValue == unichr(65535))
self.assertTrue(System.Char.MinValue == unichr(0))
object = ConversionTest()
self.assertTrue(object.CharField == six.u('A'))
object.CharField = 'B'
self.assertTrue(object.CharField == six.u('B'))
object.CharField = six.u('B')
self.assertTrue(object.CharField == six.u('B'))
object.CharField = 67
self.assertTrue(object.CharField == six.u('C'))
def test():
ConversionTest().CharField = 65536
self.assertRaises(OverflowError, test)
def test():
ConversionTest().CharField = -1
self.assertRaises(OverflowError, test)
def test():
ConversionTest().CharField = None
self.assertRaises(TypeError, test)
def test_null_conversion():
"""Test null conversion."""
import System
ob = ConversionTest()
ob.StringField = None
assert ob.StringField is None
ob.ObjectField = None
assert ob.ObjectField is None
ob.SpamField = None
assert ob.SpamField is None
pi = 22/7
assert ob.Echo[System.Double](pi) == pi
assert ob.Echo[System.DateTime](None) is None
# Primitive types and enums should not be set to null.
with pytest.raises(TypeError):
ConversionTest().Int32Field = None
with pytest.raises(TypeError):
ConversionTest().EnumField = None
def test_char_conversion():
"""Test char conversion."""
assert System.Char.MaxValue == unichr(65535)
assert System.Char.MinValue == unichr(0)
ob = ConversionTest()
assert ob.CharField == u'A'
ob.CharField = 'B'
assert ob.CharField == u'B'
ob.CharField = u'B'
assert ob.CharField == u'B'
ob.CharField = 67
assert ob.CharField == u'C'
with pytest.raises(OverflowError):
ConversionTest().CharField = 65536
with pytest.raises(OverflowError):
ConversionTest().CharField = -1
with pytest.raises(TypeError):
ConversionTest().CharField = None
def test_interface_conversion():
"""Test interface conversion."""
from Python.Test import Spam, ISpam
ob = ConversionTest()
assert ISpam(ob.SpamField).GetValue() == "spam"
assert ob.SpamField.GetValue() == "spam"
ob.SpamField = Spam("eggs")
assert ISpam(ob.SpamField).GetValue() == "eggs"
assert ob.SpamField.GetValue() == "eggs"
# need to test spam subclass here.
ob.SpamField = None
assert ob.SpamField is None
with pytest.raises(TypeError):
ob = ConversionTest()
ob.SpamField = System.String("bad")
with pytest.raises(TypeError):
ob = ConversionTest()
ob.SpamField = System.Int32(1)
def test_object_conversion():
"""Test ob conversion."""
from Python.Test import Spam
ob = ConversionTest()
assert ob.ObjectField is None
ob.ObjectField = Spam("eggs")
assert ob.ObjectField.__class__.__name__ == "Spam"
assert ob.ObjectField.GetValue() == "eggs"
ob.ObjectField = None
assert ob.ObjectField is None
ob.ObjectField = System.String("spam")
assert ob.ObjectField == "spam"
ob.ObjectField = System.Int32(1)
assert ob.ObjectField == 1
# need to test subclass here
with pytest.raises(TypeError):
class Foo(object):
pass
ob = ConversionTest()
ob.ObjectField = Foo
def test_string_conversion():
"""Test string / unicode conversion."""
ob = ConversionTest()
assert ob.StringField == "spam"
assert ob.StringField == u"spam"
ob.StringField = "eggs"
assert ob.StringField == "eggs"
assert ob.StringField == u"eggs"
ob.StringField = u"spam"
assert ob.StringField == "spam"
assert ob.StringField == u"spam"
ob.StringField = u'\uffff\uffff'
assert ob.StringField == u'\uffff\uffff'
ob.StringField = System.String("spam")
assert ob.StringField == "spam"
assert ob.StringField == u"spam"
ob.StringField = System.String(u'\uffff\uffff')
assert ob.StringField == u'\uffff\uffff'
ob.StringField = None
assert ob.StringField is None
with pytest.raises(TypeError):
ConversionTest().StringField = 1
def testBoolConversion(self):
"""Test bool conversion."""
object = ConversionTest()
self.failUnless(object.BooleanField == False)
self.failUnless(object.BooleanField is False)
self.failUnless(object.BooleanField == 0)
object.BooleanField = True
self.failUnless(object.BooleanField == True)
self.failUnless(object.BooleanField is True)
self.failUnless(object.BooleanField == 1)
object.BooleanField = False
self.failUnless(object.BooleanField == False)
self.failUnless(object.BooleanField is False)
self.failUnless(object.BooleanField == 0)
object.BooleanField = 1
self.failUnless(object.BooleanField == True)
self.failUnless(object.BooleanField is True)
self.failUnless(object.BooleanField == 1)
object.BooleanField = 0
self.failUnless(object.BooleanField == False)
self.failUnless(object.BooleanField is False)
self.failUnless(object.BooleanField == 0)
object.BooleanField = System.Boolean(None)
self.failUnless(object.BooleanField == False)
self.failUnless(object.BooleanField is False)
self.failUnless(object.BooleanField == 0)
object.BooleanField = System.Boolean('')
self.failUnless(object.BooleanField == False)
self.failUnless(object.BooleanField is False)
self.failUnless(object.BooleanField == 0)
object.BooleanField = System.Boolean(0)
self.failUnless(object.BooleanField == False)
self.failUnless(object.BooleanField is False)
self.failUnless(object.BooleanField == 0)
object.BooleanField = System.Boolean(1)
self.failUnless(object.BooleanField == True)
self.failUnless(object.BooleanField is True)
self.failUnless(object.BooleanField == 1)
object.BooleanField = System.Boolean('a')
self.failUnless(object.BooleanField == True)
self.failUnless(object.BooleanField is True)
self.failUnless(object.BooleanField == 1)
def test_bool_conversion(self):
"""Test bool conversion."""
ob = ConversionTest()
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField == 0)
ob.BooleanField = True
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField == 1)
ob.BooleanField = False
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField == 0)
ob.BooleanField = 1
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField == 1)
ob.BooleanField = 0
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField == 0)
ob.BooleanField = System.Boolean(None)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField == 0)
ob.BooleanField = System.Boolean('')
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField == 0)
ob.BooleanField = System.Boolean(0)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField is False)
self.assertTrue(ob.BooleanField == 0)
ob.BooleanField = System.Boolean(1)
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField == 1)
ob.BooleanField = System.Boolean('a')
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField is True)
self.assertTrue(ob.BooleanField == 1)
def test_bool_conversion():
"""Test bool conversion."""
ob = ConversionTest()
assert ob.BooleanField is False
assert ob.BooleanField is False
assert ob.BooleanField == 0
ob.BooleanField = True
assert ob.BooleanField is True
assert ob.BooleanField is True
assert ob.BooleanField == 1
ob.BooleanField = False
assert ob.BooleanField is False
assert ob.BooleanField is False
assert ob.BooleanField == 0
ob.BooleanField = 1
assert ob.BooleanField is True
assert ob.BooleanField is True
assert ob.BooleanField == 1
ob.BooleanField = 0
assert ob.BooleanField is False
assert ob.BooleanField is False
assert ob.BooleanField == 0
ob.BooleanField = System.Boolean(None)
assert ob.BooleanField is False
assert ob.BooleanField is False
assert ob.BooleanField == 0
ob.BooleanField = System.Boolean('')
assert ob.BooleanField is False
assert ob.BooleanField is False
assert ob.BooleanField == 0
ob.BooleanField = System.Boolean(0)
assert ob.BooleanField is False
assert ob.BooleanField is False
assert ob.BooleanField == 0
ob.BooleanField = System.Boolean(1)
assert ob.BooleanField is True
assert ob.BooleanField is True
assert ob.BooleanField == 1
ob.BooleanField = System.Boolean('a')
assert ob.BooleanField is True
assert ob.BooleanField is True
assert ob.BooleanField == 1
def testStringConversion(self):
"""Test string / unicode conversion."""
object = ConversionTest()
self.assertTrue(object.StringField == "spam")
self.assertTrue(object.StringField == six.u("spam"))
object.StringField = "eggs"
self.assertTrue(object.StringField == "eggs")
self.assertTrue(object.StringField == six.u("eggs"))
object.StringField = six.u("spam")
self.assertTrue(object.StringField == "spam")
self.assertTrue(object.StringField == six.u("spam"))
object.StringField = six.u('\uffff\uffff')
self.assertTrue(object.StringField == six.u('\uffff\uffff'))
object.StringField = System.String("spam")
self.assertTrue(object.StringField == "spam")
self.assertTrue(object.StringField == six.u("spam"))
object.StringField = System.String(six.u('\uffff\uffff'))
self.assertTrue(object.StringField == six.u('\uffff\uffff'))
object.StringField = None
self.assertTrue(object.StringField == None)
def test():
ConversionTest().StringField = 1
self.assertRaises(TypeError, test)
def test_single_conversion():
"""Test single conversion."""
assert System.Single.MaxValue == pytest.approx(3.402823e38)
assert System.Single.MinValue == pytest.approx(-3.402823e38)
ob = ConversionTest()
assert ob.SingleField == 0.0
ob.SingleField = 3.402823e38
assert ob.SingleField == System.Single(3.402823e38)
ob.SingleField = -3.402823e38
assert ob.SingleField == System.Single(-3.402823e38)
with pytest.raises(TypeError):
ConversionTest().SingleField = "spam"
with pytest.raises(TypeError):
ConversionTest().SingleField = None
with pytest.raises(OverflowError):
ConversionTest().SingleField = 3.402824e38
with pytest.raises(OverflowError):
ConversionTest().SingleField = -3.402824e38
with pytest.raises(OverflowError):
_ = System.Single(3.402824e38)
with pytest.raises(OverflowError):
_ = System.Single(-3.402824e38)
def test_char_conversion():
"""Test char conversion."""
assert System.Char.MaxValue == chr(65535)
assert System.Char.MinValue == chr(0)
ob = ConversionTest()
assert ob.CharField == u'A'
ob.CharField = 'B'
assert ob.CharField == u'B'
ob.CharField = u'B'
assert ob.CharField == u'B'
ob.CharField = 67
assert ob.CharField == u'C'
with pytest.raises(OverflowError):
ConversionTest().CharField = 65536
with pytest.raises(OverflowError):
ConversionTest().CharField = -1
with pytest.raises(TypeError):
ConversionTest().CharField = None
def test_double_conversion():
"""Test double conversion."""
assert System.Double.MaxValue == 1.7976931348623157e308
assert System.Double.MinValue == -1.7976931348623157e308
ob = ConversionTest()
assert ob.DoubleField == 0.0
ob.DoubleField = 1.7976931348623157e308
assert ob.DoubleField == 1.7976931348623157e308
ob.DoubleField = -1.7976931348623157e308
assert ob.DoubleField == -1.7976931348623157e308
ob.DoubleField = System.Double(1.7976931348623157e308)
assert ob.DoubleField == 1.7976931348623157e308
ob.DoubleField = System.Double(-1.7976931348623157e308)
assert ob.DoubleField == -1.7976931348623157e308
with pytest.raises(TypeError):
ConversionTest().DoubleField = "spam"
with pytest.raises(TypeError):
ConversionTest().DoubleField = None
def testStringConversion(self):
"""Test string / unicode conversion."""
object = ConversionTest()
self.failUnless(object.StringField == "spam")
self.failUnless(object.StringField == u"spam")
object.StringField = "eggs"
self.failUnless(object.StringField == "eggs")
self.failUnless(object.StringField == u"eggs")
object.StringField = u"spam"
self.failUnless(object.StringField == "spam")
self.failUnless(object.StringField == u"spam")
object.StringField = u'\uffff\uffff'
self.failUnless(object.StringField == u'\uffff\uffff')
object.StringField = System.String("spam")
self.failUnless(object.StringField == "spam")
self.failUnless(object.StringField == u"spam")
object.StringField = System.String(u'\uffff\uffff')
self.failUnless(object.StringField == u'\uffff\uffff')
object.StringField = None
self.failUnless(object.StringField == None)
def test():
ConversionTest().StringField = 1
self.failUnlessRaises(TypeError, test)
def testInt64Conversion(self):
"""Test int64 conversion."""
self.failUnless(System.Int64.MaxValue == 9223372036854775807L)
self.failUnless(System.Int64.MinValue == -9223372036854775808L)
object = ConversionTest()
self.failUnless(object.Int64Field == 0)
object.Int64Field = 9223372036854775807L
self.failUnless(object.Int64Field == 9223372036854775807L)
object.Int64Field = -9223372036854775808L
self.failUnless(object.Int64Field == -9223372036854775808L)
object.Int64Field = System.Int64(9223372036854775807L)
self.failUnless(object.Int64Field == 9223372036854775807L)
object.Int64Field = System.Int64(-9223372036854775808L)
self.failUnless(object.Int64Field == -9223372036854775808L)
def test():
ConversionTest().Int64Field = "spam"
self.failUnlessRaises(TypeError, test)
def test():
ConversionTest().Int64Field = None
self.failUnlessRaises(TypeError, test)
def test():
ConversionTest().Int64Field = 9223372036854775808L
self.failUnlessRaises(OverflowError, test)
def test():
ConversionTest().Int64Field = -9223372036854775809L
self.failUnlessRaises(OverflowError, test)
def test():
value = System.Int64(9223372036854775808L)
self.failUnlessRaises(OverflowError, test)
def test():
value = System.Int64(-9223372036854775809L)
self.failUnlessRaises(OverflowError, test)
def testByteConversion(self):
"""Test byte conversion."""
self.assertTrue(System.Byte.MaxValue == 255)
self.assertTrue(System.Byte.MinValue == 0)
object = ConversionTest()
self.assertTrue(object.ByteField == 0)
object.ByteField = 255
self.assertTrue(object.ByteField == 255)
object.ByteField = 0
self.assertTrue(object.ByteField == 0)
object.ByteField = System.Byte(255)
self.assertTrue(object.ByteField == 255)
object.ByteField = System.Byte(0)
self.assertTrue(object.ByteField == 0)
def test():
ConversionTest().ByteField = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().ByteField = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().ByteField = 256
self.assertRaises(OverflowError, test)
def test():
ConversionTest().ByteField = -1
self.assertRaises(OverflowError, test)
def test():
value = System.Byte(256)
self.assertRaises(OverflowError, test)
def test():
value = System.Byte(-1)
self.assertRaises(OverflowError, test)
def testDoubleConversion(self):
"""Test double conversion."""
self.assertTrue(System.Double.MaxValue == 1.7976931348623157e308)
self.assertTrue(System.Double.MinValue == -1.7976931348623157e308)
object = ConversionTest()
self.assertTrue(object.DoubleField == 0.0)
object.DoubleField = 1.7976931348623157e308
self.assertTrue(object.DoubleField == 1.7976931348623157e308)
object.DoubleField = -1.7976931348623157e308
self.assertTrue(object.DoubleField == -1.7976931348623157e308)
object.DoubleField = System.Double(1.7976931348623157e308)
self.assertTrue(object.DoubleField == 1.7976931348623157e308)
object.DoubleField = System.Double(-1.7976931348623157e308)
self.assertTrue(object.DoubleField == -1.7976931348623157e308)
def test():
ConversionTest().DoubleField = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().DoubleField = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().DoubleField = 1.7976931348623159e308
self.assertRaises(OverflowError, test)
def test():
ConversionTest().DoubleField = -1.7976931348623159e308
self.assertRaises(OverflowError, test)
def test():
value = System.Double(1.7976931348623159e308)
self.assertRaises(OverflowError, test)
def test():
value = System.Double(-1.7976931348623159e308)
self.assertRaises(OverflowError, test)
def testSingleConversion(self):
"""Test single conversion."""
self.assertTrue(System.Single.MaxValue == 3.402823e38)
self.assertTrue(System.Single.MinValue == -3.402823e38)
object = ConversionTest()
self.assertTrue(object.SingleField == 0.0)
object.SingleField = 3.402823e38
self.assertTrue(object.SingleField == 3.402823e38)
object.SingleField = -3.402823e38
self.assertTrue(object.SingleField == -3.402823e38)
object.SingleField = System.Single(3.402823e38)
self.assertTrue(object.SingleField == 3.402823e38)
object.SingleField = System.Single(-3.402823e38)
self.assertTrue(object.SingleField == -3.402823e38)
def test():
ConversionTest().SingleField = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().SingleField = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().SingleField = 3.402824e38
self.assertRaises(OverflowError, test)
def test():
ConversionTest().SingleField = -3.402824e38
self.assertRaises(OverflowError, test)
def test():
value = System.Single(3.402824e38)
self.assertRaises(OverflowError, test)
def test():
value = System.Single(-3.402824e38)
self.assertRaises(OverflowError, test)
def testUInt32Conversion(self):
"""Test uint32 conversion."""
self.failUnless(System.UInt32.MaxValue == 4294967295L)
self.failUnless(System.UInt32.MinValue == 0)
object = ConversionTest()
self.failUnless(object.UInt32Field == 0)
object.UInt32Field = 4294967295L
self.failUnless(object.UInt32Field == 4294967295L)
object.UInt32Field = -0
self.failUnless(object.UInt32Field == 0)
object.UInt32Field = System.UInt32(4294967295L)
self.failUnless(object.UInt32Field == 4294967295L)
object.UInt32Field = System.UInt32(0)
self.failUnless(object.UInt32Field == 0)
def test():
ConversionTest().UInt32Field = "spam"
self.failUnlessRaises(TypeError, test)
def test():
ConversionTest().UInt32Field = None
self.failUnlessRaises(TypeError, test)
def test():
ConversionTest().UInt32Field = 4294967296L
self.failUnlessRaises(OverflowError, test)
def test():
ConversionTest().UInt32Field = -1
self.failUnlessRaises(OverflowError, test)
def test():
value = System.UInt32(4294967296L)
self.failUnlessRaises(OverflowError, test)
def test():
value = System.UInt32(-1)
self.failUnlessRaises(OverflowError, test)
def testUInt32Conversion(self):
"""Test uint32 conversion."""
self.assertTrue(System.UInt32.MaxValue == long(4294967295))
self.assertTrue(System.UInt32.MinValue == 0)
object = ConversionTest()
self.assertTrue(object.UInt32Field == 0)
object.UInt32Field = long(4294967295)
self.assertTrue(object.UInt32Field == long(4294967295))
object.UInt32Field = -0
self.assertTrue(object.UInt32Field == 0)
object.UInt32Field = System.UInt32(long(4294967295))
self.assertTrue(object.UInt32Field == long(4294967295))
object.UInt32Field = System.UInt32(0)
self.assertTrue(object.UInt32Field == 0)
def test():
ConversionTest().UInt32Field = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().UInt32Field = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().UInt32Field = long(4294967296)
self.assertRaises(OverflowError, test)
def test():
ConversionTest().UInt32Field = -1
self.assertRaises(OverflowError, test)
def test():
value = System.UInt32(long(4294967296))
self.assertRaises(OverflowError, test)
def test():
value = System.UInt32(-1)
self.assertRaises(OverflowError, test)
def testUInt64Conversion(self):
"""Test uint64 conversion."""
self.assertTrue(System.UInt64.MaxValue == long(18446744073709551615))
self.assertTrue(System.UInt64.MinValue == 0)
object = ConversionTest()
self.assertTrue(object.UInt64Field == 0)
object.UInt64Field = long(18446744073709551615)
self.assertTrue(object.UInt64Field == long(18446744073709551615))
object.UInt64Field = -0
self.assertTrue(object.UInt64Field == 0)
object.UInt64Field = System.UInt64(long(18446744073709551615))
self.assertTrue(object.UInt64Field == long(18446744073709551615))
object.UInt64Field = System.UInt64(0)
self.assertTrue(object.UInt64Field == 0)
def test():
ConversionTest().UInt64Field = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().UInt64Field = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().UInt64Field = long(18446744073709551616)
self.assertRaises(OverflowError, test)
def test():
ConversionTest().UInt64Field = -1
self.assertRaises(OverflowError, test)
def test():
value = System.UInt64(long(18446744073709551616))
self.assertRaises(OverflowError, test)
def test():
value = System.UInt64(-1)
self.assertRaises(OverflowError, test)
def testInt64Conversion(self):
"""Test int64 conversion."""
self.assertTrue(System.Int64.MaxValue == long(9223372036854775807))
self.assertTrue(System.Int64.MinValue == long(-9223372036854775808))
object = ConversionTest()
self.assertTrue(object.Int64Field == 0)
object.Int64Field = long(9223372036854775807)
self.assertTrue(object.Int64Field == long(9223372036854775807))
object.Int64Field = long(-9223372036854775808)
self.assertTrue(object.Int64Field == long(-9223372036854775808))
object.Int64Field = System.Int64(long(9223372036854775807))
self.assertTrue(object.Int64Field == long(9223372036854775807))
object.Int64Field = System.Int64(long(-9223372036854775808))
self.assertTrue(object.Int64Field == long(-9223372036854775808))
def test():
ConversionTest().Int64Field = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().Int64Field = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().Int64Field = long(9223372036854775808)
self.assertRaises(OverflowError, test)
def test():
ConversionTest().Int64Field = long(-9223372036854775809)
self.assertRaises(OverflowError, test)
def test():
value = System.Int64(long(9223372036854775808))
self.assertRaises(OverflowError, test)
def test():
value = System.Int64(long(-9223372036854775809))
self.assertRaises(OverflowError, test)
def testUInt16Conversion(self):
"""Test uint16 conversion."""
self.assertTrue(System.UInt16.MaxValue == 65535)
self.assertTrue(System.UInt16.MinValue == 0)
object = ConversionTest()
self.assertTrue(object.UInt16Field == 0)
object.UInt16Field = 65535
self.assertTrue(object.UInt16Field == 65535)
object.UInt16Field = -0
self.assertTrue(object.UInt16Field == 0)
object.UInt16Field = System.UInt16(65535)
self.assertTrue(object.UInt16Field == 65535)
object.UInt16Field = System.UInt16(0)
self.assertTrue(object.UInt16Field == 0)
def test():
ConversionTest().UInt16Field = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().UInt16Field = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().UInt16Field = 65536
self.assertRaises(OverflowError, test)
def test():
ConversionTest().UInt16Field = -1
self.assertRaises(OverflowError, test)
def test():
value = System.UInt16(65536)
self.assertRaises(OverflowError, test)
def test():
value = System.UInt16(-1)
self.assertRaises(OverflowError, test)
def testInt16Conversion(self):
"""Test int16 conversion."""
self.assertTrue(System.Int16.MaxValue == 32767)
self.assertTrue(System.Int16.MinValue == -32768)
object = ConversionTest()
self.assertTrue(object.Int16Field == 0)
object.Int16Field = 32767
self.assertTrue(object.Int16Field == 32767)
object.Int16Field = -32768
self.assertTrue(object.Int16Field == -32768)
object.Int16Field = System.Int16(32767)
self.assertTrue(object.Int16Field == 32767)
object.Int16Field = System.Int16(-32768)
self.assertTrue(object.Int16Field == -32768)
def test():
ConversionTest().Int16Field = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().Int16Field = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().Int16Field = 32768
self.assertRaises(OverflowError, test)
def test():
ConversionTest().Int16Field = -32769
self.assertRaises(OverflowError, test)
def test():
value = System.Int16(32768)
self.assertRaises(OverflowError, test)
def test():
value = System.Int16(-32769)
self.assertRaises(OverflowError, test)
def testInt32Conversion(self):
"""Test int32 conversion."""
self.assertTrue(System.Int32.MaxValue == 2147483647)
self.assertTrue(System.Int32.MinValue == -2147483648)
object = ConversionTest()
self.assertTrue(object.Int32Field == 0)
object.Int32Field = 2147483647
self.assertTrue(object.Int32Field == 2147483647)
object.Int32Field = -2147483648
self.assertTrue(object.Int32Field == -2147483648)
object.Int32Field = System.Int32(2147483647)
self.assertTrue(object.Int32Field == 2147483647)
object.Int32Field = System.Int32(-2147483648)
self.assertTrue(object.Int32Field == -2147483648)
def test():
ConversionTest().Int32Field = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().Int32Field = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().Int32Field = 2147483648
self.assertRaises(OverflowError, test)
def test():
ConversionTest().Int32Field = -2147483649
self.assertRaises(OverflowError, test)
def test():
value = System.Int32(2147483648)
self.assertRaises(OverflowError, test)
def test():
value = System.Int32(-2147483649)
self.assertRaises(OverflowError, test)
def testSByteConversion(self):
"""Test sbyte conversion."""
self.assertTrue(System.SByte.MaxValue == 127)
self.assertTrue(System.SByte.MinValue == -128)
object = ConversionTest()
self.assertTrue(object.SByteField == 0)
object.SByteField = 127
self.assertTrue(object.SByteField == 127)
object.SByteField = -128
self.assertTrue(object.SByteField == -128)
object.SByteField = System.SByte(127)
self.assertTrue(object.SByteField == 127)
object.SByteField = System.SByte(-128)
self.assertTrue(object.SByteField == -128)
def test():
ConversionTest().SByteField = "spam"
self.assertRaises(TypeError, test)
def test():
ConversionTest().SByteField = None
self.assertRaises(TypeError, test)
def test():
ConversionTest().SByteField = 128
self.assertRaises(OverflowError, test)
def test():
ConversionTest().SByteField = -129
self.assertRaises(OverflowError, test)
def test():
value = System.SByte(128)
self.assertRaises(OverflowError, test)
def test():
value = System.SByte(-129)
self.assertRaises(OverflowError, test)
def testUInt64Conversion(self):
"""Test uint64 conversion."""
self.failUnless(System.UInt64.MaxValue == 18446744073709551615L)
self.failUnless(System.UInt64.MinValue == 0)
object = ConversionTest()
self.failUnless(object.UInt64Field == 0)
object.UInt64Field = 18446744073709551615L
self.failUnless(object.UInt64Field == 18446744073709551615L)
object.UInt64Field = -0
self.failUnless(object.UInt64Field == 0)
object.UInt64Field = System.UInt64(18446744073709551615L)
self.failUnless(object.UInt64Field == 18446744073709551615L)
object.UInt64Field = System.UInt64(0)
self.failUnless(object.UInt64Field == 0)
def test():
ConversionTest().UInt64Field = "spam"
self.failUnlessRaises(TypeError, test)
def test():
ConversionTest().UInt64Field = None
self.failUnlessRaises(TypeError, test)
def test():
ConversionTest().UInt64Field = 18446744073709551616L
self.failUnlessRaises(OverflowError, test)
def test():
ConversionTest().UInt64Field = -1
self.failUnlessRaises(OverflowError, test)
def test():
value = System.UInt64(18446744073709551616L)
self.failUnlessRaises(OverflowError, test)
def test():
value = System.UInt64(-1)
self.failUnlessRaises(OverflowError, test)
def test_timedelta_conversion():
import datetime
ob = ConversionTest()
assert type(ob.TimeSpanField) is type(datetime.timedelta(0))
assert ob.TimeSpanField.days == 0
ob.TimeSpanField = datetime.timedelta(days=1)
assert ob.TimeSpanField.days == 1
with pytest.raises(TypeError):
ConversionTest().TimeSpanField = None
with pytest.raises(TypeError):
ConversionTest().TimeSpanField = "spam"
def test_datetime_conversion():
from datetime import datetime
ob = ConversionTest()
assert type(ob.DateTimeField) is type(datetime(1, 1, 1))
assert ob.DateTimeField.day == 1
ob.DateTimeField = datetime(2000, 1, 2)
assert ob.DateTimeField.day == 2
assert ob.DateTimeField.month == 1
assert ob.DateTimeField.year == 2000
with pytest.raises(TypeError):
ConversionTest().DateTimeField = None
with pytest.raises(TypeError):
ConversionTest().DateTimeField = "spam"
def testSByteArrayConversion(self):
"""Test sbyte array conversion."""
object = ConversionTest()
self.failUnless(object.SByteArrayField == None)
object.SByteArrayField = [0, 1, 2 , 3, 4]
array = object.SByteArrayField
self.failUnless(len(array) == 5)
self.failUnless(array[0] == 0)
self.failUnless(array[4] == 4)
value = "testing"
object.SByteArrayField = value
array = object.SByteArrayField
for i in range(len(value)):
self.failUnless(array[i] == ord(value[i]))
def test_sbyte_array_conversion(self):
"""Test sbyte array conversion."""
ob = ConversionTest()
self.assertTrue(ob.SByteArrayField is None)
ob.SByteArrayField = [0, 1, 2, 3, 4]
array = ob.SByteArrayField
self.assertTrue(len(array) == 5)
self.assertTrue(array[0] == 0)
self.assertTrue(array[4] == 4)
value = b"testing"
ob.SByteArrayField = value
array = ob.SByteArrayField
for i, _ in enumerate(value):
self.assertTrue(array[i] == indexbytes(value, i))
def test_sbyte_array_conversion():
"""Test sbyte array conversion."""
ob = ConversionTest()
assert ob.SByteArrayField is None
ob.SByteArrayField = [0, 1, 2, 3, 4]
array = ob.SByteArrayField
assert len(array) == 5
assert array[0] == 0
assert array[4] == 4
value = b"testing"
ob.SByteArrayField = value
array = ob.SByteArrayField
for i, _ in enumerate(value):
assert array[i] == operator.getitem(value, i)
def testSByteArrayConversion(self):
"""Test sbyte array conversion."""
object = ConversionTest()
self.assertTrue(object.SByteArrayField == None)
object.SByteArrayField = [0, 1, 2, 3, 4]
array = object.SByteArrayField
self.assertTrue(len(array) == 5)
self.assertTrue(array[0] == 0)
self.assertTrue(array[4] == 4)
value = six.b("testing")
object.SByteArrayField = value
array = object.SByteArrayField
for i in range(len(value)):
self.assertTrue(array[i] == six.indexbytes(value, i))
def test_sbyte_array_conversion():
"""Test sbyte array conversion."""
ob = ConversionTest()
assert ob.SByteArrayField is None
ob.SByteArrayField = [0, 1, 2, 3, 4]
array = ob.SByteArrayField
assert len(array) == 5
assert array[0] == 0
assert array[4] == 4
value = b"testing"
ob.SByteArrayField = value
array = ob.SByteArrayField
for i, _ in enumerate(value):
assert array[i] == indexbytes(value, i)
def testSByteArrayConversion(self):
"""Test sbyte array conversion."""
object = ConversionTest()
self.assertTrue(object.SByteArrayField == None)
object.SByteArrayField = [0, 1, 2, 3, 4]
array = object.SByteArrayField
self.assertTrue(len(array) == 5)
self.assertTrue(array[0] == 0)
self.assertTrue(array[4] == 4)
value = six.b("testing")
object.SByteArrayField = value
array = object.SByteArrayField
for i in range(len(value)):
self.assertTrue(array[i] == six.indexbytes(value, i))
def test_string_conversion(self):
"""Test string / unicode conversion."""
ob = ConversionTest()
self.assertTrue(ob.StringField == "spam")
self.assertTrue(ob.StringField == u"spam")
ob.StringField = "eggs"
self.assertTrue(ob.StringField == "eggs")
self.assertTrue(ob.StringField == u"eggs")
ob.StringField = u"spam"
self.assertTrue(ob.StringField == "spam")
self.assertTrue(ob.StringField == u"spam")
ob.StringField = u'\uffff\uffff'
self.assertTrue(ob.StringField == u'\uffff\uffff')
ob.StringField = System.String("spam")
self.assertTrue(ob.StringField == "spam")
self.assertTrue(ob.StringField == u"spam")
ob.StringField = System.String(u'\uffff\uffff')
self.assertTrue(ob.StringField == u'\uffff\uffff')
ob.StringField = None
self.assertTrue(ob.StringField is None)
with self.assertRaises(TypeError):
ConversionTest().StringField = 1
def test_null_conversion():
"""Test null conversion."""
import System
ob = ConversionTest()
ob.StringField = None
assert ob.StringField is None
ob.ObjectField = None
assert ob.ObjectField is None
ob.SpamField = None
assert ob.SpamField is None
pi = 22 / 7
assert ob.Echo[System.Double](pi) == pi
assert ob.Echo[System.DateTime](None) is None
# Primitive types and enums should not be set to null.
with pytest.raises(TypeError):
ConversionTest().Int32Field = None
with pytest.raises(TypeError):
ConversionTest().EnumField = None
def testStringConversion(self):
"""Test string / unicode conversion."""
object = ConversionTest()
self.assertTrue(object.StringField == "spam")
self.assertTrue(object.StringField == six.u("spam"))
object.StringField = "eggs"
self.assertTrue(object.StringField == "eggs")
self.assertTrue(object.StringField == six.u("eggs"))
object.StringField = six.u("spam")
self.assertTrue(object.StringField == "spam")
self.assertTrue(object.StringField == six.u("spam"))
object.StringField = six.u('\uffff\uffff')
self.assertTrue(object.StringField == six.u('\uffff\uffff'))
object.StringField = System.String("spam")
self.assertTrue(object.StringField == "spam")
self.assertTrue(object.StringField == six.u("spam"))
object.StringField = System.String(six.u('\uffff\uffff'))
self.assertTrue(object.StringField == six.u('\uffff\uffff'))
object.StringField = None
self.assertTrue(object.StringField == None)
def test():
ConversionTest().StringField = 1
self.assertRaises(TypeError, test)
def testEnumConversion(self):
"""Test enum conversion."""
from Python.Test import ShortEnum
object = ConversionTest()
self.failUnless(object.EnumField == ShortEnum.Zero)
object.EnumField = ShortEnum.One
self.failUnless(object.EnumField == ShortEnum.One)
object.EnumField = 0
self.failUnless(object.EnumField == ShortEnum.Zero)
self.failUnless(object.EnumField == 0)
object.EnumField = 1
self.failUnless(object.EnumField == ShortEnum.One)
self.failUnless(object.EnumField == 1)
def test():
object = ConversionTest()
object.EnumField = 10
self.failUnlessRaises(ValueError, test)
def test():
object = ConversionTest()
object.EnumField = 255
self.failUnlessRaises(ValueError, test)
def test():
object = ConversionTest()
object.EnumField = 1000000
self.failUnlessRaises(OverflowError, test)
def test():
object = ConversionTest()
object.EnumField = "spam"
self.failUnlessRaises(TypeError, test)
def test_uint64_conversion():
"""Test uint64 conversion."""
assert System.UInt64.MaxValue == 18446744073709551615
assert System.UInt64.MinValue == 0
ob = ConversionTest()
assert ob.UInt64Field == 0
ob.UInt64Field = 18446744073709551615
assert ob.UInt64Field == 18446744073709551615
ob.UInt64Field = -0
assert ob.UInt64Field == 0
ob.UInt64Field = System.UInt64(18446744073709551615)
assert ob.UInt64Field == 18446744073709551615
ob.UInt64Field = System.UInt64(0)
assert ob.UInt64Field == 0
# Implicitly converts float 0.5 -> int 0
#with pytest.raises(TypeError):
#ConversionTest().UInt64Field = 0.5
with pytest.raises(ValueError):
ConversionTest().UInt64Field = "spam"
with pytest.raises(TypeError):
ConversionTest().UInt64Field = None
with pytest.raises(OverflowError):
ConversionTest().UInt64Field = 18446744073709551616
with pytest.raises(OverflowError):
ConversionTest().UInt64Field = -1
with pytest.raises(OverflowError):
_ = System.UInt64((18446744073709551616))
with pytest.raises(OverflowError):
_ = System.UInt64(-1)
def testObjectConversion(self):
"""Test object conversion."""
from Python.Test import Spam
object = ConversionTest()
self.failUnless(object.ObjectField == None)
object.ObjectField = Spam("eggs")
self.failUnless(object.ObjectField.__class__.__name__ == "Spam")
self.failUnless(object.ObjectField.GetValue() == "eggs")
object.ObjectField = None
self.failUnless(object.ObjectField == None)
object.ObjectField = System.String("spam")
self.failUnless(object.ObjectField == "spam")
object.ObjectField = System.Int32(1)
self.failUnless(object.ObjectField == 1)
# need to test subclass here
def test():
object = ConversionTest()
object.ObjectField = self
self.failUnlessRaises(TypeError, test)
def test_uint16_conversion():
"""Test uint16 conversion."""
assert System.UInt16.MaxValue == 65535
assert System.UInt16.MinValue == 0
ob = ConversionTest()
assert ob.UInt16Field == 0
ob.UInt16Field = 65535
assert ob.UInt16Field == 65535
ob.UInt16Field = -0
assert ob.UInt16Field == 0
ob.UInt16Field = System.UInt16(65535)
assert ob.UInt16Field == 65535
ob.UInt16Field = System.UInt16(0)
assert ob.UInt16Field == 0
with pytest.raises(TypeError):
ConversionTest().UInt16Field = "spam"
with pytest.raises(TypeError):
ConversionTest().UInt16Field = None
with pytest.raises(OverflowError):
ConversionTest().UInt16Field = 65536
with pytest.raises(OverflowError):
ConversionTest().UInt16Field = -1
with pytest.raises(OverflowError):
_ = System.UInt16(65536)
with pytest.raises(OverflowError):
_ = System.UInt16(-1)
def test_byte_conversion():
"""Test byte conversion."""
assert System.Byte.MaxValue == 255
assert System.Byte.MinValue == 0
ob = ConversionTest()
assert ob.ByteField == 0
ob.ByteField = 255
assert ob.ByteField == 255
ob.ByteField = 0
assert ob.ByteField == 0
ob.ByteField = System.Byte(255)
assert ob.ByteField == 255
ob.ByteField = System.Byte(0)
assert ob.ByteField == 0
with pytest.raises(TypeError):
ConversionTest().ByteField = "spam"
with pytest.raises(TypeError):
ConversionTest().ByteField = None
with pytest.raises(OverflowError):
ConversionTest().ByteField = 256
with pytest.raises(OverflowError):
ConversionTest().ByteField = -1
with pytest.raises(OverflowError):
_ = System.Byte(256)
with pytest.raises(OverflowError):
_ = System.Byte(-1)
def test_uint64_conversion():
"""Test uint64 conversion."""
assert System.UInt64.MaxValue == long(18446744073709551615)
assert System.UInt64.MinValue == 0
ob = ConversionTest()
assert ob.UInt64Field == 0
ob.UInt64Field = long(18446744073709551615)
assert ob.UInt64Field == long(18446744073709551615)
ob.UInt64Field = -0
assert ob.UInt64Field == 0
ob.UInt64Field = System.UInt64(long(18446744073709551615))
assert ob.UInt64Field == long(18446744073709551615)
ob.UInt64Field = System.UInt64(0)
assert ob.UInt64Field == 0
with pytest.raises(TypeError):
ConversionTest().UInt64Field = "spam"
with pytest.raises(TypeError):
ConversionTest().UInt64Field = None
with pytest.raises(OverflowError):
ConversionTest().UInt64Field = long(18446744073709551616)
with pytest.raises(OverflowError):
ConversionTest().UInt64Field = -1
with pytest.raises(OverflowError):
_ = System.UInt64(long(18446744073709551616))
with pytest.raises(OverflowError):
_ = System.UInt64(-1)
def test_int16_conversion():
"""Test int16 conversion."""
assert System.Int16.MaxValue == 32767
assert System.Int16.MinValue == -32768
ob = ConversionTest()
assert ob.Int16Field == 0
ob.Int16Field = 32767
assert ob.Int16Field == 32767
ob.Int16Field = -32768
assert ob.Int16Field == -32768
ob.Int16Field = System.Int16(32767)
assert ob.Int16Field == 32767
ob.Int16Field = System.Int16(-32768)
assert ob.Int16Field == -32768
with pytest.raises(TypeError):
ConversionTest().Int16Field = "spam"
with pytest.raises(TypeError):
ConversionTest().Int16Field = None
with pytest.raises(OverflowError):
ConversionTest().Int16Field = 32768
with pytest.raises(OverflowError):
ConversionTest().Int16Field = -32769
with pytest.raises(OverflowError):
_ = System.Int16(32768)
with pytest.raises(OverflowError):
_ = System.Int16(-32769)
def test_int32_conversion():
"""Test int32 conversion."""
assert System.Int32.MaxValue == 2147483647
assert System.Int32.MinValue == -2147483648
ob = ConversionTest()
assert ob.Int32Field == 0
ob.Int32Field = 2147483647
assert ob.Int32Field == 2147483647
ob.Int32Field = -2147483648
assert ob.Int32Field == -2147483648
ob.Int32Field = System.Int32(2147483647)
assert ob.Int32Field == 2147483647
ob.Int32Field = System.Int32(-2147483648)
assert ob.Int32Field == -2147483648
with pytest.raises(TypeError):
ConversionTest().Int32Field = "spam"
with pytest.raises(TypeError):
ConversionTest().Int32Field = None
with pytest.raises(OverflowError):
ConversionTest().Int32Field = 2147483648
with pytest.raises(OverflowError):
ConversionTest().Int32Field = -2147483649
with pytest.raises(OverflowError):
_ = System.Int32(2147483648)
with pytest.raises(OverflowError):
_ = System.Int32(-2147483649)
def test_sbyte_conversion():
"""Test sbyte conversion."""
assert System.SByte.MaxValue == 127
assert System.SByte.MinValue == -128
ob = ConversionTest()
assert ob.SByteField == 0
ob.SByteField = 127
assert ob.SByteField == 127
ob.SByteField = -128
assert ob.SByteField == -128
ob.SByteField = System.SByte(127)
assert ob.SByteField == 127
ob.SByteField = System.SByte(-128)
assert ob.SByteField == -128
with pytest.raises(TypeError):
ConversionTest().SByteField = "spam"
with pytest.raises(TypeError):
ConversionTest().SByteField = None
with pytest.raises(OverflowError):
ConversionTest().SByteField = 128
with pytest.raises(OverflowError):
ConversionTest().SByteField = -129
with pytest.raises(OverflowError):
_ = System.SByte(128)
with pytest.raises(OverflowError):
_ = System.SByte(-129)
def test_int64_conversion():
"""Test int64 conversion."""
assert System.Int64.MaxValue == 9223372036854775807
assert System.Int64.MinValue == -9223372036854775808
ob = ConversionTest()
assert ob.Int64Field == 0
ob.Int64Field = 9223372036854775807
assert ob.Int64Field == 9223372036854775807
ob.Int64Field = -9223372036854775808
assert ob.Int64Field == -9223372036854775808
ob.Int64Field = System.Int64(9223372036854775807)
assert ob.Int64Field == 9223372036854775807
ob.Int64Field = System.Int64(-9223372036854775808)
assert ob.Int64Field == -9223372036854775808
with pytest.raises(TypeError):
ConversionTest().Int64Field = "spam"
with pytest.raises(TypeError):
ConversionTest().Int64Field = None
with pytest.raises(OverflowError):
ConversionTest().Int64Field = 9223372036854775808
with pytest.raises(OverflowError):
ConversionTest().Int64Field = -9223372036854775809
with pytest.raises(OverflowError):
_ = System.Int64(9223372036854775808)
with pytest.raises(OverflowError):
_ = System.Int64(-9223372036854775809)
def test_uint32_conversion():
"""Test uint32 conversion."""
assert System.UInt32.MaxValue == 4294967295
assert System.UInt32.MinValue == 0
ob = ConversionTest()
assert ob.UInt32Field == 0
ob.UInt32Field = 4294967295
assert ob.UInt32Field == 4294967295
ob.UInt32Field = -0
assert ob.UInt32Field == 0
ob.UInt32Field = System.UInt32(4294967295)
assert ob.UInt32Field == 4294967295
ob.UInt32Field = System.UInt32(0)
assert ob.UInt32Field == 0
with pytest.raises(TypeError):
ConversionTest().UInt32Field = "spam"
with pytest.raises(TypeError):
ConversionTest().UInt32Field = None
with pytest.raises(OverflowError):
ConversionTest().UInt32Field = 4294967296
with pytest.raises(OverflowError):
ConversionTest().UInt32Field = -1
with pytest.raises(OverflowError):
_ = System.UInt32(4294967296)
with pytest.raises(OverflowError):
_ = System.UInt32(-1)
def testNullConversion(self):
"""Test null conversion."""
object = ConversionTest()
object.StringField = None
self.failUnless(object.StringField == None)
object.ObjectField = None
self.failUnless(object.ObjectField == None)
object.SpamField = None
self.failUnless(object.SpamField == None)
# Primitive types and enums should not be set to null.
def test():
ConversionTest().Int32Field = None
self.failUnlessRaises(TypeError, test)
def test():
ConversionTest().EnumField = None
self.failUnlessRaises(TypeError, test)
