Пример #1
0
        public void HexStringConstructorTest()
        {
            BigUInt bui = new BigUInt("1234567890ABCDEF1234567890ABCDEF");

            Assert.IsFalse(bui.IsZero);
            Assert.AreEqual(2ul, bui.UInt64Count);
            Assert.AreEqual(125, bui.BitCount);
            Assert.AreEqual(125, bui.GetSignificantBitCount());

            Assert.AreEqual(0x1234567890ABCDEFul, bui.Data(0));
            Assert.AreEqual(0x1234567890ABCDEFul, bui.Data(1));

            bui = new BigUInt("FEDCBAFEDCBA0987654321");

            Assert.IsFalse(bui.IsZero);
            Assert.AreEqual(2ul, bui.UInt64Count);
            Assert.AreEqual(88, bui.BitCount);
            Assert.AreEqual(88, bui.GetSignificantBitCount());

            Assert.AreEqual(0xFEDCBAul, bui.Data(1));
            Assert.AreEqual(0xFEDCBA0987654321ul, bui.Data(0));

            bui = new BigUInt(bitCount: 80, hexString: "DEADBEEF");

            Assert.IsFalse(bui.IsZero);
            Assert.AreEqual(2ul, bui.UInt64Count);
            Assert.AreEqual(80, bui.BitCount);
            Assert.AreEqual(32, bui.GetSignificantBitCount());
            Assert.AreEqual(0ul, bui.Data(1));
            Assert.AreEqual(0xDEADBEEFul, bui.Data(0));
        }
Пример #2
0
        public void EmptyBigUIntNET()
        {
            var biguint = new BigUInt();

            Assert.AreEqual(0, biguint.BitCount);
            Assert.AreEqual(0ul, biguint.ByteCount);
            Assert.AreEqual(0ul, biguint.UInt64Count);
            Assert.IsTrue(biguint.UInt64Count == 0ul);
            Assert.AreEqual(0, biguint.GetSignificantBitCount());
            Assert.AreEqual("0", biguint.ToString());
            Assert.IsTrue(biguint.IsZero);
            Assert.IsFalse(biguint.IsAlias);
            biguint.SetZero();

            var biguint2 = new BigUInt();

            Assert.IsTrue(biguint.Equals(biguint2));

            biguint.Resize(1);
            Assert.AreEqual(1, biguint.BitCount);
            Assert.IsTrue(biguint.UInt64Count != 0ul);
            Assert.IsFalse(biguint.IsAlias);

            biguint.Resize(0);
            Assert.AreEqual(0, biguint.BitCount);
            Assert.IsTrue(biguint.UInt64Count == 0ul);
            Assert.IsFalse(biguint.IsAlias);
        }
Пример #3
0
        public void BitCountConstructorTest()
        {
            BigUInt bui = new BigUInt(bitCount: 70);

            Assert.IsTrue(bui.IsZero);
            Assert.AreEqual(70, bui.BitCount);
            Assert.AreEqual(2ul, bui.UInt64Count);
            Assert.AreEqual(0, bui.GetSignificantBitCount());
        }
Пример #4
0
        public void U64ConstructorTest()
        {
            BigUInt bui = new BigUInt(bitCount: 80, value: 12345ul);

            Assert.IsFalse(bui.IsZero);
            Assert.AreEqual(2ul, bui.UInt64Count);
            Assert.AreEqual(14, bui.GetSignificantBitCount());
            Assert.AreEqual(0ul, bui.Data(1));
            Assert.AreEqual(12345ul, bui.Data(0));
        }
Пример #5
0
        public void BigIntegerConstructorTest()
        {
            BigInteger bi  = new BigInteger(12345);
            BigUInt    bui = new BigUInt(bi);

            Assert.IsFalse(bui.IsZero);
            Assert.AreEqual(14, bui.BitCount);
            Assert.AreEqual(2ul, bui.ByteCount);
            Assert.AreEqual(14, bui.GetSignificantBitCount());
            Assert.AreEqual(1ul, bui.UInt64Count);
            Assert.AreEqual(12345ul, bui.Data(0));
        }
