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