def test_long_log(self): """logon big ints should work""" self.assertEqual(round(math.log10(10**1000), 5), 1000.0) self.assertEqual(round(math.log(10**1000), 5), 2302.58509) self.assertEqual(round(math.log10(18446744073709551615), 5), 19.26592) self.assertEqual(round(math.log(18446744073709551615), 5), 44.36142) self.assertEqual(round(math.log10(18446744073709551616), 5), 19.26592) self.assertEqual(round(math.log(18446744073709551616), 5), 44.36142) self.assertEqual(round(math.log10(18446744073709551614), 5), 19.26592) self.assertEqual(round(math.log(18446744073709551614), 5), 44.36142) # log in a new base self.assertEqual(round(math.log(2**1000, 2), 5), 1000.0) self.assertRaises(ValueError, math.log, big(0)) self.assertRaises(ValueError, math.log, big(-1)) self.assertEqual(math.log(big(2), 1e666), 0.0) self.assertRaises(ValueError, math.log, big(2), -1e666) self.assertRaises(ZeroDivisionError, math.log, big(2), 1.0) #Make sure that an object is converted to float before being passed into log funcs class N(object): def __float__(self): return 10.0 def __int__(self): return 100 self.assertEqual(round(math.log10(N()), 5), 1.0) self.assertEqual(round(math.log(N()), 5), 2.30259)
def test_dword_conversions(self): import clr from System import Array, UInt32 from System.Numerics import BigInteger from IronPythonTest import System_Scripting_Math import Microsoft.Scripting.Utils.MathUtils clr.ImportExtensions(Microsoft.Scripting.Utils.MathUtils) def CheckDwordConversions(bigint, dwords): self.assertSequenceEqual(bigint.GetWords(), dwords) if bigint == BigInteger.Zero: self.assertEqual( System_Scripting_Math.CreateBigInteger( 0, Array[UInt32](dwords), ), bigint) else: self.assertEqual( System_Scripting_Math.CreateBigInteger( 1, Array[UInt32](dwords)), bigint) self.assertEqual( System_Scripting_Math.CreateBigInteger( -1, Array[UInt32](dwords)), BigInteger.Negate(bigint)) CheckDwordConversions(big(0), [0x00000000]) CheckDwordConversions(big(1), [0x00000001]) CheckDwordConversions(big(1 << 31), [0x80000000]) CheckDwordConversions(big(1 << 31) + 9, [0x80000009]) CheckDwordConversions(big(1 << 32), [0x00000000, 0x00000001])
def test_add_mul(self): self.assertRaises(TypeError, lambda: "a" + 3) self.assertRaises(TypeError, lambda: 3 + "a") self.assertRaises(TypeError, lambda: "a" * "3") self.assertRaises(OverflowError, lambda: "a" * (sys.maxsize + 1)) self.assertRaises(OverflowError, lambda: (sys.maxsize + 1) * "a") class myint(int): pass if is_cli: from System.IO import Path self.assertEqual("foo" + os.sep, "foo" + Path.DirectorySeparatorChar) self.assertEqual(os.sep + os.sep, Path.DirectorySeparatorChar + os.sep) # multiply self.assertEqual("aaaa", "a" * big(4)) self.assertEqual("aaaa", "a" * myint(4)) self.assertEqual("aaa", "a" * 3) self.assertEqual("a", "a" * True) self.assertEqual("", "a" * False) self.assertEqual("aaaa", big(4) * "a") self.assertEqual("aaaa", myint(4) * "a") self.assertEqual("aaa", 3 * "a") self.assertEqual("a", True * "a") self.assertEqual("", False * "a")
def test_getslice_missing_values(self): # missing values are different from passing None explicitly class myint(int): pass class foo: def __getitem__(self, index): return (index) def __len__(self): return 42 def validate_slice_result(result, value): self.assertEqual(result, value) self.assertEqual(result.__class__, slice) # only numeric types are passed to __getslice__ validate_slice_result(foo()[:], slice(None)) validate_slice_result(foo()[big(2):], slice(2, None)) validate_slice_result(foo()[2 << 64:], slice(36893488147419103232, None)) validate_slice_result(foo()[:big(2)], slice(2)) validate_slice_result(foo()[:2 << 64], slice(36893488147419103232)) validate_slice_result(foo()[big(2):big(3)], slice(2, 3)) validate_slice_result( foo()[2 << 64:3 << 64], slice(36893488147419103232, 55340232221128654848)) validate_slice_result(foo()[myint(2):], slice(2, None)) validate_slice_result(foo()[:myint(2)], slice(2)) validate_slice_result(foo()[myint(2):myint(3)], slice(2, 3)) validate_slice_result(foo()[True:], slice(True, None)) validate_slice_result(foo()[:True], slice(True)) validate_slice_result(foo()[False:True], slice(False, True)) def test_slice(foo): self.assertEqual(foo()[None:], slice(None, None)) self.assertEqual(foo()[:None], slice(None, None)) self.assertEqual(foo()[None:None], slice(None, None)) self.assertEqual(foo()['abc':], slice('abc', None)) self.assertEqual(foo()[:'abc'], slice(None, 'abc')) self.assertEqual(foo()['abc':'def'], slice('abc', 'def')) self.assertEqual(foo()[2.0:], slice(2.0, None)) self.assertEqual(foo()[:2.0], slice(None, 2.0)) self.assertEqual(foo()[2.0:3.0], slice(2.0, 3.0)) self.assertEqual(foo()[1j:], slice(1j, None)) self.assertEqual(foo()[:1j], slice(None, 1j)) self.assertEqual(foo()[2j:3j], slice(2j, 3j)) test_slice(foo) class foo: def __getitem__(self, index): return (index) def __len__(self): return 42 self.assertEqual(foo()[:], slice(None)) test_slice(foo)
def test_hex_conversions(self): # Test hex conversions. CPython 2.5 uses capital L, lowercase letters a...f) s = hex(big(27)) # 0x1b self.assertTrue(s == "0x1b", "27: Expect lowercase digits. Received: %s." % (s)) s = hex(-big(27)) self.assertTrue(s == "-0x1b", "-27: Expect lowercase digits. Received: %s." % (s))
def test_functionality(self): objects = [ None, True, False, '', 'a', 'abc', -3, 0, 10, 254, -255, 256, 257, 65534, 65535, -65536, 3.1415926, big(0), -1234567890123456789, 2**33, [], [[]], [[], []], ['abc'], [1, 2], tuple(), (), ( (), (), ), (1, ), (1, 2, 3), {}, { 'abc': {} }, { 1: 2 }, { 1: 2, 4: '4', 5: None }, 0 + 1j, 2 - 3.23j, set(), set(['abc', -5]), set([1, (2.1, big(3)), frozenset([5]), 'x']), frozenset(), frozenset(['abc', -5]), frozenset([1, (2.1, big(3)), frozenset([5]), 'x']) ] if is_cli: import System objects.extend([ System.Single.Parse('-2345678'), System.Int64.Parse('2345678'), ]) # dumps / loads for x in objects: s = marshal.dumps(x) x2 = marshal.loads(s) self.assertEqual(x, x2) # on 64-bit the order in set/frozenset isn't the same after dumps/loads if (is_64 or is_osx) and isinstance(x, (set, frozenset)): continue s2 = marshal.dumps(x2) self.assertEqual(s, s2) # dump / load for x in objects: with open(self.tfn, 'wb') as f: marshal.dump(x, f) with open(self.tfn, 'rb') as f: x2 = marshal.load(f) self.assertEqual(x, x2)
def test_conversions(self): success = False try: nstr("Hi") except NameError: success = True self.assertEqual(success, True) success = False try: zip2([1, 2, 3], [4, 5, 6]) except NameError: success = True self.assertEqual(success, True) self.assertEqual(bytes(), b"") self.assertEqual(str(), u"") self.assertEqual(oct(big(0)), "0o0") self.assertEqual(hex(12297829382473034410), "0xaaaaaaaaaaaaaaaa") #10581 self.assertEqual(hex(-big(1)), "-0x1") self.assertEqual(int("-01"), -1) self.assertEqual(int(" 1 "), 1) with self.assertRaises(ValueError): int('09', 8) int_types = [int] if is_cli: from iptest import clr_int_types int_types.extend(clr_int_types) for f in int_types: self.assertRaises(ValueError, f, ' - 1 ') self.assertRaises(ValueError, f, 'p') self.assertRaises(ValueError, f, 't') self.assertRaises(ValueError, f, 'a') self.assertRaises(ValueError, f, '3.2') self.assertRaises(ValueError, f, '0x0R') self.assertRaises(ValueError, f, '0A') self.assertRaises(ValueError, f, '0x0G') self.assertRaises(ValueError, f, '1l') self.assertRaises(ValueError, f, '1L') self.assertEqual( int(1e100), 10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104 ) self.assertEqual( int(-1e100), -10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104 ) self.assertEqual(pow(2, 3), 8)
def test_more_complex(self): self.assertEqual((12 + 3j) / big(3), (4 + 1j)) self.assertEqual(3j - big(5), -5 + 3j) if is_cli: self.assertEqual(3j - Int64(), 3j) self.assertRaises(TypeError, (lambda: 3j - [])) if is_cli: self.assertEqual(pow(5j, Int64()), (1 + 0j)) self.assertEqual(pow(5j, big(0)), (1 + 0j)) self.assertRaises(TypeError, (lambda: pow(5j, []))) if is_cli: self.assertEqual(5j * Int64(), 0) self.assertEqual(5j * big(3), 15j) self.assertRaises(TypeError, (lambda: (5j * [])))
def test_cp9350(self): for i in [1, big(1)]: a = array.array('B', [0]) * i self.assertEqual(a, array.array('B', [0])) for i in [2, big(2)]: a = array.array('B', [0]) * i self.assertEqual(a, array.array('B', [0, 0])) for i in [2**8, big(2**8)]: a = array.array('B', [1]) * i self.assertEqual(a, array.array('B', [1] * 2**8))
def test_negated_comparisons(self): self.assertTrue(not (20 == False)) self.assertTrue(not (20 == None)) self.assertTrue(not (False == 20)) self.assertTrue(not (None == 20)) self.assertTrue(not (20 == 'a')) self.assertTrue(not ('a' == 20)) self.assertTrue(not (2.5 == None)) self.assertTrue(not (20 == (2, 3))) self.assertEqual(big(1234793454934), 1234793454934) self.assertEqual(4**-2, 0.0625) self.assertEqual(big(4)**-2, 0.0625)
def test_edge_cases(self): # these are dependant on sys.hash_info.modulo = 2147483647 self.assertEqual(hash(2147483647), 0) # int.MaxValue self.assertEqual(hash(-2147483648), -2) # int.MinValue self.assertEqual(hash(-2147483647), 0) # int.MinValue+1 self.assertEqual(hash(big(2147483647)), 0) # int.MaxValue self.assertEqual(hash(big(-2147483648)), -2) # int.MinValue self.assertEqual(hash(big(-2147483647)), 0) # int.MinValue+1 self.assertEqual(hash(9223372036854775807), 1) # long.MaxValue self.assertEqual(hash(-9223372036854775808), -2) # long.MinValue self.assertEqual(hash(-9223372036854775807), -2) # long.MinValue+1 # this checks that we handle the case where the hash results in -1 self.assertEqual(hash(complex(-1000004, 1)), -2) # sys.hash_info.imag-1 + 1j
def test_trunc(self): import sys, math test_values = [ -1, 0, 1, big(-1), big(0), big(1), -1.0, 0.0, 1.0, sys.maxsize + 0.5, -sys.maxsize - 0.5, 9876543210, -9876543210, -1e100, 1e100 ] for value in test_values: self.assertEqual(int(value), math.trunc(value)) self.assertTrue(isinstance(math.trunc(value), int))
def test_extensible_math(self): operators = [ '__add__', '__sub__', '__pow__', '__mul__', '__div__', '__floordiv__', '__truediv__', '__mod__' ] opSymbol = ['+', '-', '**', '*', '/', '//', '/', '%'] types = [] for baseType in [(int, (100, 2)), (int, (big(100), big(2))), (float, (100.0, 2.0))]: # (complex, (100+0j, 2+0j)) - cpython doesn't call reverse ops for complex ? class prototype(baseType[0]): for op in operators: exec('''def %s(self, other): global opCalled opCalled.append('%s') return super(self.__class__, self).%s(other) def %s(self, other): global opCalled opCalled.append('%s') return super(self.__class__, self).%s(other)''' % (op, op, op, op[:2] + 'r' + op[2:], op[:2] + 'r' + op[2:], op[:2] + 'r' + op[2:])) types.append((prototype, baseType[1])) global opCalled opCalled = [] for op in opSymbol: for typeInfo in types: ex = typeInfo[0](typeInfo[1][0]) ey = typeInfo[0](typeInfo[1][1]) nx = typeInfo[0].__bases__[0](typeInfo[1][0]) ny = typeInfo[0].__bases__[0](typeInfo[1][1]) #print 'nx %s ey' % op, type(nx), type(ey) res1 = eval('nx %s ey' % op) res2 = eval('nx %s ny' % op) self.assertEqual(res1, res2) self.assertEqual(len(opCalled), 1) opCalled = [] #print 'ex %s ny' % op, type(ex), type(ny) res1 = eval('ex %s ny' % op) res2 = eval('nx %s ny' % op) self.assertEqual(res1, res2) self.assertEqual(len(opCalled), 1) opCalled = []
def test_complex(self): from System.Numerics import Complex self.assertEqual( Complex.Add(Complex(big(9999), -1234), Complex.Conjugate(Complex(9999, -1234))), Complex.Multiply.Overloads[complex, complex](big(9999), 2)) self.assertEqual( Complex.Add(Complex(99999.99e-200, 12345.88e+100), Complex.Negate(Complex(99999.99e-200, 12345.88e+100))), Complex.Subtract(Complex(99999.99e-200, 12345.88e+100), Complex(99999.99e-200, 12345.88e+100))) self.assertEqual(Complex.Divide(4 + 2j, 2), (2 + 1j)) self.assertTrue( not hasattr(Complex, "Mod") ) #IP 1.x had limited support for modulo which has been removed
def test_maxlen_type(self): self.assertEqual(deque([], 42).maxlen, 42) self.assertEqual(deque([], big(42)).maxlen, 42) self.assertEqual(deque([], myint(42)).maxlen, 42) self.assertRaisesMessage(TypeError, "an integer is required", deque, [], 1.2) self.assertRaisesMessage(TypeError, "an integer is required", deque, [], myfloat(1)) self.assertRaisesMessage(TypeError, "an integer is required", deque, [], mycomplex(1)) self.assertRaisesMessage(TypeError, "an integer is required", deque, [], "1") class int_with_int(int): def __int__(self): return 42 self.assertEqual(deque([], int_with_int(24)).maxlen, 24) class int_with_index(int): def __index__(self): return 42 self.assertEqual(deque([], int_with_index(24)).maxlen, 24) class object_with_int: def __int__(self): return 42 self.assertRaisesMessage(TypeError, "an integer is required", deque, [], object_with_int()) class object_with_index: def __index__(self): return 42 self.assertRaisesMessage(TypeError, "an integer is required", deque, [], object_with_index())
def get_values(values, itypes, ftypes): """ This will return structure of values converted to variety of types as a list of tuples: [ ... ( python_value, [ all_values ] ), ... ] all_values: Byte, UInt16, UInt32, UInt64, SByte, Int16, Int32, Int64, BigInteger, myint, Single, Double, myfloat, Complex, mycomplex """ all = [] for v in values: sv = str(v) py = int(v) clr = get_clr_values(sv, itypes) clr.append(py) clr.append(big(py)) clr.append(myint(py)) all.append((py, clr)) py = float(v) clr = get_clr_values(sv, ftypes) clr.append(myfloat(py)) all.append((py, clr)) for imag in [0j, 1j, -1j]: py = complex(v + imag) all.append((py, [py, mycomplex(py)])) all.append((True, [True])) all.append((False, [False])) return all
def test_neg_clrtype_returns_nonsense_values(self): ''' The __clrtype__ implementation returns invalid values. ''' global called import System for x, expected_msg in [ [[], "expected Type, got list"], [(None, ), "expected Type, got tuple"], [True, "expected Type, got bool"], [False, "expected Type, got bool"], [3.14, "expected Type, got float"], ["a string", "expected Type, got str"], [System.UInt16(32), "expected Type, got UInt16"], [0, "expected Type, got int"], [big(1), "expected Type, got int"], ]: called = False class MyType(type): def __clrtype__(self): global called called = True return x try: class X(object, metaclass=MyType): pass Fail( "Arbitrary return values of __clrtype__ should not be allowed: " + str(x)) except TypeError as e: self.assertEqual(str(e), expected_msg) finally: self.assertEqual(called, True) #http://ironpython.codeplex.com/WorkItem/View.aspx?WorkItemId=23244 called = False class MyType(type): def __clrtype__(self): global called called = True return None try: class X(object, metaclass=MyType): pass Fail("Arbitrary return values of __clrtype__ are not allowed: ", +str(x)) except ValueError as e: self.assertEqual(str(e), "__clrtype__ must return a type, not None") finally: self.assertEqual(called, True)
def test_neg_type___clrtype__(self): ''' Tests out negative type.__clrtype__ cases. ''' import System #Number of params self.assertRaisesMessage( TypeError, "__clrtype__() takes exactly 1 argument (0 given)", type.__clrtype__) self.assertRaisesMessage( TypeError, "__clrtype__() takes exactly 1 argument (2 given)", type.__clrtype__, None, None) self.assertRaisesMessage( TypeError, "__clrtype__() takes exactly 1 argument (3 given)", type.__clrtype__, None, None, None) #Wrong param type self.assertRaisesPartialMessage(TypeError, ", got NoneType", type.__clrtype__, None) self.assertRaisesPartialMessage(TypeError, ", got float", type.__clrtype__, 3.14) for x in [ None, [], (None, ), Exception("message"), 3.14, big(3), 0, 5j, "string", u"string", True, System, _os, os, lambda: 3.14 ]: self.assertRaises(TypeError, type.__clrtype__, x) #Shouldn't be able to set __clrtype__ to something else self.assertRaisesMessage( AttributeError, "attribute '__clrtype__' of 'type' object is read-only", setattr, type, "__clrtype__", None)
def test_subclass_ctor(self): # verify all of the ctors work for various types... class myunicode(str): pass class myunicode2(str): def __init__(self, *args): pass class myfloat(float): pass class mycomplex(complex): pass class myint(int): pass for x in [ 1, 1.0, big(1), 1j, myfloat(1.0), mycomplex(1), myint(1), True, False, None, object(), "", u"" ]: self.assertEqual(myunicode(x), str(x)) self.assertEqual(myunicode2(x), str(x)) self.assertEqual(myunicode(b'foo', 'ascii'), str(b'foo', 'ascii')) self.assertEqual(myunicode2(b'foo', 'ascii'), str(b'foo', 'ascii'))
def test_bitfield_long(self): """Tests for bitfields of type c_long""" class Test(Structure): _fields_ = [("x", c_long, 16), ("y", c_long, 16), ("z", c_long, 32)] class myindex: def __init__(self, value): self.value = value def __index__(self): return self.value self.assertEqual(Test(0x1234).x, 0x1234) self.assertEqual(Test(big(0x1234)).x, 0x1234) self.assertEqual(Test(myint(0x1234)).x, 0x1234) self.assertEqual(Test(True).x, 1) if is_cli or sys.version_info >= (3, 8): self.assertEqual(Test(myindex(0x1234)).x, 0x1234) if is_cli or sys.version_info >= (3, 10): msg = "'float' object cannot be interpreted as an integer" else: msg = "int expected instead of float" self.assertRaisesMessage(TypeError, msg, Test, 2.3) with self.assertRaisesMessage(ValueError, "number of bits invalid for bit field"): class Test(Structure): _fields_ = [("x", c_int, 0)] self.assertEqual(repr(Test.x), "<Field type=c_long, ofs=0:0, bits=16>") self.assertEqual(repr(Test.y), "<Field type=c_long, ofs=0:16, bits=16>") self.assertEqual(repr(Test.z), "<Field type=c_long, ofs=4:0, bits=32>") self.assertEqual((Test.x.offset, Test.x.size), (0, (16 << 16) + 0)) self.assertEqual((Test.y.offset, Test.y.size), (0, (16 << 16) + 16)) self.assertEqual((Test.z.offset, Test.z.size), (4, (32 << 16) + 0))
def test_pep19546(self): ''' Just a small sanity test. CPython's test_int.py covers this PEP quite well. ''' #Octal self.assertEqual(0O21, 17) self.assertEqual(0O21, 0o21) self.assertEqual(0o0, 0) self.assertEqual(-0o1, -1) self.assertEqual(0o17777777776, 2147483646) self.assertEqual(0o17777777777, 2147483647) self.assertEqual(0o20000000000, 2147483648) self.assertEqual(-0o17777777777, -2147483647) self.assertEqual(-0o20000000000, -2147483648) self.assertEqual(-0o20000000001, -2147483649) #Binary self.assertEqual(0B11, 3) self.assertEqual(0B11, 0b11) self.assertEqual(0b0, 0) self.assertEqual(-0b1, -1) self.assertEqual(0b1111111111111111111111111111110, 2147483646) self.assertEqual(0b1111111111111111111111111111111, 2147483647) self.assertEqual(0b10000000000000000000000000000000, 2147483648) self.assertEqual(-0b1111111111111111111111111111111, -2147483647) self.assertEqual(-0b10000000000000000000000000000000, -2147483648) self.assertEqual(-0b10000000000000000000000000000001, -2147483649) #bin and oct test_cases = [ (0B11, "0b11", "0o3"), (2147483648, "0b10000000000000000000000000000000", "0o20000000000"), (big(-2147483649), "-0b10000000000000000000000000000001", "-0o20000000001"), (big(-1), "-0b1", "-0o1"), (-0b10000000000000000000000000000000, "-0b10000000000000000000000000000000", "-0o20000000000"), (-0o17777777777, "-0b1111111111111111111111111111111", "-0o17777777777"), (0o17777777777, "0b1111111111111111111111111111111", "0o17777777777"), ] for val, bin_exp, oct_exp in test_cases: self.assertEqual(bin(val), bin_exp) self.assertEqual(oct(val), oct_exp)
def test_misc(self): from System import ArgumentException, ArgumentNullException from System.Numerics import BigInteger from IronPythonTest import System_Scripting_Math self.assertRaises(ArgumentException, System_Scripting_Math.CreateBigInteger, 0, (1, 2, 3)) self.assertRaises(ArgumentNullException, System_Scripting_Math.CreateBigInteger, 0, None) self.assertEqual(big(1).CompareTo(None), 1) self.assertEqual(big(1).CompareTo(True), 0) if is_netcoreapp: import clr clr.AddReference("System.Net.Sockets") from System.Net.Sockets import IOControlCode self.assertEqual(int(IOControlCode.TranslateHandle), 0xc800000D)
def test_abs(self): self.assertRaises(TypeError, abs, None) #long integer passed to abs self.assertEqual(big(22), abs(big(22))) self.assertEqual(big(22), abs(-big(22))) #bool passed to abs self.assertEqual(1, abs(True)) self.assertEqual(0, abs(False)) #__abs__ defined on user type class myclass: def __abs__(self): return "myabs" c = myclass() self.assertEqual("myabs", abs(c))
def test_to_type_conversions(self): from System import Decimal, Double, Single from System import Int64, UInt64, Int32, UInt32, Int16, UInt16, Byte, SByte from System import Boolean, Char, DateTime, Object, Enum, DateTimeKind val = 1 for i in [big(val), Int32(val)]: self.assertEqual(i.ToDecimal(self.p), val) self.assertIsInstance(i.ToDecimal(self.p), Decimal) self.assertEqual(i.ToDouble(self.p), val) self.assertIsInstance(i.ToDouble(self.p), Double) self.assertEqual(i.ToSingle(self.p), val) self.assertIsInstance(i.ToSingle(self.p), Single) self.assertEqual(i.ToInt64(self.p), val) self.assertIsInstance(i.ToInt64(self.p), Int64) self.assertEqual(i.ToUInt64(self.p), val) self.assertIsInstance(i.ToUInt64(self.p), UInt64) self.assertEqual(i.ToInt32(self.p), val) self.assertIsInstance(i.ToInt32(self.p), Int32) self.assertEqual(i.ToUInt32(self.p), val) self.assertIsInstance(i.ToUInt32(self.p), UInt32) self.assertEqual(i.ToInt16(self.p), val) self.assertIsInstance(i.ToInt16(self.p), Int16) self.assertEqual(i.ToUInt16(self.p), val) self.assertIsInstance(i.ToUInt16(self.p), UInt16) self.assertEqual(i.ToByte(self.p), val) self.assertIsInstance(i.ToByte(self.p), Byte) self.assertEqual(i.ToSByte(self.p), val) self.assertIsInstance(i.ToSByte(self.p), SByte) self.assertEqual(i.ToBoolean(self.p), val) self.assertIsInstance(i.ToBoolean(self.p), Boolean) self.assertEqual(i.ToChar(self.p), Char(val)) self.assertEqual(i.ToString(self.p), str(val)) self.assertRaisesRegex(TypeError, r"Invalid cast from '\w+' to 'DateTime'", i.ToDateTime, self.p) for t in [ Decimal, Double, Single, Int64, UInt64, Int32, UInt32, Int16, UInt16, Byte, SByte, Boolean, Char, str ]: self.assertEqual(i.ToType(t, self.p), t(i)) self.assertEqual(i.ToType(Object, self.p), i) self.assertIsInstance(i.ToType(Object, self.p), Object) self.assertRaisesRegex(TypeError, r"Invalid cast from '\w+' to 'DateTime'", i.ToType, DateTime, self.p) self.assertRaisesRegex( TypeError, r"Invalid cast from '[\w.]+' to 'System.DateTimeKind'\.", i.ToType, DateTimeKind, self.p) if not is_mono: self.assertRaisesRegex( TypeError, r"Unable to cast object of type '[\w.]+' to type 'System.Enum'\.", i.ToType, Enum, self.p)
def test_zero_division(self): self.assertRaises(ZeroDivisionError, (lambda: (0**-1))) self.assertRaises(ZeroDivisionError, (lambda: (0.0**-1))) self.assertRaises(ZeroDivisionError, (lambda: (0**-1.0))) self.assertRaises(ZeroDivisionError, (lambda: (0.0**-1.0))) self.assertRaises(ZeroDivisionError, (lambda: (False**-1))) self.assertRaises(ZeroDivisionError, (lambda: (big(0)**-(2**65)))) self.assertRaises(ZeroDivisionError, (lambda: (0j**-1))) self.assertRaises(ZeroDivisionError, (lambda: (0j**1j)))
def test__bool__(self): class ClassWithBool: def __init__(self, val): self.val = val def __bool__(self): return self.val class ClassWithLen: def __init__(self, val): self.val = val def __len__(self): return self.val class MyIndex: def __init__(self, val): self.val = val def __index__(self): return self.val bool_cases = [ (True, True), (False, False), (0.0, TypeError), (-1, TypeError), (1 << 64, TypeError), (MyIndex(0), TypeError), ] len_cases = [ (1, True), (0, False), (0.0, TypeError), (-1, ValueError), (1 << 64, OverflowError), ] cases = [] cases += [(ClassWithBool(x), y) for x, y in bool_cases] cases += [(ClassWithLen(x), y) for x, y in len_cases] cases += [(ClassWithLen(big(x)), y) for x, y in len_cases if isinstance(x, int)] cases += [(ClassWithLen(myint(x)), y) for x, y in len_cases if isinstance(x, int)] cases += [(ClassWithLen(MyIndex(x)), y) for x, y in len_cases] for val, res in cases: if type(res) == type: with self.assertRaises(res): bool(val) with self.assertRaises(res): not val else: self.assertEqual(bool(val), res) self.assertEqual(not val, not res)
def test_complex(self): # Complex tests self.assertTrue((2 + 4j) / (1 + 1j) == (3 + 1j)) self.assertTrue((2 + 10j) / 4.0 == (0.5 + 2.5j)) self.assertEqual(1j**2, (-1.0 + 0j)) self.assertEqual(pow(1j, 2), (-1.0 + 0j)) self.assertEqual(1 + 0j, 1) self.assertEqual(1 + 0j, 1.0) self.assertEqual(1 + 0j, big(1)) self.assertEqual((1 + 1j) / big(1), (1 + 1j)) self.assertEqual((1j) + big(1), (1 + 1j)) self.assertEqual(0j**0, 1) self.assertEqual(0j**0j, 1) self.assertEqual(pow(0j, 0), 1) self.assertEqual(pow(0j, 0j), 1) if is_cli: self.assertEqual((1j) + Int64(), 1j) self.assertRaises(TypeError, (lambda: (1 + 1j) + [])) self.assertRaises(TypeError, lambda: type(2j).__dict__['real'].__set__, 2j, 0)
def test_log(self): import math zeros = [-1, -1.0, big(-1), 0, 0.0, big(0)] nonzeros = [2, 2.0, big(2)] ones = [1, 1.0, big(1)] self.assertEqual(type(zeros[0]), type(zeros[2])) for z0 in zeros: self.assertRaises(ValueError, math.log, z0) self.assertRaises(ValueError, math.log10, z0) for z in zeros: self.assertRaises(ValueError, math.log, z0, z) for n in nonzeros + ones: self.assertRaises(ValueError, math.log, z0, n) self.assertRaises(ValueError, math.log, n, z0) for one in ones: for n in nonzeros: self.assertRaises(ZeroDivisionError, math.log, n, one)
def test_string_mult(self): """string multiplication""" class foo(int): pass fooInst = foo(3) self.assertEqual('aaa', 'a' * 3) self.assertEqual('aaa', 'a' * big(3)) self.assertEqual('aaa', 'a' * fooInst) self.assertEqual('', 'a' * False) self.assertEqual('a', 'a' * True)
def test_type_name(self): import System i = 1 j = big(1) self.assertEqual(int.__name__, "int") self.assertEqual(System.Numerics.BigInteger.__name__, "int") self.assertEqual(System.Int32.__name__, "Int32") self.assertEqual(System.Int64.__name__, "Int64") self.assertEqual(i.__class__.__name__, "int") self.assertEqual(j.__class__.__name__, "int")