Пример #6
0
        public void CopyConstructorTest()
        {
            BigUInt bui1 = new BigUInt("DEADBEEF");
            BigUInt bui2 = new BigUInt("1234567890ABCDEF1234567890ABCDEF");

            BigUInt bui3 = new BigUInt(bui1);

            Assert.AreEqual(1ul, bui3.UInt64Count);
            Assert.AreEqual(32, bui3.GetSignificantBitCount());
            Assert.AreEqual(0xDEADBEEFul, bui3.Data(0));
            Assert.IsTrue(bui1.Equals(bui3));

            bui3 = new BigUInt(bui2);

            Assert.AreEqual(2ul, bui3.UInt64Count);
            Assert.AreEqual(125, bui3.BitCount);
            Assert.AreEqual(125, bui3.GetSignificantBitCount());
            Assert.AreEqual(0x1234567890ABCDEFul, bui3.Data(0));
            Assert.AreEqual(0x1234567890ABCDEFul, bui3.Data(1));
            Assert.IsTrue(bui2.Equals(bui3));
        }
Пример #7
0
        public void BigUInt99BitsNET()
        {
            var biguint = new BigUInt(99);

            Assert.AreEqual(99, biguint.BitCount);
            Assert.IsTrue(biguint.UInt64Count != 0ul);
            Assert.AreEqual(13ul, biguint.ByteCount);
            Assert.AreEqual(2ul, biguint.UInt64Count);
            Assert.AreEqual(0, biguint.GetSignificantBitCount());
            Assert.AreEqual("0", biguint.ToString());
            Assert.IsTrue(biguint.IsZero);
            Assert.AreEqual(0UL, biguint.Data(0));
            Assert.AreEqual(0UL, biguint.Data(1));
            Assert.AreEqual(0, biguint[0]);
            Assert.AreEqual(0, biguint[1]);
            Assert.AreEqual(0, biguint[2]);
            Assert.AreEqual(0, biguint[3]);
            Assert.AreEqual(0, biguint[4]);
            Assert.AreEqual(0, biguint[5]);
            Assert.AreEqual(0, biguint[6]);
            Assert.AreEqual(0, biguint[7]);
            Assert.AreEqual(0, biguint[8]);
            Assert.AreEqual(0, biguint[9]);
            Assert.AreEqual(0, biguint[10]);
            Assert.AreEqual(0, biguint[11]);
            Assert.AreEqual(0, biguint[12]);

            biguint.Set(1);
            Assert.AreEqual(1, biguint.GetSignificantBitCount());
            Assert.AreEqual("1", biguint.ToString());
            Assert.IsFalse(biguint.IsZero);
            Assert.AreEqual(13ul, biguint.ByteCount);
            Assert.AreEqual(2ul, biguint.UInt64Count);
            Assert.AreEqual(1UL, biguint.Data(0));
            Assert.AreEqual(0UL, biguint.Data(1));
            Assert.AreEqual(1, biguint[0]);
            Assert.AreEqual(0, biguint[1]);
            Assert.AreEqual(0, biguint[2]);
            Assert.AreEqual(0, biguint[3]);
            Assert.AreEqual(0, biguint[4]);
            Assert.AreEqual(0, biguint[5]);
            Assert.AreEqual(0, biguint[6]);
            Assert.AreEqual(0, biguint[7]);
            Assert.AreEqual(0, biguint[8]);
            Assert.AreEqual(0, biguint[9]);
            Assert.AreEqual(0, biguint[10]);
            Assert.AreEqual(0, biguint[11]);
            Assert.AreEqual(0, biguint[12]);
            biguint.SetZero();
            Assert.IsTrue(biguint.IsZero);
            Assert.AreEqual(0UL, biguint.Data(0));
            Assert.AreEqual(0UL, biguint.Data(1));

            biguint.Set("7FFFFFFFFFFFFFFFFFFFFFFFF");
            Assert.AreEqual(99, biguint.GetSignificantBitCount());
            Assert.AreEqual("7FFFFFFFFFFFFFFFFFFFFFFFF", biguint.ToString());
            Assert.IsFalse(biguint.IsZero);
            Assert.AreEqual(0xFFFFFFFFFFFFFFFFUL, biguint.Data(0));
            Assert.AreEqual(0x7FFFFFFFFUL, biguint.Data(1));
            Assert.AreEqual(0xFF, biguint[0]);
            Assert.AreEqual(0xFF, biguint[1]);
            Assert.AreEqual(0xFF, biguint[2]);
            Assert.AreEqual(0xFF, biguint[3]);
            Assert.AreEqual(0xFF, biguint[4]);
            Assert.AreEqual(0xFF, biguint[5]);
            Assert.AreEqual(0xFF, biguint[6]);
            Assert.AreEqual(0xFF, biguint[7]);
            Assert.AreEqual(0xFF, biguint[8]);
            Assert.AreEqual(0xFF, biguint[9]);
            Assert.AreEqual(0xFF, biguint[10]);
            Assert.AreEqual(0xFF, biguint[11]);
            Assert.AreEqual(0x07, biguint[12]);
            biguint.SetZero();
            Assert.IsTrue(biguint.IsZero);
            Assert.AreEqual(0UL, biguint.Data(0));
            Assert.AreEqual(0UL, biguint.Data(1));

            biguint.Set("4000000000000000000000000");
            Assert.AreEqual(99, biguint.GetSignificantBitCount());
            Assert.AreEqual("4000000000000000000000000", biguint.ToString());
            Assert.IsFalse(biguint.IsZero);
            Assert.AreEqual(0UL, biguint.Data(0));
            Assert.AreEqual(0x400000000UL, biguint.Data(1));
            Assert.AreEqual(0, biguint[0]);
            Assert.AreEqual(0, biguint[1]);
            Assert.AreEqual(0, biguint[2]);
            Assert.AreEqual(0, biguint[3]);
            Assert.AreEqual(0, biguint[4]);
            Assert.AreEqual(0, biguint[5]);
            Assert.AreEqual(0, biguint[6]);
            Assert.AreEqual(0, biguint[7]);
            Assert.AreEqual(0, biguint[8]);
            Assert.AreEqual(0, biguint[9]);
            Assert.AreEqual(0, biguint[10]);
            Assert.AreEqual(0, biguint[11]);
            Assert.AreEqual(0x04, biguint[12]);

            biguint.Set(0x8001);
            Assert.AreEqual(16, biguint.GetSignificantBitCount());
            Assert.AreEqual("8001", biguint.ToString());
            Assert.IsFalse(biguint.IsZero);
            Assert.AreEqual(0x8001UL, biguint.Data(0));
            Assert.AreEqual(0UL, biguint.Data(1));
            Assert.AreEqual(0x01, biguint[0]);
            Assert.AreEqual(0x80, biguint[1]);
            Assert.AreEqual(0, biguint[2]);
            Assert.AreEqual(0, biguint[3]);
            Assert.AreEqual(0, biguint[4]);
            Assert.AreEqual(0, biguint[5]);
            Assert.AreEqual(0, biguint[6]);
            Assert.AreEqual(0, biguint[7]);
            Assert.AreEqual(0, biguint[8]);
            Assert.AreEqual(0, biguint[9]);
            Assert.AreEqual(0, biguint[10]);
            Assert.AreEqual(0, biguint[11]);
            Assert.AreEqual(0, biguint[12]);

            var biguint2 = new BigUInt("123");

            Assert.IsFalse(biguint.Equals(biguint2));
            Assert.IsFalse(biguint2.Equals(biguint));
            Assert.AreNotEqual(biguint.GetHashCode(), biguint2.GetHashCode());

            biguint.Set(biguint2);
            Assert.IsTrue(biguint.Equals(biguint2));
            Assert.IsTrue(biguint2.Equals(biguint));
            Assert.AreEqual(biguint.GetHashCode(), biguint2.GetHashCode());
            Assert.AreEqual(9, biguint.GetSignificantBitCount());
            Assert.AreEqual("123", biguint.ToString());
            Assert.AreEqual(0x123UL, biguint.Data(0));
            Assert.AreEqual(0UL, biguint.Data(1));
            Assert.AreEqual(0x23, biguint[0]);
            Assert.AreEqual(0x01, biguint[1]);
            Assert.AreEqual(0, biguint[2]);
            Assert.AreEqual(0, biguint[3]);
            Assert.AreEqual(0, biguint[4]);
            Assert.AreEqual(0, biguint[5]);
            Assert.AreEqual(0, biguint[6]);
            Assert.AreEqual(0, biguint[7]);
            Assert.AreEqual(0, biguint[8]);
            Assert.AreEqual(0, biguint[9]);
            Assert.AreEqual(0, biguint[10]);
            Assert.AreEqual(0, biguint[11]);
            Assert.AreEqual(0, biguint[12]);

            biguint.Resize(8);
            Assert.AreEqual(8, biguint.BitCount);
            Assert.AreEqual(1ul, biguint.UInt64Count);
            Assert.AreEqual("23", biguint.ToString());

            biguint.Resize(100);
            Assert.AreEqual(100, biguint.BitCount);
            Assert.AreEqual(2ul, biguint.UInt64Count);
            Assert.AreEqual("23", biguint.ToString());

            biguint.Resize(0);
            Assert.AreEqual(0, biguint.BitCount);
            Assert.AreEqual(0ul, biguint.UInt64Count);
            Assert.IsTrue(biguint.UInt64Count == 0);
        }
