428 lines
16 KiB
C#
428 lines
16 KiB
C#
/*
|
|
Copyright 2014 Alex Dyachenko
|
|
|
|
This file is part of the MPIR Library.
|
|
|
|
The MPIR Library is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published
|
|
by the Free Software Foundation; either version 3 of the License, or (at
|
|
your option) any later version.
|
|
|
|
The MPIR Library is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with the MPIR Library. If not, see http://www.gnu.org/licenses/.
|
|
*/
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Linq;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
|
|
namespace MPIR.Tests.HugeIntTests
|
|
{
|
|
[TestClass]
|
|
public class IO
|
|
{
|
|
[TestMethod]
|
|
public void IntInputOutputRaw()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = a ^ 100;
|
|
a.Write(ms);
|
|
ms.Position = 0;
|
|
b.Read(ms);
|
|
Assert.AreEqual(a, b);
|
|
Assert.IsTrue(b > 0);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntInputOutputRawNegative()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = -(a ^ 100);
|
|
a.Write(ms);
|
|
ms.Position = 0;
|
|
b.Read(ms);
|
|
Assert.AreEqual(a, b);
|
|
Assert.IsTrue(b < 0);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntInputOutputStr()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = a ^ 100;
|
|
using (var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true))
|
|
a.Write(writer);
|
|
|
|
ms.Position = 0;
|
|
|
|
using (var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, true))
|
|
b.Read(reader);
|
|
|
|
Assert.AreEqual(a, b);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntInputOutputStrHex()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = a ^ 100;
|
|
using (var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true))
|
|
{
|
|
writer.Write("0x");
|
|
a.Write(writer, 16);
|
|
}
|
|
|
|
ms.Position = 0;
|
|
|
|
using (var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, true))
|
|
b.Read(reader);
|
|
|
|
Assert.AreEqual(a, b);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
Assert.AreEqual((char)0xFEFF + "0x" + a.ToString(16), Encoding.UTF8.GetString(ms.ToArray()));
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntInputOutputStrHexLower()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = a ^ 100;
|
|
using (var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true))
|
|
{
|
|
writer.Write("0x");
|
|
a.Write(writer, 16, true);
|
|
}
|
|
|
|
ms.Position = 0;
|
|
|
|
using (var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, true))
|
|
b.Read(reader);
|
|
|
|
Assert.AreEqual(a, b);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
Assert.AreEqual((char)0xFEFF + "0x" + a.ToString(16, true), Encoding.UTF8.GetString(ms.ToArray()));
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntInputOutputStrOctal()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = a ^ 100;
|
|
using (var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true))
|
|
{
|
|
writer.Write('0');
|
|
a.Write(writer, 8);
|
|
}
|
|
|
|
ms.Position = 0;
|
|
|
|
using (var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, true))
|
|
b.Read(reader);
|
|
|
|
Assert.AreEqual(a, b);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
Assert.AreEqual((char)0xFEFF + "0" + a.ToString(8), Encoding.UTF8.GetString(ms.ToArray()));
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntInputOutputStrBinary()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = a ^ 100;
|
|
using (var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true))
|
|
{
|
|
writer.Write("0b");
|
|
a.Write(writer, 2);
|
|
}
|
|
|
|
ms.Position = 0;
|
|
|
|
using (var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, true))
|
|
b.Read(reader);
|
|
|
|
Assert.AreEqual(a, b);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
Assert.AreEqual((char)0xFEFF + "0b" + a.ToString(2), Encoding.UTF8.GetString(ms.ToArray()));
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntInputOutputStr62()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
using (var ms = new MemoryStream())
|
|
{
|
|
a.Value = a ^ 100;
|
|
using (var writer = new StreamWriter(ms, Encoding.UTF8, 1024, true))
|
|
a.Write(writer, 62);
|
|
|
|
ms.Position = 0;
|
|
|
|
using (var reader = new StreamReader(ms, Encoding.UTF8, false, 1024, true))
|
|
b.Read(reader, 62);
|
|
|
|
Assert.AreEqual(a, b);
|
|
Assert.AreEqual(ms.Length, ms.Position);
|
|
Assert.AreEqual((char)0xFEFF + a.ToString(62), Encoding.UTF8.GetString(ms.ToArray()));
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntImportExport()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
{
|
|
var bytes = new byte[1000];
|
|
|
|
foreach (var order in Enum.GetValues(typeof(LimbOrder)).Cast<LimbOrder>())
|
|
foreach (var endianness in Enum.GetValues(typeof(Endianness)).Cast<Endianness>())
|
|
foreach (var nails in new[] { 0, 5, 10, 16 })
|
|
foreach (var size in new[] { 8, 11, 16 })
|
|
{
|
|
var words = a.Export(bytes, size, order, endianness, nails);
|
|
var expected = (ulong)System.Math.Ceiling(193m / (size * 8 - nails));
|
|
Assert.AreEqual(expected, words);
|
|
|
|
b.SetTo(0);
|
|
b.Import(bytes, words, size, order, endianness, nails);
|
|
Assert.AreEqual(a, b);
|
|
}
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntImportExportAllocating()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
{
|
|
foreach (var order in Enum.GetValues(typeof(LimbOrder)).Cast<LimbOrder>())
|
|
foreach (var endianness in Enum.GetValues(typeof(Endianness)).Cast<Endianness>())
|
|
foreach (var nails in new[] { 0, 5, 10, 16 })
|
|
foreach (var size in new[] { 8, 11, 16 })
|
|
{
|
|
var bytes = a.Export<byte>(size, order, endianness, nails);
|
|
var expected = (int)System.Math.Ceiling(193m / (size * 8 - nails));
|
|
Assert.AreEqual(expected, bytes.Length / size);
|
|
|
|
b.SetTo(0);
|
|
b.Import(bytes, (uint)(bytes.Length / size), size, order, endianness, nails);
|
|
Assert.AreEqual(a, b);
|
|
}
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntImportExportAllocatingShort()
|
|
{
|
|
using (var a = new HugeInt("0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
using (var b = new HugeInt())
|
|
{
|
|
foreach (var order in Enum.GetValues(typeof(LimbOrder)).Cast<LimbOrder>())
|
|
foreach (var endianness in Enum.GetValues(typeof(Endianness)).Cast<Endianness>())
|
|
foreach (var nails in new[] { 0, 5, 10, 16 })
|
|
foreach (var size in new[] { 8, 11, 16 })
|
|
{
|
|
var bytes = a.Export<short>(size, order, endianness, nails);
|
|
var expected = (int)System.Math.Ceiling(193m / (size * 8 - nails));
|
|
Assert.AreEqual(expected, bytes.Length * 2 / size);
|
|
|
|
b.SetTo(0);
|
|
b.Import(bytes, (uint)(bytes.Length * 2 / size), size, order, endianness, nails);
|
|
Assert.AreEqual(a, b);
|
|
}
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntImportExportAllocatingZero()
|
|
{
|
|
using (var a = new HugeInt())
|
|
using (var b = new HugeInt())
|
|
{
|
|
var order = LimbOrder.LeastSignificantFirst;
|
|
var endianness = Endianness.Native;
|
|
var nails = 5;
|
|
var size = 4;
|
|
|
|
var bytes = a.Export<byte>(size, order, endianness, nails);
|
|
Assert.AreEqual(0, bytes.Length);
|
|
|
|
b.SetTo(1);
|
|
b.Import(bytes, 0, size, order, endianness, nails);
|
|
Assert.AreEqual(a, b);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntSize()
|
|
{
|
|
using (var a = new HugeInt("-0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
{
|
|
var limbs = 192U / MpirSettings.BITS_PER_LIMB + 1;
|
|
Assert.AreEqual(limbs, a.Size());
|
|
Assert.AreEqual(limbs, (-a).Size());
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntAllocatedSize()
|
|
{
|
|
using (var a = new HugeInt("-0x10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"))
|
|
{
|
|
var allocated = a.AllocatedSize;
|
|
Assert.IsTrue(allocated >= (int)a.Size());
|
|
a.Value = -a;
|
|
Assert.AreEqual(allocated, a.AllocatedSize);
|
|
Assert.AreEqual(192U / MpirSettings.BITS_PER_LIMB + 1, a.Size());
|
|
|
|
a.Value >>= 64;
|
|
Assert.AreEqual(128U / MpirSettings.BITS_PER_LIMB + 1, a.Size());
|
|
Assert.AreEqual(allocated, a.AllocatedSize);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntGetLimb()
|
|
{
|
|
using (var a = new HugeInt("-0x10123456789ABCDEFA123456789ABCDEF0123456789ABCDEF"))
|
|
{
|
|
Assert.AreEqual(Platform.Ui(0x0123456789ABCDEFUL, 0x89ABCDEFU), a.GetLimb(0));
|
|
Assert.AreEqual(Platform.Ui(0xA123456789ABCDEFUL, 0x01234567U), a.GetLimb(1));
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntReadLimbs()
|
|
{
|
|
var dest = Enumerable.Repeat(Platform.Ui(0, 0), 8).ToArray();
|
|
|
|
using (var a = new HugeInt("-0x55533123456789ABCDEF02468ACEFDB9753171122334455667788"))
|
|
{
|
|
a.ReadLimbs(dest, 1, 2, 3);
|
|
a.ReadLimbs(dest, 2, 2, 6);
|
|
Assert.AreEqual(Platform.Ui(0x2468ACEFDB975317UL, 0x11223344U), dest[3]);
|
|
Assert.AreEqual(Platform.Ui(0x123456789ABCDEF0UL, 0xDB975317U), dest[4]);
|
|
Assert.AreEqual(Platform.Ui(0x123456789ABCDEF0UL, 0xDB975317U), dest[6]);
|
|
Assert.AreEqual(Platform.Ui(0x0000000000055533UL, 0x2468ACEFU), dest[7]);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntModifyLimbs()
|
|
{
|
|
var src = new[]
|
|
{
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0x2468ACEFDB975317UL, 0x11223344U),
|
|
Platform.Ui(0x3456789ABCDEF044UL, 0x09872458U),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0x123456789ABCDEF0UL, 0xDB975317U),
|
|
Platform.Ui(0x0000000000055533UL, 0x2468ACEFU),
|
|
};
|
|
|
|
using (var a = new HugeInt(Platform.Select("0x1122334455667788", "0x55667788")))
|
|
using (var expected1 = new HugeInt(Platform.Select( "0x3456789ABCDEF0442468ACEFDB9753171122334455667788", "0x098724581122334455667788")))
|
|
using (var expected2 = new HugeInt(Platform.Select("-0x55533123456789ABCDEF02468ACEFDB9753171122334455667788", "-0x2468ACEFDB9753171122334455667788")))
|
|
{
|
|
a.ModifyLimbs(src, 1, 2, 3, false);
|
|
Assert.AreEqual(expected1, a);
|
|
|
|
a.ModifyLimbs(src, 2, 2, 6, true);
|
|
Assert.AreEqual(expected2, a);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntModifyLimbsWithGap()
|
|
{
|
|
var src = new[]
|
|
{
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0x2468ACEFDB975317UL, 0x11223344U),
|
|
Platform.Ui(0x3456789ABCDEF044UL, 0x09872458U),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0x123456789ABCDEF0UL, 0xDB975317U),
|
|
Platform.Ui(0x0000000000055533UL, 0x2468ACEFU),
|
|
};
|
|
|
|
using (var a = new HugeInt(Platform.Select("0x1122334455667788", "0x55667788")))
|
|
using (var expected = new HugeInt(Platform.Select("0x3456789ABCDEF0442468ACEFDB97531700000000000000001122334455667788", "0x09872458112233440000000055667788")))
|
|
{
|
|
a.ModifyLimbs(src, 2, 2, 3, false);
|
|
Assert.AreEqual(expected, a);
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public void IntWriteLimbs()
|
|
{
|
|
var src = new[]
|
|
{
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0x2468ACEFDB975317UL, 0x11223344U),
|
|
Platform.Ui(0x3456789ABCDEF044UL, 0x09872458U),
|
|
Platform.Ui(0, 0),
|
|
Platform.Ui(0x123456789ABCDEF0UL, 0xDB975317U),
|
|
Platform.Ui(0x0000000000055533UL, 0x2468ACEFU),
|
|
};
|
|
|
|
using (var a = new HugeInt(Platform.Select("0x1122334455667788", "0x55667788")))
|
|
using (var expected = new HugeInt(Platform.Select("-0x123456789ABCDEF000000000000000003456789ABCDEF0442468ACEFDB975317", "-0xDB975317000000000987245811223344")))
|
|
{
|
|
a.WriteLimbs(src, 3, 4, false);
|
|
Assert.IsTrue(-expected == a);
|
|
|
|
a.WriteLimbs(src, 3, 4, true);
|
|
Assert.AreEqual(expected, a);
|
|
}
|
|
}
|
|
//more tests coming here
|
|
}
|
|
}
|