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