Пример #8
0
        public void BigUInt64BitsNET()
        {
            var biguint = new BigUInt(64);

            Assert.AreEqual(64, biguint.BitCount);
            Assert.AreEqual(8ul, biguint.ByteCount);
            Assert.AreEqual(1ul, biguint.UInt64Count);
            Assert.AreEqual(0, biguint.GetSignificantBitCount());
            Assert.AreEqual("0", biguint.ToString());
            Assert.IsTrue(biguint.IsZero);
            Assert.IsTrue(biguint.UInt64Count != 0);
            Assert.AreEqual(0UL, biguint.Data(0));
            Assert.AreEqual(0, biguint[0]);
            Assert.AreEqual(0, biguint[1]);
            Assert.AreEqual(0, biguint[2]);
            Assert.AreEqual(0, biguint[3]);
            Assert.AreEqual(0, biguint[4]);
            Assert.AreEqual(0, biguint[5]);
            Assert.AreEqual(0, biguint[6]);
            Assert.AreEqual(0, biguint[7]);

            biguint.Set(1);
            Assert.AreEqual(1, biguint.GetSignificantBitCount());
            Assert.AreEqual("1", biguint.ToString());
            Assert.IsFalse(biguint.IsZero);
            Assert.AreEqual(1UL, biguint.Data(0));
            Assert.AreEqual(1, biguint[0]);
            Assert.AreEqual(0, biguint[1]);
            Assert.AreEqual(0, biguint[2]);
            Assert.AreEqual(0, biguint[3]);
            Assert.AreEqual(0, biguint[4]);
            Assert.AreEqual(0, biguint[5]);
            Assert.AreEqual(0, biguint[6]);
            Assert.AreEqual(0, biguint[7]);
            biguint.SetZero();
            Assert.IsTrue(biguint.IsZero);
            Assert.AreEqual(0UL, biguint.Data(0));

            biguint.Set("7FFFFFFFFFFFFFFF");
            Assert.AreEqual(63, biguint.GetSignificantBitCount());
            Assert.IsFalse(biguint.IsZero);
            Assert.AreEqual("7FFFFFFFFFFFFFFF", biguint.ToString());
            Assert.AreEqual(0x7FFFFFFFFFFFFFFFUL, biguint.Data(0));
            Assert.AreEqual(0xFF, biguint[0]);
            Assert.AreEqual(0xFF, biguint[1]);
            Assert.AreEqual(0xFF, biguint[2]);
            Assert.AreEqual(0xFF, biguint[3]);
            Assert.AreEqual(0xFF, biguint[4]);
            Assert.AreEqual(0xFF, biguint[5]);
            Assert.AreEqual(0xFF, biguint[6]);
            Assert.AreEqual(0x7F, biguint[7]);

            biguint.Set("FFFFFFFFFFFFFFFF");
            Assert.AreEqual(64, biguint.GetSignificantBitCount());
            Assert.IsFalse(biguint.IsZero);
            Assert.AreEqual("FFFFFFFFFFFFFFFF", biguint.ToString());
            Assert.AreEqual(0xFFFFFFFFFFFFFFFFUL, biguint.Data(0));
            Assert.AreEqual(0xFF, biguint[0]);
            Assert.AreEqual(0xFF, biguint[1]);
            Assert.AreEqual(0xFF, biguint[2]);
            Assert.AreEqual(0xFF, biguint[3]);
            Assert.AreEqual(0xFF, biguint[4]);
            Assert.AreEqual(0xFF, biguint[5]);
            Assert.AreEqual(0xFF, biguint[6]);
            Assert.AreEqual(0xFF, biguint[7]);

            biguint.Set(0x8001);
            Assert.AreEqual(16, biguint.GetSignificantBitCount());
            Assert.AreEqual("8001", biguint.ToString());
            Assert.AreEqual(0x8001UL, biguint.Data(0));
            Assert.AreEqual(0x01, biguint[0]);
            Assert.AreEqual(0x80, biguint[1]);
            Assert.AreEqual(0x00, biguint[2]);
            Assert.AreEqual(0x00, biguint[3]);
            Assert.AreEqual(0x00, biguint[4]);
            Assert.AreEqual(0x00, biguint[5]);
            Assert.AreEqual(0x00, biguint[6]);
            Assert.AreEqual(0x00, biguint[7]);
        }