def test_big_2():
for (a, m, t,x) in [
(31, "ToInt32",Int32,2),
(32, "ToUInt32",UInt32,0),
(63, "ToInt64",Int64,2),
(64, "ToUInt64",UInt64,0)
]:
b = BigInteger(-x ** a )
left = getattr(b, m)()
right = t.MinValue
AreEqual(left, right)
b = BigInteger(2 ** a -1)
left = getattr(b, m)()
right = t.MaxValue
AreEqual(left, right)
b = BigInteger(0L)
left = getattr(b, m)()
right = t.MaxValue - t.MaxValue
AreEqual(left, right)
AssertError(OverflowError,getattr(BigInteger(2 ** a ), m))
AssertError(OverflowError,getattr(BigInteger(-1 - x ** a ), m))
def test_big_1(self):
from System import SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64
from System.Numerics import BigInteger
for (a, m, t, x) in [(7, "ToSByte", SByte, 2), (8, "ToByte", Byte, 0),
(15, "ToInt16", Int16, 2),
(16, "ToUInt16", UInt16, 0),
(31, "ToInt32", Int32, 2),
(32, "ToUInt32", UInt32, 0),
(63, "ToInt64", Int64, 2),
(64, "ToUInt64", UInt64, 0)]:
b = BigInteger(-x**a)
left = getattr(b, m)(self.p)
right = t.MinValue
self.assertEqual(left, right)
b = BigInteger(2**a - 1)
left = getattr(b, m)(self.p)
right = t.MaxValue
self.assertEqual(left, right)
b = BigInteger(0L)
left = getattr(b, m)(self.p)
right = t.MaxValue - t.MaxValue
self.assertEqual(left, 0)
self.assertRaises(OverflowError, getattr(BigInteger(2**a), m),
self.p)
self.assertRaises(OverflowError, getattr(BigInteger(-1 - x**a), m),
self.p)
def test_big_1():
for (a, m, t,x) in [
(7, "ToSByte", SByte,2),
(8, "ToByte", Byte, 0),
(15, "ToInt16", Int16,2),
(16, "ToUInt16", UInt16,0),
(31, "ToInt32", Int32,2),
(32, "ToUInt32", UInt32,0),
(63, "ToInt64", Int64,2),
(64, "ToUInt64", UInt64,0)
]:
b = BigInteger(-x ** a )
left = getattr(b, m)(p)
right = t.MinValue
AreEqual(left, right)
b = BigInteger(2 ** a -1)
left = getattr(b, m)(p)
right = t.MaxValue
AreEqual(left, right)
b = BigInteger(0L)
left = getattr(b, m)(p)
right = t.MaxValue - t.MaxValue
AreEqual(left, 0)
AssertError(OverflowError,getattr(BigInteger(2 ** a ), m),p)
AssertError(OverflowError,getattr(BigInteger(-1 - x ** a ), m),p)
def test_big_2(self):
from System import Int32, UInt32, Int64, UInt64
from System.Numerics import BigInteger
for (a, m, t, x) in [(31, "ToInt32", Int32, 2),
(32, "ToUInt32", UInt32, 0),
(63, "ToInt64", Int64, 2),
(64, "ToUInt64", UInt64, 0)]:
b = BigInteger(-x**a)
left = getattr(b, m)()
right = t.MinValue
self.assertEqual(left, right)
b = BigInteger(2**a - 1)
left = getattr(b, m)()
right = t.MaxValue
self.assertEqual(left, right)
b = BigInteger(0L)
left = getattr(b, m)()
right = t.MaxValue - t.MaxValue
self.assertEqual(left, right)
self.assertRaises(OverflowError, getattr(BigInteger(2**a), m))
self.assertRaises(OverflowError, getattr(BigInteger(-1 - x**a), m))
def test_dword_conversions():
def CheckDwordConversions(bigint, dwords):
SequencesAreEqual(bigint.GetWords(), dwords)
if bigint == BigInteger.Zero:
AreEqual(
IronPythonTest.System_Scripting_Math.CreateBigInteger(
0,
Array[UInt32](dwords),),
bigint)
else:
AreEqual(
IronPythonTest.System_Scripting_Math.CreateBigInteger(
1,
Array[UInt32](dwords)),
bigint)
AreEqual(
IronPythonTest.System_Scripting_Math.CreateBigInteger(
-1,
Array[UInt32](dwords)),
BigInteger.Negate(bigint))
CheckDwordConversions(BigInteger(0), [0x00000000])
CheckDwordConversions(BigInteger(1), [0x00000001])
CheckDwordConversions(BigInteger((1<<31)), [0x80000000])
CheckDwordConversions(BigInteger(((1<<31) + 9)), [0x80000009])
CheckDwordConversions(BigInteger((1<<32)), [0x00000000, 0x00000001])
def test_dword_conversions(self):
from System import Array, UInt32
from System.Numerics import BigInteger
from IronPythonTest import System_Scripting_Math
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(BigInteger(0), [0x00000000])
CheckDwordConversions(BigInteger(1), [0x00000001])
CheckDwordConversions(BigInteger((1 << 31)), [0x80000000])
CheckDwordConversions(BigInteger(((1 << 31) + 9)), [0x80000009])
CheckDwordConversions(BigInteger((1 << 32)), [0x00000000, 0x00000001])
def test_rightshiftby32_negative_bug(self):
# test workaround for https://github.com/dotnet/runtime/issues/43396
from System.Numerics import BigInteger
self.assertEqual(
BigInteger.Parse("-18446744073709543424") >> 32, -4294967296)
self.assertEqual(
BigInteger.Parse("-79228162514264337593543917568") >> 32,
-18446744073709551616)
def test_misc():
AssertError(ArgumentException, IronPythonTest.System_Scripting_Math.CreateBigInteger, 0, (1, 2, 3))
AssertError(ArgumentNullException, IronPythonTest.System_Scripting_Math.CreateBigInteger, 0, None)
AreEqual(BigInteger(1).CompareTo(None), 1)
if is_net40:
AreEqual(BigInteger(1).CompareTo(True), 0)
else:
AssertError(ArgumentException, BigInteger(1).CompareTo, True)
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(BigInteger(1).CompareTo(None), 1)
self.assertEqual(BigInteger(1).CompareTo(True), 0)
def test_misc():
AssertError(ArgumentException, IronPythonTest.System_Scripting_Math.CreateBigInteger, 0, (1, 2, 3))
AssertError(ArgumentNullException, IronPythonTest.System_Scripting_Math.CreateBigInteger, 0, None)
if not is_netstandard: # TODO: figure out why this doesn't work
AreEqual(BigInteger(1).CompareTo(None), 1)
if is_net40:
AreEqual(BigInteger(1).CompareTo(True), 0)
else:
AssertError(ArgumentException, BigInteger(1).CompareTo, True)
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)
if not is_netstandard: # TODO: figure out why this doesn't work
self.assertEqual(BigInteger(1).CompareTo(None), 1)
self.assertEqual(BigInteger(1).CompareTo(True), 0)
def test_complex(self):
from System.Numerics import BigInteger, Complex
self.assertEqual(
Complex.Add(Complex(BigInteger(9999), -1234),
Complex.Conjugate(Complex(9999, -1234))),
Complex.Multiply(BigInteger(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_complex():
AreEqual(
Complex.Add(
Complex(BigInteger(9999), -1234),
Complex.Conjugate(Complex(9999, -1234)) ),
Complex.Multiply(BigInteger(9999), 2) )
AreEqual(
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) ))
AreEqual(
Complex.Divide(4+2j,2),
(2 + 1j) )
Assert(not hasattr(Complex, "Mod")) #IP 1.x had limited support for modulo which has been removed
def CheckDwordConversions(bigint, dwords):
SequencesAreEqual(bigint.GetWords(), dwords)
if bigint == BigInteger.Zero:
AreEqual(
IronPythonTest.System_Scripting_Math.CreateBigInteger(
0,
Array[UInt32](dwords),
), bigint)
else:
AreEqual(
IronPythonTest.System_Scripting_Math.CreateBigInteger(
1, Array[UInt32](dwords)), bigint)
AreEqual(
IronPythonTest.System_Scripting_Math.CreateBigInteger(
-1, Array[UInt32](dwords)), BigInteger.Negate(bigint))
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))
def test_bool_misc():
if is_net40:
def is_zero(bigint):
return bigint.IsZero
else:
def is_zero(bigint):
return bigint.IsZero()
AreEqual(BigInteger(-1234).Sign, -1)
AreEqual(is_zero(BigInteger(-1234)), False)
AreEqual(BigInteger(-1234).IsNegative(), True)
AreEqual(BigInteger(-1234).IsPositive(), False)
AreEqual(BigInteger(0).Sign, 0)
AreEqual(is_zero(BigInteger(0)), True)
AreEqual(BigInteger(0).IsNegative(), False)
AreEqual(BigInteger(0).IsPositive(), False)
AreEqual(BigInteger(1234).Sign, 1)
AreEqual(is_zero(BigInteger(1234)), False)
AreEqual(BigInteger(1234).IsNegative(), False)
AreEqual(BigInteger(1234).IsPositive(), True)
def CheckByteConversions(bigint, bytes):
self.assertSequenceEqual(bigint.ToByteArray(), bytes)
self.assertEqual(BigInteger.Create(Array[Byte](bytes)), bigint)
def test_byte_conversions(self):
from System import Array, Byte
from System.Numerics import BigInteger
def CheckByteConversions(bigint, bytes):
self.assertSequenceEqual(bigint.ToByteArray(), bytes)
self.assertEqual(BigInteger.Create(Array[Byte](bytes)), bigint)
CheckByteConversions(BigInteger(0x00), [0x00])
CheckByteConversions(BigInteger(-0x01), [0xff])
CheckByteConversions(BigInteger(-0x81), [0x7f, 0xff])
CheckByteConversions(BigInteger(-0x100), [0x00, 0xff])
CheckByteConversions(BigInteger(-0x1000), [0x00, 0xf0])
CheckByteConversions(BigInteger(-0x10000), [0x00, 0x00, 0xff])
CheckByteConversions(BigInteger(-0x100000), [0x00, 0x00, 0xf0])
CheckByteConversions(BigInteger(-0x10000000), [0x00, 0x00, 0x00, 0xf0])
CheckByteConversions(BigInteger(-0x100000000),
[0x00, 0x00, 0x00, 0x00, 0xff])
CheckByteConversions(BigInteger(0x7f), [0x7f])
CheckByteConversions(BigInteger(0xff), [0xff, 0x00])
CheckByteConversions(BigInteger(0x0201), [0x01, 0x02])
CheckByteConversions(BigInteger(0xf2f1), [0xf1, 0xf2, 0x00])
CheckByteConversions(BigInteger(0x03020100), [0x00, 0x01, 0x02, 0x03])
CheckByteConversions(BigInteger(0x0403020100),
[0x00, 0x01, 0x02, 0x03, 0x04])
CheckByteConversions(BigInteger(0x0706050403020100),
[0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07])
CheckByteConversions(
BigInteger(0x080706050403020100),
[0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])
def test_bool_misc(self):
from System.Numerics import BigInteger
def is_zero(bigint):
return bigint.IsZero
self.assertEqual(BigInteger(-1234).Sign, -1)
self.assertEqual(is_zero(BigInteger(-1234)), False)
self.assertEqual(BigInteger(-1234).IsNegative(), True)
self.assertEqual(BigInteger(-1234).IsPositive(), False)
self.assertEqual(BigInteger(0).Sign, 0)
self.assertEqual(is_zero(BigInteger(0)), True)
self.assertEqual(BigInteger(0).IsNegative(), False)
self.assertEqual(BigInteger(0).IsPositive(), False)
self.assertEqual(BigInteger(1234).Sign, 1)
self.assertEqual(is_zero(BigInteger(1234)), False)
self.assertEqual(BigInteger(1234).IsNegative(), False)
self.assertEqual(BigInteger(1234).IsPositive(), True)
def test_bigint():
AreEqual(
BigInteger.Add(
1L, 99999999999999999999999999999999999999999999999999999999999L),
BigInteger.Subtract(
100000000000000000000000000000000000000000000000000000000001L, 1L))
AreEqual(BigInteger.Multiply(400L, 500L), BigInteger.Divide(1000000L, 5L))
AreEqual(BigInteger.Multiply(400L, 8L), BigInteger.LeftShift(400L, 3L))
AreEqual(BigInteger.Divide(400L, 8L), BigInteger.RightShift(400L, 3L))
AreEqual(BigInteger.RightShift(BigInteger.LeftShift(400L, 100L), 100L),
400L)
AreEqual(
BigInteger.RightShift(BigInteger.LeftShift(-12345678987654321L, 100L),
100L), -12345678987654321L)
if is_net40:
AssertError(ValueError, BigInteger.RightShift, 400L, -100L)
AssertError(ValueError, BigInteger.LeftShift, 400L, -100L)
AssertError(ValueError, BigInteger.RightShift, -12345678987654321L,
-100L)
AssertError(ValueError, BigInteger.LeftShift, -12345678987654321L,
-100L)
else:
AreEqual(
BigInteger.LeftShift(BigInteger.RightShift(400L, -100L), -100L),
400L)
AreEqual(
BigInteger.LeftShift(
BigInteger.RightShift(-12345678987654321L, -100L), -100L),
-12345678987654321L)
AreEqual(
BigInteger(
-123456781234567812345678123456781234567812345678123456781234567812345678L
).OnesComplement().OnesComplement(),
-123456781234567812345678123456781234567812345678123456781234567812345678L
)
AreEqual(
BigInteger(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L
).OnesComplement(),
-(-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L
+ 1L))
Assert(
BigInteger.Xor(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L,
BigInteger(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L
).OnesComplement()), -1L)
AreEqual(
BigInteger.BitwiseAnd(0xff00ff00,
BigInteger.BitwiseOr(0x00ff00ff, 0xaabbaabb)),
BigInteger(0xaa00aa00))
AreEqual(
BigInteger.Mod(BigInteger(-9999999999999999999999999999999999999999),
1000000000000000000),
-BigInteger.Mod(9999999999999999999999999999999999999999,
BigInteger(-1000000000000000000)))
AreEqual(BigInteger.ToInt64(0x7fffffffffffffff), 9223372036854775807L)
AssertError(OverflowError, BigInteger.ToInt64, 0x8000000000000000)
AreEqual(BigInteger(-0).ToBoolean(p), False)
AreEqual(BigInteger(-1212321.3213).ToBoolean(p), True)
AreEqual(BigInteger(1212321384892342394723947L).ToBoolean(p), True)
AreEqual(BigInteger(0L).ToChar(p), Char.MinValue)
AreEqual(BigInteger(65L).ToChar(p), IConvertible.ToChar('A', p))
AreEqual(BigInteger(0xffff).ToChar(p), Char.MaxValue)
AssertError(OverflowError, BigInteger(-1).ToChar, p)
AreEqual(BigInteger(100).ToDouble(p), 100.0)
AreEqual(
BigInteger(BigInteger(100).ToDouble(p)).ToSingle(p),
BigInteger(100.1213123).ToFloat())
Assert(BigInteger(100) != 100.32)
AreEqual(BigInteger(100), 100.0)
Assert(100.32 != BigInteger(100))
AreEqual(100.0, BigInteger(100))
def CheckByteConversions(bigint, bytes):
SequencesAreEqual(bigint.ToByteArray(), bytes)
AreEqual(BigInteger.Create(Array[Byte](bytes)), bigint)
def test_bigint(self):
from System import Int64, Boolean, Char, Double, Single, IConvertible
from System.Numerics import BigInteger
self.assertEqual(
BigInteger.Add(
big(1),
99999999999999999999999999999999999999999999999999999999999),
BigInteger.Subtract(
100000000000000000000000000000000000000000000000000000000001,
big(1)))
self.assertEqual(BigInteger.Multiply(big(400), big(500)),
BigInteger.Divide(big(1000000), big(5)))
self.assertEqual(BigInteger.Multiply(big(400), big(8)),
big(400) << big(3))
self.assertEqual(BigInteger.Divide(big(400), big(8)),
big(400) >> big(3))
self.assertEqual((big(400) << big(100)) >> big(100), big(400))
self.assertEqual((-12345678987654321 << big(100)) >> big(100),
-12345678987654321)
self.assertRaises(ValueError, lambda x, y: x >> y, big(400), -big(100))
self.assertRaises(ValueError, lambda x, y: x << y, big(400), -big(100))
self.assertRaises(ValueError, lambda x, y: x >> y, -12345678987654321,
-big(100))
self.assertRaises(ValueError, lambda x, y: x << y, -12345678987654321,
-big(100))
self.assertEqual(
~(~big(
-123456781234567812345678123456781234567812345678123456781234567812345678
)),
-123456781234567812345678123456781234567812345678123456781234567812345678
)
self.assertEqual(
~big(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678
),
-(-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678
+ big(1)))
self.assertTrue(
big(-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678
) ^
(~big(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678
)), -big(1))
self.assertEqual(
big(0xff00ff00) & (big(0x00ff00ff) | big(0xaabbaabb)),
big(0xaa00aa00))
self.assertEqual(
big(-9999999999999999999999999999999999999999) %
1000000000000000000, -(9999999999999999999999999999999999999999 %
big(-1000000000000000000)))
self.assertEqual(Int64(big(0x7fffffffffffffff)), 9223372036854775807)
self.assertRaises(OverflowError, Int64, big(0x8000000000000000))
self.assertEqual(Boolean(big(-0)), False)
self.assertEqual(Boolean(big(int(-1212321.3213))), True)
self.assertEqual(Boolean(big(1212321384892342394723947)), True)
self.assertEqual(Char(big(0)), Char.MinValue)
self.assertEqual(Char(big(65)), IConvertible.ToChar('A', self.p))
self.assertEqual(Char(big(0xffff)), Char.MaxValue)
self.assertRaises(OverflowError, Char, big(-1))
self.assertEqual(Double(big(100)), 100.0)
self.assertEqual(Single(big(100)), 100.0)
self.assertEqual(Single(big(100)),
IConvertible.ToSingle(int(100.1213123), self.p))
self.assertTrue(big(100) != 100.32)
self.assertEqual(big(100), 100.0)
self.assertTrue(100.32 != big(100))
self.assertEqual(100.0, big(100))
def test_bigint(self):
from System import Char, IConvertible
from System.Numerics import BigInteger, Complex
self.assertEqual(
BigInteger.Add(
1L,
99999999999999999999999999999999999999999999999999999999999L),
BigInteger.Subtract(
100000000000000000000000000000000000000000000000000000000001L,
1L))
self.assertEqual(BigInteger.Multiply(400L, 500L),
BigInteger.Divide(1000000L, 5L))
self.assertEqual(BigInteger.Multiply(400L, 8L),
BigInteger.LeftShift(400L, 3L))
self.assertEqual(BigInteger.Divide(400L, 8L),
BigInteger.RightShift(400L, 3L))
self.assertEqual(
BigInteger.RightShift(BigInteger.LeftShift(400L, 100L), 100L),
400L)
self.assertEqual(
BigInteger.RightShift(
BigInteger.LeftShift(-12345678987654321L, 100L), 100L),
-12345678987654321L)
self.assertRaises(ValueError, BigInteger.RightShift, 400L, -100L)
self.assertRaises(ValueError, BigInteger.LeftShift, 400L, -100L)
self.assertRaises(ValueError, BigInteger.RightShift,
-12345678987654321L, -100L)
self.assertRaises(ValueError, BigInteger.LeftShift,
-12345678987654321L, -100L)
self.assertEqual(
BigInteger(
-123456781234567812345678123456781234567812345678123456781234567812345678L
).OnesComplement().OnesComplement(),
-123456781234567812345678123456781234567812345678123456781234567812345678L
)
self.assertEqual(
BigInteger(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L
).OnesComplement(),
-(-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L
+ 1L))
self.assertTrue(
BigInteger.Xor(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L,
BigInteger(
-1234567812345678123456781234567812345678123456781234567812345678123456781234567812345678L
).OnesComplement()), -1L)
self.assertEqual(
BigInteger.BitwiseAnd(0xff00ff00,
BigInteger.BitwiseOr(0x00ff00ff,
0xaabbaabb)),
BigInteger(0xaa00aa00))
self.assertEqual(
BigInteger.Mod(
BigInteger(-9999999999999999999999999999999999999999),
1000000000000000000),
-BigInteger.Mod(9999999999999999999999999999999999999999,
BigInteger(-1000000000000000000)))
self.assertEqual(BigInteger.ToInt64(0x7fffffffffffffff),
9223372036854775807L)
self.assertRaises(OverflowError, BigInteger.ToInt64,
0x8000000000000000)
self.assertEqual(BigInteger(-0).ToBoolean(self.p), False)
self.assertEqual(BigInteger(-1212321.3213).ToBoolean(self.p), True)
self.assertEqual(
BigInteger(1212321384892342394723947L).ToBoolean(self.p), True)
self.assertEqual(BigInteger(0L).ToChar(self.p), Char.MinValue)
self.assertEqual(
BigInteger(65L).ToChar(self.p), IConvertible.ToChar('A', self.p))
self.assertEqual(BigInteger(0xffff).ToChar(self.p), Char.MaxValue)
self.assertRaises(OverflowError, BigInteger(-1).ToChar, self.p)
self.assertEqual(BigInteger(100).ToDouble(self.p), 100.0)
self.assertEqual(
BigInteger(BigInteger(100).ToDouble(self.p)).ToSingle(self.p),
BigInteger(100.1213123).ToFloat())
self.assertTrue(BigInteger(100) != 100.32)
self.assertEqual(BigInteger(100), 100.0)
self.assertTrue(100.32 != BigInteger(100))
self.assertEqual(100.0, BigInteger(100))
def test_byte_conversions():
def CheckByteConversions(bigint, bytes):
SequencesAreEqual(bigint.ToByteArray(), bytes)
AreEqual(BigInteger.Create(Array[Byte](bytes)), bigint)
CheckByteConversions(BigInteger(0x00), [0x00])
CheckByteConversions(BigInteger(-0x01), [0xff])
CheckByteConversions(BigInteger(-0x81), [0x7f, 0xff])
CheckByteConversions(BigInteger(-0x100), [0x00, 0xff])
CheckByteConversions(BigInteger(-0x1000), [0x00, 0xf0])
CheckByteConversions(BigInteger(-0x10000), [0x00, 0x00, 0xff])
CheckByteConversions(BigInteger(-0x100000), [0x00, 0x00, 0xf0])
CheckByteConversions(BigInteger(-0x10000000), [0x00, 0x00, 0x00, 0xf0])
CheckByteConversions(BigInteger(-0x100000000),
[0x00, 0x00, 0x00, 0x00, 0xff])
CheckByteConversions(BigInteger(0x7f), [0x7f])
CheckByteConversions(BigInteger(0xff), [0xff, 0x00])
CheckByteConversions(BigInteger(0x0201), [0x01, 0x02])
CheckByteConversions(BigInteger(0xf2f1), [0xf1, 0xf2, 0x00])
CheckByteConversions(BigInteger(0x03020100), [0x00, 0x01, 0x02, 0x03])
CheckByteConversions(BigInteger(0x0403020100),
[0x00, 0x01, 0x02, 0x03, 0x04])
CheckByteConversions(BigInteger(0x0706050403020100),
[0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07])
CheckByteConversions(
BigInteger(0x080706050403020100),
[0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])
