diff --git a/crypto/test/src/math/ec/test/AllTests.cs b/crypto/test/src/math/ec/test/AllTests.cs
new file mode 100644
index 000000000..f5d7d2249
--- /dev/null
+++ b/crypto/test/src/math/ec/test/AllTests.cs
@@ -0,0 +1,27 @@
+using System;
+
+using NUnit.Core;
+using NUnit.Framework;
+
+namespace Org.BouncyCastle.Math.EC.Tests
+{
+ public class AllTests
+ {
+ public static void Main(
+ string[] args)
+ {
+// junit.textui.TestRunner.run(suite());
+ EventListener el = new NullListener();
+ suite().Run(el);
+ }
+
+ public static TestSuite suite()
+ {
+ TestSuite suite = new TestSuite("EC Math tests");
+
+ suite.Add(new ECPointTest());
+
+ return suite;
+ }
+ }
+}
diff --git a/crypto/test/src/math/ec/test/ECPointPerformanceTest.cs b/crypto/test/src/math/ec/test/ECPointPerformanceTest.cs
new file mode 100644
index 000000000..e71ee653a
--- /dev/null
+++ b/crypto/test/src/math/ec/test/ECPointPerformanceTest.cs
@@ -0,0 +1,73 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.Sec;
+using Org.BouncyCastle.Asn1.X9;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Math.EC;
+using Org.BouncyCastle.Security;
+using Org.BouncyCastle.Utilities.Date;
+
+namespace Org.BouncyCastle.Math.EC.Tests
+{
+ /**
+ * Compares the performance of the the window NAF point multiplication against
+ * conventional point multiplication.
+ */
+ [TestFixture, Explicit]
+ public class ECPointPerformanceTest
+ {
+ public const int NUM_ROUNDS = 100;
+
+ private void randMult(string curveName)
+ {
+ X9ECParameters spec = SecNamedCurves.GetByName(curveName);
+
+ BigInteger n = spec.N;
+ ECPoint g = (ECPoint) spec.G;
+ SecureRandom random = new SecureRandom(); //SecureRandom.getInstance("SHA1PRNG", "SUN");
+ BigInteger k = new BigInteger(n.BitLength - 1, random);
+
+ ECPoint qMultiply = null;
+ long startTime = DateTimeUtilities.CurrentUnixMs();
+ for (int i = 0; i < NUM_ROUNDS; i++)
+ {
+ qMultiply = g.Multiply(k);
+ }
+ long endTime = DateTimeUtilities.CurrentUnixMs();
+
+ double avgDuration = (double) (endTime - startTime) / NUM_ROUNDS;
+ Console.WriteLine(curveName);
+ Console.Write("Millis : ");
+ Console.WriteLine(avgDuration);
+ Console.WriteLine();
+ }
+
+ [Test]
+ public void TestMultiply()
+ {
+ randMult("sect163k1");
+ randMult("sect163r2");
+ randMult("sect233k1");
+ randMult("sect233r1");
+ randMult("sect283k1");
+ randMult("sect283r1");
+ randMult("sect409k1");
+ randMult("sect409r1");
+ randMult("sect571k1");
+ randMult("sect571r1");
+ randMult("secp224k1");
+ randMult("secp224r1");
+ randMult("secp256k1");
+ randMult("secp256r1");
+ randMult("secp521r1");
+ }
+
+ // public static void Main(string argv[])
+ // {
+ // ECMultiplyPerformanceTest test = new ECMultiplyPerformanceTest();
+ // Test.testMultiply();
+ // }
+ }
+}
diff --git a/crypto/test/src/math/ec/test/ECPointTest.cs b/crypto/test/src/math/ec/test/ECPointTest.cs
new file mode 100644
index 000000000..4c8b2d8fc
--- /dev/null
+++ b/crypto/test/src/math/ec/test/ECPointTest.cs
@@ -0,0 +1,451 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Asn1.Sec;
+using Org.BouncyCastle.Asn1.X9;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Math.EC;
+using Org.BouncyCastle.Security;
+
+namespace Org.BouncyCastle.Math.EC.Tests
+{
+ /**
+ * Test class for {@link org.bouncycastle.math.ec.ECPoint ECPoint}. All
+ * literature values are taken from "Guide to elliptic curve cryptography",
+ * Darrel Hankerson, Alfred J. Menezes, Scott Vanstone, 2004, Springer-Verlag
+ * New York, Inc.
+ */
+ [TestFixture]
+ public class ECPointTest
+ {
+ /**
+ * Random source used to generate random points
+ */
+ private SecureRandom secRand = new SecureRandom();
+
+// private ECPointTest.Fp fp = null;
+
+// private ECPointTest.F2m f2m = null;
+
+ /**
+ * Nested class containing sample literature values for <code>Fp</code>.
+ */
+ public class Fp
+ {
+ internal static readonly BigInteger q = new BigInteger("29");
+
+ internal static readonly BigInteger a = new BigInteger("4");
+
+ internal static readonly BigInteger b = new BigInteger("20");
+
+ internal static readonly FpCurve curve = new FpCurve(q, a, b);
+
+ internal static readonly FpPoint infinity = (FpPoint) curve.Infinity;
+
+ internal static readonly int[] pointSource = { 5, 22, 16, 27, 13, 6, 14, 6 };
+
+ internal static FpPoint[] p = new FpPoint[pointSource.Length / 2];
+
+ /**
+ * Creates the points on the curve with literature values.
+ */
+ internal static void createPoints()
+ {
+ for (int i = 0; i < pointSource.Length / 2; i++)
+ {
+ FpFieldElement x = new FpFieldElement(q, new BigInteger(
+ pointSource[2 * i].ToString()));
+ FpFieldElement y = new FpFieldElement(q, new BigInteger(
+ pointSource[2 * i + 1].ToString()));
+ p[i] = new FpPoint(curve, x, y);
+ }
+ }
+ }
+
+ /**
+ * Nested class containing sample literature values for <code>F2m</code>.
+ */
+ public class F2m
+ {
+ // Irreducible polynomial for TPB z^4 + z + 1
+ internal const int m = 4;
+
+ internal const int k1 = 1;
+
+ // a = z^3
+ internal static readonly F2mFieldElement aTpb = new F2mFieldElement(m, k1,
+ new BigInteger("8", 16));
+
+ // b = z^3 + 1
+ internal static readonly F2mFieldElement bTpb = new F2mFieldElement(m, k1,
+ new BigInteger("9", 16));
+
+ internal static readonly F2mCurve curve = new F2mCurve(m, k1, aTpb
+ .ToBigInteger(), bTpb.ToBigInteger());
+
+ internal static readonly F2mPoint infinity = (F2mPoint) curve.Infinity;
+
+ internal static readonly string[] pointSource = { "2", "f", "c", "c", "1", "1", "b", "2" };
+
+ internal static F2mPoint[] p = new F2mPoint[pointSource.Length / 2];
+
+ /**
+ * Creates the points on the curve with literature values.
+ */
+ internal static void createPoints()
+ {
+ for (int i = 0; i < pointSource.Length / 2; i++)
+ {
+ F2mFieldElement x = new F2mFieldElement(m, k1,
+ new BigInteger(pointSource[2 * i], 16));
+ F2mFieldElement y = new F2mFieldElement(m, k1,
+ new BigInteger(pointSource[2 * i + 1], 16));
+ p[i] = new F2mPoint(curve, x, y);
+ }
+ }
+ }
+
+ [SetUp]
+ public void setUp()
+ {
+// fp = new ECPointTest.Fp();
+ Fp.createPoints();
+
+// f2m = new ECPointTest.F2m();
+ F2m.createPoints();
+ }
+
+ /**
+ * Tests, if inconsistent points can be created, i.e. points with exactly
+ * one null coordinate (not permitted).
+ */
+ [Test]
+ public void TestPointCreationConsistency()
+ {
+ try
+ {
+ FpPoint bad = new FpPoint(Fp.curve, new FpFieldElement(
+ Fp.q, new BigInteger("12")), null);
+ Assert.Fail();
+ }
+ catch (ArgumentException)
+ {
+ // Expected
+ }
+
+ try
+ {
+ FpPoint bad = new FpPoint(Fp.curve, null,
+ new FpFieldElement(Fp.q, new BigInteger("12")));
+ Assert.Fail();
+ }
+ catch (ArgumentException)
+ {
+ // Expected
+ }
+
+ try
+ {
+ F2mPoint bad = new F2mPoint(F2m.curve, new F2mFieldElement(
+ F2m.m, F2m.k1, new BigInteger("1011")), null);
+ Assert.Fail();
+ }
+ catch (ArgumentException)
+ {
+ // Expected
+ }
+
+ try
+ {
+ F2mPoint bad = new F2mPoint(F2m.curve, null,
+ new F2mFieldElement(F2m.m, F2m.k1,
+ new BigInteger("1011")));
+ Assert.Fail();
+ }
+ catch (ArgumentException)
+ {
+ // Expected
+ }
+ }
+
+ /**
+ * Tests <code>ECPoint.add()</code> against literature values.
+ *
+ * @param p
+ * The array of literature values.
+ * @param infinity
+ * The point at infinity on the respective curve.
+ */
+ private void implTestAdd(ECPoint[] p, ECPoint infinity)
+ {
+ Assert.AreEqual(p[2], p[0].Add(p[1]), "p0 plus p1 does not equal p2");
+ Assert.AreEqual(p[2], p[1].Add(p[0]), "p1 plus p0 does not equal p2");
+ for (int i = 0; i < p.Length; i++)
+ {
+ Assert.AreEqual(p[i], p[i].Add(infinity), "Adding infinity failed");
+ Assert.AreEqual(p[i], infinity.Add(p[i]), "Adding to infinity failed");
+ }
+ }
+
+ /**
+ * Calls <code>implTestAdd()</code> for <code>Fp</code> and
+ * <code>F2m</code>.
+ */
+ [Test]
+ public void TestAdd()
+ {
+ implTestAdd(Fp.p, Fp.infinity);
+ implTestAdd(F2m.p, F2m.infinity);
+ }
+
+ /**
+ * Tests <code>ECPoint.twice()</code> against literature values.
+ *
+ * @param p
+ * The array of literature values.
+ */
+ private void implTestTwice(ECPoint[] p)
+ {
+ Assert.AreEqual(p[3], p[0].Twice(), "Twice incorrect");
+ Assert.AreEqual(p[3], p[0].Add(p[0]), "Add same point incorrect");
+ }
+
+ /**
+ * Calls <code>implTestTwice()</code> for <code>Fp</code> and
+ * <code>F2m</code>.
+ */
+ [Test]
+ public void TestTwice()
+ {
+ implTestTwice(Fp.p);
+ implTestTwice(F2m.p);
+ }
+
+ /**
+ * Goes through all points on an elliptic curve and checks, if adding a
+ * point <code>k</code>-times is the same as multiplying the point by
+ * <code>k</code>, for all <code>k</code>. Should be called for points
+ * on very small elliptic curves only.
+ *
+ * @param p
+ * The base point on the elliptic curve.
+ * @param infinity
+ * The point at infinity on the elliptic curve.
+ */
+ private void implTestAllPoints(ECPoint p, ECPoint infinity)
+ {
+ ECPoint adder = infinity;
+ ECPoint multiplier = infinity;
+ int i = 1;
+ do
+ {
+ adder = adder.Add(p);
+ multiplier = p.Multiply(new BigInteger(i.ToString()));
+ Assert.AreEqual(adder, multiplier,
+ "Results of add() and multiply() are inconsistent " + i);
+ i++;
+ }
+ while (!(adder.Equals(infinity)));
+ }
+
+ /**
+ * Calls <code>implTestAllPoints()</code> for the small literature curves,
+ * both for <code>Fp</code> and <code>F2m</code>.
+ */
+ [Test]
+ public void TestAllPoints()
+ {
+ for (int i = 0; i < Fp.p.Length; i++)
+ {
+ implTestAllPoints(Fp.p[0], Fp.infinity);
+ }
+
+ for (int i = 0; i < F2m.p.Length; i++)
+ {
+ implTestAllPoints(F2m.p[0], F2m.infinity);
+ }
+ }
+
+ /**
+ * Simple shift-and-add multiplication. Serves as reference implementation
+ * to verify (possibly faster) implementations in
+ * {@link org.bouncycastle.math.ec.ECPoint ECPoint}.
+ *
+ * @param p
+ * The point to multiply.
+ * @param k
+ * The multiplier.
+ * @return The result of the point multiplication <code>kP</code>.
+ */
+ private ECPoint multiply(ECPoint p, BigInteger k)
+ {
+ ECPoint q = p.Curve.Infinity;
+ int t = k.BitLength;
+ for (int i = 0; i < t; i++)
+ {
+ if (k.TestBit(i))
+ {
+ q = q.Add(p);
+ }
+ p = p.Twice();
+ }
+ return q;
+ }
+
+ /**
+ * Checks, if the point multiplication algorithm of the given point yields
+ * the same result as point multiplication done by the reference
+ * implementation given in <code>multiply()</code>. This method chooses a
+ * random number by which the given point <code>p</code> is multiplied.
+ *
+ * @param p
+ * The point to be multiplied.
+ * @param numBits
+ * The bitlength of the random number by which <code>p</code>
+ * is multiplied.
+ */
+ private void implTestMultiply(ECPoint p, int numBits)
+ {
+ BigInteger k = new BigInteger(numBits, secRand);
+ ECPoint reff = multiply(p, k);
+ ECPoint q = p.Multiply(k);
+ Assert.AreEqual(reff, q, "ECPoint.multiply is incorrect");
+ }
+
+ /**
+ * Checks, if the point multiplication algorithm of the given point yields
+ * the same result as point multiplication done by the reference
+ * implementation given in <code>multiply()</code>. This method tests
+ * multiplication of <code>p</code> by every number of bitlength
+ * <code>numBits</code> or less.
+ *
+ * @param p
+ * The point to be multiplied.
+ * @param numBits
+ * Try every multiplier up to this bitlength
+ */
+ private void implTestMultiplyAll(ECPoint p, int numBits)
+ {
+ BigInteger bound = BigInteger.Two.Pow(numBits);
+ BigInteger k = BigInteger.Zero;
+
+ do
+ {
+ ECPoint reff = multiply(p, k);
+ ECPoint q = p.Multiply(k);
+ Assert.AreEqual(reff, q, "ECPoint.multiply is incorrect");
+ k = k.Add(BigInteger.One);
+ }
+ while (k.CompareTo(bound) < 0);
+ }
+
+ /**
+ * Tests <code>ECPoint.add()</code> and <code>ECPoint.subtract()</code>
+ * for the given point and the given point at infinity.
+ *
+ * @param p
+ * The point on which the tests are performed.
+ * @param infinity
+ * The point at infinity on the same curve as <code>p</code>.
+ */
+ private void implTestAddSubtract(ECPoint p, ECPoint infinity)
+ {
+ Assert.AreEqual(p.Twice(), p.Add(p), "Twice and Add inconsistent");
+ Assert.AreEqual(p, p.Twice().Subtract(p), "Twice p - p is not p");
+ Assert.AreEqual(infinity, p.Subtract(p), "p - p is not infinity");
+ Assert.AreEqual(p, p.Add(infinity), "p plus infinity is not p");
+ Assert.AreEqual(p, infinity.Add(p), "infinity plus p is not p");
+ Assert.AreEqual(infinity, infinity.Add(infinity), "infinity plus infinity is not infinity ");
+ }
+
+ /**
+ * Calls <code>implTestAddSubtract()</code> for literature values, both
+ * for <code>Fp</code> and <code>F2m</code>.
+ */
+ [Test]
+ public void TestAddSubtractMultiplySimple()
+ {
+ for (int iFp = 0; iFp < Fp.pointSource.Length / 2; iFp++)
+ {
+ implTestAddSubtract(Fp.p[iFp], Fp.infinity);
+
+ // Could be any numBits, 6 is chosen at will
+ implTestMultiplyAll(Fp.p[iFp], 6);
+ implTestMultiplyAll(Fp.infinity, 6);
+ }
+
+ for (int iF2m = 0; iF2m < F2m.pointSource.Length / 2; iF2m++)
+ {
+ implTestAddSubtract(F2m.p[iF2m], F2m.infinity);
+
+ // Could be any numBits, 6 is chosen at will
+ implTestMultiplyAll(F2m.p[iF2m], 6);
+ implTestMultiplyAll(F2m.infinity, 6);
+ }
+ }
+
+ /**
+ * Test encoding with and without point compression.
+ *
+ * @param p
+ * The point to be encoded and decoded.
+ */
+ private void implTestEncoding(ECPoint p)
+ {
+ // Not Point Compression
+ ECPoint unCompP;
+
+ // Point compression
+ ECPoint compP;
+
+ if (p is FpPoint)
+ {
+ unCompP = new FpPoint(p.Curve, p.X, p.Y, false);
+ compP = new FpPoint(p.Curve, p.X, p.Y, true);
+ }
+ else
+ {
+ unCompP = new F2mPoint(p.Curve, p.X, p.Y, false);
+ compP = new F2mPoint(p.Curve, p.X, p.Y, true);
+ }
+
+ byte[] unCompBarr = unCompP.GetEncoded();
+ ECPoint decUnComp = p.Curve.DecodePoint(unCompBarr);
+ Assert.AreEqual(p, decUnComp, "Error decoding uncompressed point");
+
+ byte[] compBarr = compP.GetEncoded();
+ ECPoint decComp = p.Curve.DecodePoint(compBarr);
+ Assert.AreEqual(p, decComp, "Error decoding compressed point");
+ }
+
+ /**
+ * Calls <code>implTestAddSubtract()</code>,
+ * <code>implTestMultiply</code> and <code>implTestEncoding</code> for
+ * the standard elliptic curves as given in <code>SecNamedCurves</code>.
+ */
+ [Test]
+ public void TestAddSubtractMultiplyTwiceEncoding()
+ {
+ foreach (string name in SecNamedCurves.Names)
+ {
+ X9ECParameters x9ECParameters = SecNamedCurves.GetByName(name);
+
+ BigInteger n = x9ECParameters.N;
+
+ // The generator is multiplied by random b to get random q
+ BigInteger b = new BigInteger(n.BitLength, secRand);
+ ECPoint g = x9ECParameters.G;
+ ECPoint q = g.Multiply(b);
+
+ // Get point at infinity on the curve
+ ECPoint infinity = x9ECParameters.Curve.Infinity;
+
+ implTestAddSubtract(q, infinity);
+ implTestMultiply(q, n.BitLength);
+ implTestMultiply(infinity, n.BitLength);
+ implTestEncoding(q);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/crypto/test/src/math/ec/test/F2mProofer.cs b/crypto/test/src/math/ec/test/F2mProofer.cs
new file mode 100644
index 000000000..88e868c34
--- /dev/null
+++ b/crypto/test/src/math/ec/test/F2mProofer.cs
@@ -0,0 +1,201 @@
+// TODO Need a replacement for the Java properties class to finish this class
+
+//using System;
+//using System.IO;
+//using System.Text;
+//
+//using Org.BouncyCastle.Asn1.Sec;
+//using Org.BouncyCastle.Asn1.X9;
+//using Org.BouncyCastle.Math.EC;
+//using Org.BouncyCastle.Security;
+//
+//namespace Org.BouncyCastle.Math.EC.Tests
+//{
+// public class F2mProofer
+// {
+// private const int NUM_SAMPLES = 1000;
+//
+// private static readonly string PATH = "crypto/test/src/org/bouncycastle/math/ec/test/samples/";
+//
+// private static readonly string INPUT_FILE_NAME_PREFIX = "Input_";
+//
+// private static readonly string RESULT_FILE_NAME_PREFIX = "Output_";
+//
+// /**
+// * The standard curves on which the tests are done
+// */
+// public static readonly string[] Curves = { "sect163r2", "sect233r1",
+// "sect283r1", "sect409r1", "sect571r1" };
+//
+// private string pointToString(F2mPoint p)
+// {
+// F2mFieldElement x = (F2mFieldElement) p.X;
+// F2mFieldElement y = (F2mFieldElement) p.Y;
+//
+// int m = x.M;
+// int len = m / 2 + 5;
+//
+// StringBuilder sb = new StringBuilder(len);
+// sb.Append('(');
+// sb.Append(x.ToBigInteger().ToString(16));
+// sb.Append(", ");
+// sb.Append(y.ToBigInteger().ToString(16));
+// sb.Append(')');
+//
+// return sb.ToString();
+// }
+//
+// private void generateRandomInput(X9ECParameters x9ECParameters)
+// {
+// F2mPoint g = (F2mPoint) x9ECParameters.G;
+// int m = ((F2mFieldElement) g.X).M;
+//
+// SecureRandom secRand = new SecureRandom(); //SecureRandom.GetInstance("SHA1PRNG");
+// Properties inputProps = new Properties();
+// for (int i = 0; i < NUM_SAMPLES; i++)
+// {
+// BigInteger rand = new BigInteger(m, secRand);
+// inputProps.put(i.ToString(), rand.ToString(16));
+// }
+// string bits = m.ToString();
+// FileStream fos = File.Create(PATH
+// + INPUT_FILE_NAME_PREFIX + bits + ".properties");
+// inputProps.store(fos, "Input Samples of length" + bits);
+// fos.Close();
+// }
+//
+// private void multiplyPoints(X9ECParameters x9ECParameters,
+// string classPrefix)
+// {
+// F2mPoint g = (F2mPoint) x9ECParameters.G;
+// int m = ((F2mFieldElement) g.X).M;
+//
+// string inputFileName = PATH + INPUT_FILE_NAME_PREFIX + m
+// + ".properties";
+// Properties inputProps = new Properties();
+// FileStream fis = File.OpenRead(inputFileName);
+// inputProps.load(fis);
+// fis.Close();
+//
+// Properties outputProps = new Properties();
+//
+// for (int i = 0; i < NUM_SAMPLES; i++)
+// {
+// BigInteger rand = new BigInteger(inputProps.getProperty(Integer
+// .ToString(i)), 16);
+// F2mPoint result = (F2mPoint) g.Multiply(rand);
+// string resultStr = pointToString(result);
+// outputProps.setProperty(i.ToString(), resultStr);
+// }
+//
+// string outputFileName = PATH + RESULT_FILE_NAME_PREFIX + classPrefix
+// + "_" + m + ".properties";
+// FileStream fos = File.Create(outputFileName);
+// outputProps.store(fos, "Output Samples of length" + m);
+// fos.Close();
+// }
+//
+// private Properties loadResults(string classPrefix, int m)
+// {
+// FileStream fis = File.OpenRead(PATH
+// + RESULT_FILE_NAME_PREFIX + classPrefix + "_" + m + ".properties");
+// Properties res = new Properties();
+// res.load(fis);
+// fis.Close();
+// return res;
+// }
+//
+// private void compareResult(X9ECParameters x9ECParameters,
+// string classPrefix1, string classPrefix2)
+// {
+// F2mPoint g = (F2mPoint) x9ECParameters.G;
+// int m = ((F2mFieldElement) g.X).M;
+//
+// Properties res1 = loadResults(classPrefix1, m);
+// Properties res2 = loadResults(classPrefix2, m);
+//
+// Set keys = res1.keySet();
+// Iterator iter = keys.iterator();
+// while (iter.hasNext())
+// {
+// string key = (string) iter.next();
+// string result1 = res1.getProperty(key);
+// string result2 = res2.getProperty(key);
+// if (!(result1.Equals(result2)))
+// {
+// Console.Error.WriteLine("Difference found: m = " + m + ", "
+// + result1 + " does not equal " + result2);
+// }
+// }
+//
+// }
+//
+// private static void usage()
+// {
+// Console.Error.WriteLine("Usage: F2mProofer [-init | -Multiply <className> "
+// + "| -compare <className1> <className2>]");
+// }
+//
+// public static void Main(string[] args)
+// {
+// if (args.Length == 0)
+// {
+// usage();
+// return;
+// }
+// F2mProofer proofer = new F2mProofer();
+// if (args[0].Equals("-init"))
+// {
+// Console.WriteLine("Generating random input...");
+// for (int i = 0; i < Curves.Length; i++)
+// {
+// X9ECParameters x9ECParameters = SecNamedCurves
+// .GetByName(Curves[i]);
+// proofer.generateRandomInput(x9ECParameters);
+// }
+// Console.WriteLine("Successfully generated random input in " + PATH);
+// }
+// else if (args[0].Equals("-compare"))
+// {
+// if (args.Length < 3)
+// {
+// usage();
+// return;
+// }
+// string classPrefix1 = args[1];
+// string classPrefix2 = args[2];
+// Console.WriteLine("Comparing results...");
+// for (int i = 0; i < Curves.Length; i++)
+// {
+// X9ECParameters x9ECParameters = SecNamedCurves
+// .GetByName(Curves[i]);
+// proofer.compareResult(x9ECParameters, classPrefix1,
+// classPrefix2);
+// }
+// Console.WriteLine("Successfully compared results in " + PATH);
+// }
+// else if (args[0].Equals("-Multiply"))
+// {
+// if (args.Length < 2)
+// {
+// usage();
+// return;
+// }
+// string classPrefix = args[1];
+// Console.WriteLine("Multiplying points...");
+// for (int i = 0; i < Curves.Length; i++)
+// {
+// X9ECParameters x9ECParameters = SecNamedCurves
+// .GetByName(Curves[i]);
+// proofer.multiplyPoints(x9ECParameters, classPrefix);
+// }
+// Console.WriteLine("Successfully generated multiplied points in "
+// + PATH);
+// }
+// else
+// {
+// usage();
+// }
+// }
+// }
+//}
diff --git a/crypto/test/src/math/ec/test/TnafTest.cs b/crypto/test/src/math/ec/test/TnafTest.cs
new file mode 100644
index 000000000..c04ae00d2
--- /dev/null
+++ b/crypto/test/src/math/ec/test/TnafTest.cs
@@ -0,0 +1,158 @@
+//using System;
+//using System.Text;
+//
+//using NUnit.Framework;
+//
+//using Org.BouncyCastle.Asn1.Sec;
+//using Org.BouncyCastle.Asn1.X9;
+//using Org.BouncyCastle.Math.EC.Multiplier;
+//using Org.BouncyCastle.Utilities.Date;
+//
+//namespace Org.BouncyCastle.Math.EC.Tests
+//{
+// [TestFixture, Explicit]
+// public class TnafTest
+// {
+// private Random m_rand = new Random();
+//
+// private string ecPointToString(
+// ECPoint p)
+// {
+// StringBuilder sb = new StringBuilder("x = ");
+// sb.Append(p.X.ToBigInteger().ToString());
+// sb.Append("; y = ");
+// sb.Append(p.Y.ToBigInteger().ToString());
+// return sb.ToString();
+// }
+//
+// private ECPoint repeatedMultiply(ECPoint p, BigInteger k)
+// {
+// ECPoint result = p.Multiply(k);
+// for (int i = 1; i < 10; ++i)
+// {
+// ECPoint check = p.Multiply(k);
+// Assert.AreEqual(result, check);
+// }
+// return result;
+// }
+//
+// private void ImplTestMultiplyTnaf(string curveName)
+// {
+// X9ECParameters x9ECParameters = SecNamedCurves.GetByName(curveName);
+//
+// F2mCurve curve = (F2mCurve)x9ECParameters.Curve;
+// BigInteger n = curve.N;
+//
+// // The generator is multiplied by random b to get random q
+// BigInteger b = new BigInteger(n.BitLength, m_rand);
+// ECPoint g = x9ECParameters.G;
+// F2mPoint p = (F2mPoint) g.Multiply(b);
+//
+// BigInteger k = new BigInteger(n.BitLength, m_rand);
+// long now1 = DateTimeUtilities.CurrentUnixMs();
+// p.SetECMultiplier(new WTauNafMultiplier());
+// ECPoint refRWTnaf = repeatedMultiply(p, k);
+// long now2 = DateTimeUtilities.CurrentUnixMs();
+// p.SetECMultiplier(new WNafMultiplier());
+// ECPoint refWnaf = repeatedMultiply(p, k);
+// long now3 = DateTimeUtilities.CurrentUnixMs();
+// p.SetECMultiplier(new FpNafMultiplier());
+// ECPoint refFpNaf = repeatedMultiply(p, k);
+// long now4 = DateTimeUtilities.CurrentUnixMs();
+// p.SetECMultiplier(new ReferenceMultiplier());
+// ECPoint reference = repeatedMultiply(p, k);
+// long now5 = DateTimeUtilities.CurrentUnixMs();
+//
+// Assert.AreEqual(reference, refRWTnaf, "WTNAF multiplication is incorrect");
+// Assert.AreEqual(reference, refFpNaf, "FPNAF multiplication is incorrect");
+// Assert.AreEqual(reference, refWnaf, "WNAF multiplication is incorrect");
+//
+// Console.WriteLine(curveName + ": Multiply WTNAF took millis: " + (now2 - now1));
+// Console.WriteLine(curveName + ": Multiply WNAF took millis: " + (now3 - now2));
+// Console.WriteLine(curveName + ": Multiply FPNAF took millis: " + (now4 - now3));
+// Console.WriteLine(curveName + ": Multiply REFE took millis: " + (now5 - now4));
+//
+//// Console.WriteLine(curveName + ": refRWTnaf = " + ecPointToString(refRWTnaf));
+//// Console.WriteLine(curveName + ": refWnaf = " + ecPointToString(refWnaf));
+//// Console.WriteLine(curveName + ": refFpNaf = " + ecPointToString(refFpNaf));
+//// Console.WriteLine(curveName + ": reference = " + ecPointToString(reference) + "\n");
+// Console.WriteLine();
+// }
+//
+// [Test]
+// public void TestMultiplyTnaf()
+// {
+// Console.WriteLine("\n\n\n***** Start test multiplications on F2m (Koblitz) *****");
+// ImplTestMultiplyTnaf("sect163k1");
+// ImplTestMultiplyTnaf("sect233k1");
+// ImplTestMultiplyTnaf("sect239k1");
+// ImplTestMultiplyTnaf("sect283k1");
+// ImplTestMultiplyTnaf("sect409k1");
+// ImplTestMultiplyTnaf("sect571k1");
+// }
+//
+// private void ImplTestMultiplyWnaf(String curveName)
+// {
+// X9ECParameters x9ECParameters = SecNamedCurves.GetByName(curveName);
+//
+// BigInteger r = x9ECParameters.N;
+//
+// // The generator is multiplied by random b to get random q
+// BigInteger b = new BigInteger(r.BitLength, m_rand);
+// ECPoint g = x9ECParameters.G;
+// ECPoint p = g.Multiply(b);
+//
+// BigInteger k = new BigInteger(r.BitLength, m_rand);
+// long now1 = DateTimeUtilities.CurrentUnixMs();
+// p.SetECMultiplier(new WNafMultiplier());
+// ECPoint refWnaf = repeatedMultiply(p, k);
+// long now2 = DateTimeUtilities.CurrentUnixMs();
+// p.SetECMultiplier(new FpNafMultiplier());
+// ECPoint refFpNaf = repeatedMultiply(p, k);
+// long now3 = DateTimeUtilities.CurrentUnixMs();
+// p.SetECMultiplier(new ReferenceMultiplier());
+// ECPoint reference = repeatedMultiply(p, k);
+// long now4 = DateTimeUtilities.CurrentUnixMs();
+//
+// Assert.AreEqual(reference, refWnaf, "WNAF multiplication is incorrect");
+// Assert.AreEqual(reference, refFpNaf, "FPNAF multiplication is incorrect");
+//
+// Console.WriteLine(curveName + ": Multiply WNAF took millis: " + (now2 - now1));
+// Console.WriteLine(curveName + ": Multiply FPNAF took millis: " + (now3 - now2));
+// Console.WriteLine(curveName + ": Multiply REFE took millis: " + (now4 - now3));
+//
+//// Console.WriteLine(curveName + ": refWnaf = " + ecPointToString(refWnaf));
+//// Console.WriteLine(curveName + ": refFpNaf = " + ecPointToString(refFpNaf));
+//// Console.WriteLine(curveName + ": reference = " + ecPointToString(reference));
+// Console.WriteLine();
+// }
+//
+// [Test]
+// public void TestMultiplyWnaf()
+// {
+// Console.WriteLine("\n\n\n***** Start test multiplications on F2m *****");
+// ImplTestMultiplyWnaf("sect113r1");
+// ImplTestMultiplyWnaf("sect113r2");
+// ImplTestMultiplyWnaf("sect131r1");
+// ImplTestMultiplyWnaf("sect131r2");
+// ImplTestMultiplyWnaf("sect163r1");
+// ImplTestMultiplyWnaf("sect163r2");
+// ImplTestMultiplyWnaf("sect193r1");
+// ImplTestMultiplyWnaf("sect193r2");
+// ImplTestMultiplyWnaf("sect233r1");
+// ImplTestMultiplyWnaf("sect283r1");
+// ImplTestMultiplyWnaf("sect409r1");
+// ImplTestMultiplyWnaf("sect571r1");
+//
+// Console.WriteLine("\n\n\n***** Start test multiplications on Fp *****");
+// ImplTestMultiplyWnaf("secp112r1");
+// ImplTestMultiplyWnaf("secp128r1");
+// ImplTestMultiplyWnaf("secp160r1");
+// ImplTestMultiplyWnaf("secp192r1");
+// ImplTestMultiplyWnaf("secp224r1");
+// ImplTestMultiplyWnaf("secp256r1");
+// ImplTestMultiplyWnaf("secp384r1");
+// ImplTestMultiplyWnaf("secp521r1");
+// }
+// }
+//}
diff --git a/crypto/test/src/math/test/AllTests.cs b/crypto/test/src/math/test/AllTests.cs
new file mode 100644
index 000000000..6f2b50140
--- /dev/null
+++ b/crypto/test/src/math/test/AllTests.cs
@@ -0,0 +1,27 @@
+using System;
+
+using NUnit.Core;
+using NUnit.Framework;
+
+namespace Org.BouncyCastle.Math.Tests
+{
+ public class AllTests
+ {
+ public static void Main(
+ string[] args)
+ {
+// junit.textui.TestRunner.run(suite());
+ EventListener el = new NullListener();
+ suite().Run(el);
+ }
+
+ public static TestSuite suite()
+ {
+ TestSuite suite = new TestSuite("Math tests");
+
+ suite.Add(new BigIntegerTest());
+
+ return suite;
+ }
+ }
+}
diff --git a/crypto/test/src/math/test/BigIntegerTest.cs b/crypto/test/src/math/test/BigIntegerTest.cs
new file mode 100644
index 000000000..2f66a4b59
--- /dev/null
+++ b/crypto/test/src/math/test/BigIntegerTest.cs
@@ -0,0 +1,1048 @@
+using System;
+
+using NUnit.Framework;
+
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Math.Tests
+{
+ [TestFixture]
+ public class BigIntegerTest
+ {
+ private static Random random = new Random();
+
+ [Test]
+ public void MonoBug81857()
+ {
+ BigInteger b = new BigInteger("18446744073709551616");
+ BigInteger exp = BigInteger.Two;
+ BigInteger mod = new BigInteger("48112959837082048697");
+ BigInteger expected = new BigInteger("4970597831480284165");
+
+ BigInteger manual = b.Multiply(b).Mod(mod);
+ Assert.AreEqual(expected, manual, "b * b % mod");
+ }
+
+ [Test]
+ public void TestAbs()
+ {
+ Assert.AreEqual(zero, zero.Abs());
+
+ Assert.AreEqual(one, one.Abs());
+ Assert.AreEqual(one, minusOne.Abs());
+
+ Assert.AreEqual(two, two.Abs());
+ Assert.AreEqual(two, minusTwo.Abs());
+ }
+
+ [Test]
+ public void TestAdd()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(
+ val(i + j),
+ val(i).Add(val(j)),
+ "Problem: " + i + ".Add(" + j + ") should be " + (i + j));
+ }
+ }
+ }
+
+ [Test]
+ public void TestAnd()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(
+ val(i & j),
+ val(i).And(val(j)),
+ "Problem: " + i + " AND " + j + " should be " + (i & j));
+ }
+ }
+ }
+
+ [Test]
+ public void TestAndNot()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(
+ val(i & ~j),
+ val(i).AndNot(val(j)),
+ "Problem: " + i + " AND NOT " + j + " should be " + (i & ~j));
+ }
+ }
+ }
+
+ [Test]
+ public void TestBitCount()
+ {
+ Assert.AreEqual(0, zero.BitCount);
+ Assert.AreEqual(1, one.BitCount);
+ Assert.AreEqual(0, minusOne.BitCount);
+ Assert.AreEqual(1, two.BitCount);
+ Assert.AreEqual(1, minusTwo.BitCount);
+
+ for (int i = 0; i < 100; ++i)
+ {
+ BigInteger pow2 = one.ShiftLeft(i);
+
+ Assert.AreEqual(1, pow2.BitCount);
+ Assert.AreEqual(i, pow2.Negate().BitCount);
+ }
+
+ for (int i = 0; i < 10; ++i)
+ {
+ BigInteger test = new BigInteger(128, 0, random);
+ int bitCount = 0;
+
+ for (int bit = 0; bit < test.BitLength; ++bit)
+ {
+ if (test.TestBit(bit))
+ {
+ ++bitCount;
+ }
+ }
+
+ Assert.AreEqual(bitCount, test.BitCount);
+ }
+ }
+
+ [Test]
+ public void TestBitLength()
+ {
+ Assert.AreEqual(0, zero.BitLength);
+ Assert.AreEqual(1, one.BitLength);
+ Assert.AreEqual(0, minusOne.BitLength);
+ Assert.AreEqual(2, two.BitLength);
+ Assert.AreEqual(1, minusTwo.BitLength);
+
+ for (int i = 0; i < 100; ++i)
+ {
+ int bit = i + random.Next(64);
+ BigInteger odd = new BigInteger(bit, random).SetBit(bit + 1).SetBit(0);
+ BigInteger pow2 = one.ShiftLeft(bit);
+
+ Assert.AreEqual(bit + 2, odd.BitLength);
+ Assert.AreEqual(bit + 2, odd.Negate().BitLength);
+ Assert.AreEqual(bit + 1, pow2.BitLength);
+ Assert.AreEqual(bit, pow2.Negate().BitLength);
+ }
+ }
+
+ [Test]
+ public void TestClearBit()
+ {
+ Assert.AreEqual(zero, zero.ClearBit(0));
+ Assert.AreEqual(zero, one.ClearBit(0));
+ Assert.AreEqual(two, two.ClearBit(0));
+
+ Assert.AreEqual(zero, zero.ClearBit(1));
+ Assert.AreEqual(one, one.ClearBit(1));
+ Assert.AreEqual(zero, two.ClearBit(1));
+
+ // TODO Tests for clearing bits in negative numbers
+
+ // TODO Tests for clearing extended bits
+
+ for (int i = 0; i < 10; ++i)
+ {
+ BigInteger n = new BigInteger(128, random);
+
+ for (int j = 0; j < 10; ++j)
+ {
+ int pos = random.Next(128);
+ BigInteger m = n.ClearBit(pos);
+ bool test = m.ShiftRight(pos).Remainder(two).Equals(one);
+
+ Assert.IsFalse(test);
+ }
+ }
+
+ for (int i = 0; i < 100; ++i)
+ {
+ BigInteger pow2 = one.ShiftLeft(i);
+ BigInteger minusPow2 = pow2.Negate();
+
+ Assert.AreEqual(zero, pow2.ClearBit(i));
+ Assert.AreEqual(minusPow2.ShiftLeft(1), minusPow2.ClearBit(i));
+
+ BigInteger bigI = BigInteger.ValueOf(i);
+ BigInteger negI = bigI.Negate();
+
+ for (int j = 0; j < 10; ++j)
+ {
+ string data = "i=" + i + ", j=" + j;
+ Assert.AreEqual(bigI.AndNot(one.ShiftLeft(j)), bigI.ClearBit(j), data);
+ Assert.AreEqual(negI.AndNot(one.ShiftLeft(j)), negI.ClearBit(j), data);
+ }
+ }
+ }
+
+ [Test]
+ public void TestCompareTo()
+ {
+ Assert.AreEqual(0, minusTwo.CompareTo(minusTwo));
+ Assert.AreEqual(-1, minusTwo.CompareTo(minusOne));
+ Assert.AreEqual(-1, minusTwo.CompareTo(zero));
+ Assert.AreEqual(-1, minusTwo.CompareTo(one));
+ Assert.AreEqual(-1, minusTwo.CompareTo(two));
+
+ Assert.AreEqual(1, minusOne.CompareTo(minusTwo));
+ Assert.AreEqual(0, minusOne.CompareTo(minusOne));
+ Assert.AreEqual(-1, minusOne.CompareTo(zero));
+ Assert.AreEqual(-1, minusOne.CompareTo(one));
+ Assert.AreEqual(-1, minusOne.CompareTo(two));
+
+ Assert.AreEqual(1, zero.CompareTo(minusTwo));
+ Assert.AreEqual(1, zero.CompareTo(minusOne));
+ Assert.AreEqual(0, zero.CompareTo(zero));
+ Assert.AreEqual(-1, zero.CompareTo(one));
+ Assert.AreEqual(-1, zero.CompareTo(two));
+
+ Assert.AreEqual(1, one.CompareTo(minusTwo));
+ Assert.AreEqual(1, one.CompareTo(minusOne));
+ Assert.AreEqual(1, one.CompareTo(zero));
+ Assert.AreEqual(0, one.CompareTo(one));
+ Assert.AreEqual(-1, one.CompareTo(two));
+
+ Assert.AreEqual(1, two.CompareTo(minusTwo));
+ Assert.AreEqual(1, two.CompareTo(minusOne));
+ Assert.AreEqual(1, two.CompareTo(zero));
+ Assert.AreEqual(1, two.CompareTo(one));
+ Assert.AreEqual(0, two.CompareTo(two));
+ }
+
+ [Test]
+ public void TestConstructors()
+ {
+ Assert.AreEqual(BigInteger.Zero, new BigInteger(new byte[]{ 0 }));
+ Assert.AreEqual(BigInteger.Zero, new BigInteger(new byte[]{ 0, 0 }));
+
+ for (int i = 0; i < 10; ++i)
+ {
+ Assert.IsTrue(new BigInteger(i + 3, 0, random).TestBit(0));
+ }
+
+ // TODO Other constructors
+ }
+
+ [Test]
+ public void TestDivide()
+ {
+ for (int i = -5; i <= 5; ++i)
+ {
+ try
+ {
+ val(i).Divide(zero);
+ Assert.Fail("expected ArithmeticException");
+ }
+ catch (ArithmeticException) {}
+ }
+
+ int product = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9;
+ int productPlus = product + 1;
+
+ BigInteger bigProduct = val(product);
+ BigInteger bigProductPlus = val(productPlus);
+
+ for (int divisor = 1; divisor < 10; ++divisor)
+ {
+ // Exact division
+ BigInteger expected = val(product / divisor);
+
+ Assert.AreEqual(expected, bigProduct.Divide(val(divisor)));
+ Assert.AreEqual(expected.Negate(), bigProduct.Negate().Divide(val(divisor)));
+ Assert.AreEqual(expected.Negate(), bigProduct.Divide(val(divisor).Negate()));
+ Assert.AreEqual(expected, bigProduct.Negate().Divide(val(divisor).Negate()));
+
+ expected = val((product + 1)/divisor);
+
+ Assert.AreEqual(expected, bigProductPlus.Divide(val(divisor)));
+ Assert.AreEqual(expected.Negate(), bigProductPlus.Negate().Divide(val(divisor)));
+ Assert.AreEqual(expected.Negate(), bigProductPlus.Divide(val(divisor).Negate()));
+ Assert.AreEqual(expected, bigProductPlus.Negate().Divide(val(divisor).Negate()));
+ }
+
+ for (int rep = 0; rep < 10; ++rep)
+ {
+ BigInteger a = new BigInteger(100 - rep, 0, random);
+ BigInteger b = new BigInteger(100 + rep, 0, random);
+ BigInteger c = new BigInteger(10 + rep, 0, random);
+ BigInteger d = a.Multiply(b).Add(c);
+ BigInteger e = d.Divide(a);
+
+ Assert.AreEqual(b, e);
+ }
+
+ // Special tests for power of two since uses different code path internally
+ for (int i = 0; i < 100; ++i)
+ {
+ int shift = random.Next(64);
+ BigInteger a = one.ShiftLeft(shift);
+ BigInteger b = new BigInteger(64 + random.Next(64), random);
+ BigInteger bShift = b.ShiftRight(shift);
+
+ string data = "shift=" + shift +", b=" + b.ToString(16);
+
+ Assert.AreEqual(bShift, b.Divide(a), data);
+ Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
+ Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
+ Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
+ }
+
+ // Regression
+ {
+ int shift = 63;
+ BigInteger a = one.ShiftLeft(shift);
+ BigInteger b = new BigInteger(1, Hex.Decode("2504b470dc188499"));
+ BigInteger bShift = b.ShiftRight(shift);
+
+ string data = "shift=" + shift +", b=" + b.ToString(16);
+
+ Assert.AreEqual(bShift, b.Divide(a), data);
+ Assert.AreEqual(bShift.Negate(), b.Divide(a.Negate()), data);
+// Assert.AreEqual(bShift.Negate(), b.Negate().Divide(a), data);
+ Assert.AreEqual(bShift, b.Negate().Divide(a.Negate()), data);
+ }
+ }
+
+ [Test]
+ public void TestDivideAndRemainder()
+ {
+ // TODO More basic tests
+
+ BigInteger n = new BigInteger(48, random);
+ BigInteger[] qr = n.DivideAndRemainder(n);
+ Assert.AreEqual(one, qr[0]);
+ Assert.AreEqual(zero, qr[1]);
+ qr = n.DivideAndRemainder(one);
+ Assert.AreEqual(n, qr[0]);
+ Assert.AreEqual(zero, qr[1]);
+
+ for (int rep = 0; rep < 10; ++rep)
+ {
+ BigInteger a = new BigInteger(100 - rep, 0, random);
+ BigInteger b = new BigInteger(100 + rep, 0, random);
+ BigInteger c = new BigInteger(10 + rep, 0, random);
+ BigInteger d = a.Multiply(b).Add(c);
+ BigInteger[] es = d.DivideAndRemainder(a);
+
+ Assert.AreEqual(b, es[0]);
+ Assert.AreEqual(c, es[1]);
+ }
+
+ // Special tests for power of two since uses different code path internally
+ for (int i = 0; i < 100; ++i)
+ {
+ int shift = random.Next(64);
+ BigInteger a = one.ShiftLeft(shift);
+ BigInteger b = new BigInteger(64 + random.Next(64), random);
+ BigInteger bShift = b.ShiftRight(shift);
+ BigInteger bMod = b.And(a.Subtract(one));
+
+ string data = "shift=" + shift +", b=" + b.ToString(16);
+
+ qr = b.DivideAndRemainder(a);
+ Assert.AreEqual(bShift, qr[0], data);
+ Assert.AreEqual(bMod, qr[1], data);
+
+ qr = b.DivideAndRemainder(a.Negate());
+ Assert.AreEqual(bShift.Negate(), qr[0], data);
+ Assert.AreEqual(bMod, qr[1], data);
+
+ qr = b.Negate().DivideAndRemainder(a);
+ Assert.AreEqual(bShift.Negate(), qr[0], data);
+ Assert.AreEqual(bMod.Negate(), qr[1], data);
+
+ qr = b.Negate().DivideAndRemainder(a.Negate());
+ Assert.AreEqual(bShift, qr[0], data);
+ Assert.AreEqual(bMod.Negate(), qr[1], data);
+ }
+ }
+
+ [Test]
+ public void TestFlipBit()
+ {
+ for (int i = 0; i < 10; ++i)
+ {
+ BigInteger a = new BigInteger(128, 0, random);
+ BigInteger b = a;
+
+ for (int x = 0; x < 100; ++x)
+ {
+ // Note: Intentionally greater than initial size
+ int pos = random.Next(256);
+
+ a = a.FlipBit(pos);
+ b = b.TestBit(pos) ? b.ClearBit(pos) : b.SetBit(pos);
+ }
+
+ Assert.AreEqual(a, b);
+ }
+
+ for (int i = 0; i < 100; ++i)
+ {
+ BigInteger pow2 = one.ShiftLeft(i);
+ BigInteger minusPow2 = pow2.Negate();
+
+ Assert.AreEqual(zero, pow2.FlipBit(i));
+ Assert.AreEqual(minusPow2.ShiftLeft(1), minusPow2.FlipBit(i));
+
+ BigInteger bigI = BigInteger.ValueOf(i);
+ BigInteger negI = bigI.Negate();
+
+ for (int j = 0; j < 10; ++j)
+ {
+ string data = "i=" + i + ", j=" + j;
+ Assert.AreEqual(bigI.Xor(one.ShiftLeft(j)), bigI.FlipBit(j), data);
+ Assert.AreEqual(negI.Xor(one.ShiftLeft(j)), negI.FlipBit(j), data);
+ }
+ }
+ }
+
+ [Test]
+ public void TestGcd()
+ {
+ for (int i = 0; i < 10; ++i)
+ {
+ BigInteger fac = new BigInteger(32, random).Add(two);
+ BigInteger p1 = BigInteger.ProbablePrime(63, random);
+ BigInteger p2 = BigInteger.ProbablePrime(64, random);
+
+ BigInteger gcd = fac.Multiply(p1).Gcd(fac.Multiply(p2));
+
+ Assert.AreEqual(fac, gcd);
+ }
+ }
+
+ [Test]
+ public void TestGetLowestSetBit()
+ {
+ for (int i = 1; i <= 100; ++i)
+ {
+ BigInteger test = new BigInteger(i + 1, 0, random).Add(one);
+ int bit1 = test.GetLowestSetBit();
+ Assert.AreEqual(test, test.ShiftRight(bit1).ShiftLeft(bit1));
+ int bit2 = test.ShiftLeft(i + 1).GetLowestSetBit();
+ Assert.AreEqual(i + 1, bit2 - bit1);
+ int bit3 = test.ShiftLeft(3 * i).GetLowestSetBit();
+ Assert.AreEqual(3 * i, bit3 - bit1);
+ }
+ }
+
+ [Test]
+ public void TestIntValue()
+ {
+ int[] tests = new int[]{ int.MinValue, -1234, -10, -1, 0, ~0, 1, 10, 5678, int.MaxValue };
+
+ foreach (int test in tests)
+ {
+ Assert.AreEqual(test, val(test).IntValue);
+ }
+
+ // TODO Tests for large numbers
+ }
+
+ [Test]
+ public void TestIsProbablePrime()
+ {
+ Assert.IsFalse(zero.IsProbablePrime(100));
+ Assert.IsFalse(zero.IsProbablePrime(100));
+ Assert.IsTrue(zero.IsProbablePrime(0));
+ Assert.IsTrue(zero.IsProbablePrime(-10));
+ Assert.IsFalse(minusOne.IsProbablePrime(100));
+ Assert.IsTrue(minusTwo.IsProbablePrime(100));
+ Assert.IsTrue(val(-17).IsProbablePrime(100));
+ Assert.IsTrue(val(67).IsProbablePrime(100));
+ Assert.IsTrue(val(773).IsProbablePrime(100));
+
+ foreach (int p in firstPrimes)
+ {
+ Assert.IsTrue(val(p).IsProbablePrime(100));
+ Assert.IsTrue(val(-p).IsProbablePrime(100));
+ }
+
+ foreach (int c in nonPrimes)
+ {
+ Assert.IsFalse(val(c).IsProbablePrime(100));
+ Assert.IsFalse(val(-c).IsProbablePrime(100));
+ }
+
+ foreach (int e in mersennePrimeExponents)
+ {
+ Assert.IsTrue(mersenne(e).IsProbablePrime(100));
+ Assert.IsTrue(mersenne(e).Negate().IsProbablePrime(100));
+ }
+
+ foreach (int e in nonPrimeExponents)
+ {
+ Assert.IsFalse(mersenne(e).IsProbablePrime(100));
+ Assert.IsFalse(mersenne(e).Negate().IsProbablePrime(100));
+ }
+
+ // TODO Other examples of 'tricky' values?
+ }
+
+ [Test]
+ public void TestLongValue()
+ {
+ long[] tests = new long[]{ long.MinValue, -1234, -10, -1, 0L, ~0L, 1, 10, 5678, long.MaxValue };
+
+ foreach (long test in tests)
+ {
+ Assert.AreEqual(test, val(test).LongValue);
+ }
+
+ // TODO Tests for large numbers
+ }
+
+ [Test]
+ public void TestMax()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(val(System.Math.Max(i, j)), val(i).Max(val(j)));
+ }
+ }
+ }
+
+ [Test]
+ public void TestMin()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(val(System.Math.Min(i, j)), val(i).Min(val(j)));
+ }
+ }
+ }
+
+ [Test]
+ public void TestMod()
+ {
+ // TODO Basic tests
+
+ for (int rep = 0; rep < 100; ++rep)
+ {
+ int diff = random.Next(25);
+ BigInteger a = new BigInteger(100 - diff, 0, random);
+ BigInteger b = new BigInteger(100 + diff, 0, random);
+ BigInteger c = new BigInteger(10 + diff, 0, random);
+
+ BigInteger d = a.Multiply(b).Add(c);
+ BigInteger e = d.Mod(a);
+ Assert.AreEqual(c, e);
+
+ BigInteger pow2 = one.ShiftLeft(random.Next(128));
+ Assert.AreEqual(b.And(pow2.Subtract(one)), b.Mod(pow2));
+ }
+ }
+
+ [Test]
+ public void TestModInverse()
+ {
+ for (int i = 0; i < 10; ++i)
+ {
+ BigInteger p = BigInteger.ProbablePrime(64, random);
+ BigInteger q = new BigInteger(63, random).Add(one);
+ BigInteger inv = q.ModInverse(p);
+ BigInteger inv2 = inv.ModInverse(p);
+
+ Assert.AreEqual(q, inv2);
+ Assert.AreEqual(one, q.Multiply(inv).Mod(p));
+ }
+
+ // ModInverse a power of 2 for a range of powers
+ for (int i = 1; i <= 128; ++i)
+ {
+ BigInteger m = one.ShiftLeft(i);
+ BigInteger d = new BigInteger(i, random).SetBit(0);
+ BigInteger x = d.ModInverse(m);
+ BigInteger check = x.Multiply(d).Mod(m);
+
+ Assert.AreEqual(one, check);
+ }
+ }
+
+ [Test]
+ public void TestModPow()
+ {
+ try
+ {
+ two.ModPow(one, zero);
+ Assert.Fail("expected ArithmeticException");
+ }
+ catch (ArithmeticException) {}
+
+ Assert.AreEqual(zero, zero.ModPow(zero, one));
+ Assert.AreEqual(one, zero.ModPow(zero, two));
+ Assert.AreEqual(zero, two.ModPow(one, one));
+ Assert.AreEqual(one, two.ModPow(zero, two));
+
+ for (int i = 0; i < 100; ++i)
+ {
+ BigInteger m = BigInteger.ProbablePrime(10 + i, random);
+ BigInteger x = new BigInteger(m.BitLength - 1, random);
+
+ Assert.AreEqual(x, x.ModPow(m, m));
+ if (x.SignValue != 0)
+ {
+ Assert.AreEqual(zero, zero.ModPow(x, m));
+ Assert.AreEqual(one, x.ModPow(m.Subtract(one), m));
+ }
+
+ BigInteger y = new BigInteger(m.BitLength - 1, random);
+ BigInteger n = new BigInteger(m.BitLength - 1, random);
+ BigInteger n3 = n.ModPow(three, m);
+
+ BigInteger resX = n.ModPow(x, m);
+ BigInteger resY = n.ModPow(y, m);
+ BigInteger res = resX.Multiply(resY).Mod(m);
+ BigInteger res3 = res.ModPow(three, m);
+
+ Assert.AreEqual(res3, n3.ModPow(x.Add(y), m));
+
+ BigInteger a = x.Add(one); // Make sure it's not zero
+ BigInteger b = y.Add(one); // Make sure it's not zero
+
+ Assert.AreEqual(a.ModPow(b, m).ModInverse(m), a.ModPow(b.Negate(), m));
+ }
+ }
+
+ [Test]
+ public void TestMultiply()
+ {
+ BigInteger one = BigInteger.One;
+
+ Assert.AreEqual(one, one.Negate().Multiply(one.Negate()));
+
+ for (int i = 0; i < 100; ++i)
+ {
+ int aLen = 64 + random.Next(64);
+ int bLen = 64 + random.Next(64);
+
+ BigInteger a = new BigInteger(aLen, random).SetBit(aLen);
+ BigInteger b = new BigInteger(bLen, random).SetBit(bLen);
+ BigInteger c = new BigInteger(32, random);
+
+ BigInteger ab = a.Multiply(b);
+ BigInteger bc = b.Multiply(c);
+
+ Assert.AreEqual(ab.Add(bc), a.Add(c).Multiply(b));
+ Assert.AreEqual(ab.Subtract(bc), a.Subtract(c).Multiply(b));
+ }
+
+ // Special tests for power of two since uses different code path internally
+ for (int i = 0; i < 100; ++i)
+ {
+ int shift = random.Next(64);
+ BigInteger a = one.ShiftLeft(shift);
+ BigInteger b = new BigInteger(64 + random.Next(64), random);
+ BigInteger bShift = b.ShiftLeft(shift);
+
+ Assert.AreEqual(bShift, a.Multiply(b));
+ Assert.AreEqual(bShift.Negate(), a.Multiply(b.Negate()));
+ Assert.AreEqual(bShift.Negate(), a.Negate().Multiply(b));
+ Assert.AreEqual(bShift, a.Negate().Multiply(b.Negate()));
+
+ Assert.AreEqual(bShift, b.Multiply(a));
+ Assert.AreEqual(bShift.Negate(), b.Multiply(a.Negate()));
+ Assert.AreEqual(bShift.Negate(), b.Negate().Multiply(a));
+ Assert.AreEqual(bShift, b.Negate().Multiply(a.Negate()));
+ }
+ }
+
+ [Test]
+ public void TestNegate()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ Assert.AreEqual(val(-i), val(i).Negate());
+ }
+ }
+
+ [Test]
+ public void TestNextProbablePrime()
+ {
+ BigInteger firstPrime = BigInteger.ProbablePrime(32, random);
+ BigInteger nextPrime = firstPrime.NextProbablePrime();
+
+ Assert.IsTrue(firstPrime.IsProbablePrime(10));
+ Assert.IsTrue(nextPrime.IsProbablePrime(10));
+
+ BigInteger check = firstPrime.Add(one);
+
+ while (check.CompareTo(nextPrime) < 0)
+ {
+ Assert.IsFalse(check.IsProbablePrime(10));
+ check = check.Add(one);
+ }
+ }
+
+ [Test]
+ public void TestNot()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ Assert.AreEqual(
+ val(~i),
+ val(i).Not(),
+ "Problem: ~" + i + " should be " + ~i);
+ }
+ }
+
+ [Test]
+ public void TestOr()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(
+ val(i | j),
+ val(i).Or(val(j)),
+ "Problem: " + i + " OR " + j + " should be " + (i | j));
+ }
+ }
+ }
+
+ [Test]
+ public void TestPow()
+ {
+ Assert.AreEqual(one, zero.Pow(0));
+ Assert.AreEqual(zero, zero.Pow(123));
+ Assert.AreEqual(one, one.Pow(0));
+ Assert.AreEqual(one, one.Pow(123));
+
+ Assert.AreEqual(two.Pow(147), one.ShiftLeft(147));
+ Assert.AreEqual(one.ShiftLeft(7).Pow(11), one.ShiftLeft(77));
+
+ BigInteger n = new BigInteger("1234567890987654321");
+ BigInteger result = one;
+
+ for (int i = 0; i < 10; ++i)
+ {
+ try
+ {
+ val(i).Pow(-1);
+ Assert.Fail("expected ArithmeticException");
+ }
+ catch (ArithmeticException) {}
+
+ Assert.AreEqual(result, n.Pow(i));
+
+ result = result.Multiply(n);
+ }
+ }
+
+ [Test]
+ public void TestRemainder()
+ {
+ // TODO Basic tests
+
+ for (int rep = 0; rep < 10; ++rep)
+ {
+ BigInteger a = new BigInteger(100 - rep, 0, random);
+ BigInteger b = new BigInteger(100 + rep, 0, random);
+ BigInteger c = new BigInteger(10 + rep, 0, random);
+ BigInteger d = a.Multiply(b).Add(c);
+ BigInteger e = d.Remainder(a);
+
+ Assert.AreEqual(c, e);
+ }
+ }
+
+ [Test]
+ public void TestSetBit()
+ {
+ Assert.AreEqual(one, zero.SetBit(0));
+ Assert.AreEqual(one, one.SetBit(0));
+ Assert.AreEqual(three, two.SetBit(0));
+
+ Assert.AreEqual(two, zero.SetBit(1));
+ Assert.AreEqual(three, one.SetBit(1));
+ Assert.AreEqual(two, two.SetBit(1));
+
+ // TODO Tests for setting bits in negative numbers
+
+ // TODO Tests for setting extended bits
+
+ for (int i = 0; i < 10; ++i)
+ {
+ BigInteger n = new BigInteger(128, random);
+
+ for (int j = 0; j < 10; ++j)
+ {
+ int pos = random.Next(128);
+ BigInteger m = n.SetBit(pos);
+ bool test = m.ShiftRight(pos).Remainder(two).Equals(one);
+
+ Assert.IsTrue(test);
+ }
+ }
+
+ for (int i = 0; i < 100; ++i)
+ {
+ BigInteger pow2 = one.ShiftLeft(i);
+ BigInteger minusPow2 = pow2.Negate();
+
+ Assert.AreEqual(pow2, pow2.SetBit(i));
+ Assert.AreEqual(minusPow2, minusPow2.SetBit(i));
+
+ BigInteger bigI = BigInteger.ValueOf(i);
+ BigInteger negI = bigI.Negate();
+
+ for (int j = 0; j < 10; ++j)
+ {
+ string data = "i=" + i + ", j=" + j;
+ Assert.AreEqual(bigI.Or(one.ShiftLeft(j)), bigI.SetBit(j), data);
+ Assert.AreEqual(negI.Or(one.ShiftLeft(j)), negI.SetBit(j), data);
+ }
+ }
+ }
+
+ [Test]
+ public void TestShiftLeft()
+ {
+ for (int i = 0; i < 100; ++i)
+ {
+ int shift = random.Next(128);
+
+ BigInteger a = new BigInteger(128 + i, random).Add(one);
+ int bits = a.BitCount; // Make sure nBits is set
+
+ BigInteger negA = a.Negate();
+ bits = negA.BitCount; // Make sure nBits is set
+
+ BigInteger b = a.ShiftLeft(shift);
+ BigInteger c = negA.ShiftLeft(shift);
+
+ Assert.AreEqual(a.BitCount, b.BitCount);
+ Assert.AreEqual(negA.BitCount + shift, c.BitCount);
+ Assert.AreEqual(a.BitLength + shift, b.BitLength);
+ Assert.AreEqual(negA.BitLength + shift, c.BitLength);
+
+ int j = 0;
+ for (; j < shift; ++j)
+ {
+ Assert.IsFalse(b.TestBit(j));
+ }
+
+ for (; j < b.BitLength; ++j)
+ {
+ Assert.AreEqual(a.TestBit(j - shift), b.TestBit(j));
+ }
+ }
+ }
+
+ [Test]
+ public void TestShiftRight()
+ {
+ for (int i = 0; i < 10; ++i)
+ {
+ int shift = random.Next(128);
+ BigInteger a = new BigInteger(256 + i, random).SetBit(256 + i);
+ BigInteger b = a.ShiftRight(shift);
+
+ Assert.AreEqual(a.BitLength - shift, b.BitLength);
+
+ for (int j = 0; j < b.BitLength; ++j)
+ {
+ Assert.AreEqual(a.TestBit(j + shift), b.TestBit(j));
+ }
+ }
+ }
+
+ [Test]
+ public void TestSignValue()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ Assert.AreEqual(i < 0 ? -1 : i > 0 ? 1 : 0, val(i).SignValue);
+ }
+ }
+
+ [Test]
+ public void TestSubtract()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(
+ val(i - j),
+ val(i).Subtract(val(j)),
+ "Problem: " + i + ".Subtract(" + j + ") should be " + (i - j));
+ }
+ }
+ }
+
+ [Test]
+ public void TestTestBit()
+ {
+ for (int i = 0; i < 10; ++i)
+ {
+ BigInteger n = new BigInteger(128, random);
+
+ Assert.IsFalse(n.TestBit(128));
+ Assert.IsTrue(n.Negate().TestBit(128));
+
+ for (int j = 0; j < 10; ++j)
+ {
+ int pos = random.Next(128);
+ bool test = n.ShiftRight(pos).Remainder(two).Equals(one);
+
+ Assert.AreEqual(test, n.TestBit(pos));
+ }
+ }
+ }
+
+ [Test]
+ public void TestToByteArray()
+ {
+ byte[] z = BigInteger.Zero.ToByteArray();
+ Assert.IsTrue(Arrays.AreEqual(new byte[1], z));
+
+ for (int i = 16; i <= 48; ++i)
+ {
+ BigInteger x = BigInteger.ProbablePrime(i, random);
+ byte[] b = x.ToByteArray();
+ Assert.AreEqual((i / 8 + 1), b.Length);
+ BigInteger y = new BigInteger(b);
+ Assert.AreEqual(x, y);
+
+ x = x.Negate();
+ b = x.ToByteArray();
+ Assert.AreEqual((i / 8 + 1), b.Length);
+ y = new BigInteger(b);
+ Assert.AreEqual(x, y);
+ }
+ }
+
+ [Test]
+ public void TestToByteArrayUnsigned()
+ {
+ byte[] z = BigInteger.Zero.ToByteArrayUnsigned();
+ Assert.IsTrue(Arrays.AreEqual(new byte[0], z));
+
+ for (int i = 16; i <= 48; ++i)
+ {
+ BigInteger x = BigInteger.ProbablePrime(i, random);
+ byte[] b = x.ToByteArrayUnsigned();
+ Assert.AreEqual((i + 7) / 8, b.Length);
+ BigInteger y = new BigInteger(1, b);
+ Assert.AreEqual(x, y);
+
+ x = x.Negate();
+ b = x.ToByteArrayUnsigned();
+ Assert.AreEqual(i / 8 + 1, b.Length);
+ y = new BigInteger(b);
+ Assert.AreEqual(x, y);
+ }
+ }
+
+ [Test]
+ public void TestToString()
+ {
+ string s = "12345667890987654321";
+
+ Assert.AreEqual(s, new BigInteger(s).ToString());
+ Assert.AreEqual(s, new BigInteger(s, 10).ToString(10));
+ Assert.AreEqual(s, new BigInteger(s, 16).ToString(16));
+
+ for (int i = 0; i < 100; ++i)
+ {
+ BigInteger n = new BigInteger(i, random);
+
+ Assert.AreEqual(n, new BigInteger(n.ToString(2), 2));
+ Assert.AreEqual(n, new BigInteger(n.ToString(10), 10));
+ Assert.AreEqual(n, new BigInteger(n.ToString(16), 16));
+ }
+
+ // Radix version
+ int[] radices = new int[] { 2, 8, 10, 16 };
+ int trials = 256;
+
+ BigInteger[] tests = new BigInteger[trials];
+ for (int i = 0; i < trials; ++i)
+ {
+ int len = random.Next(i + 1);
+ tests[i] = new BigInteger(len, random);
+ }
+
+ foreach (int radix in radices)
+ {
+ for (int i = 0; i < trials; ++i)
+ {
+ BigInteger n1 = tests[i];
+ string str = n1.ToString(radix);
+ BigInteger n2 = new BigInteger(str, radix);
+ Assert.AreEqual(n1, n2);
+ }
+ }
+ }
+
+ [Test]
+ public void TestValueOf()
+ {
+ Assert.AreEqual(-1, BigInteger.ValueOf(-1).SignValue);
+ Assert.AreEqual(0, BigInteger.ValueOf(0).SignValue);
+ Assert.AreEqual(1, BigInteger.ValueOf(1).SignValue);
+
+ for (long i = -5; i < 5; ++i)
+ {
+ Assert.AreEqual(i, BigInteger.ValueOf(i).IntValue);
+ }
+ }
+
+ [Test]
+ public void TestXor()
+ {
+ for (int i = -10; i <= 10; ++i)
+ {
+ for (int j = -10; j <= 10; ++j)
+ {
+ Assert.AreEqual(
+ val(i ^ j),
+ val(i).Xor(val(j)),
+ "Problem: " + i + " XOR " + j + " should be " + (i ^ j));
+ }
+ }
+ }
+
+ private static BigInteger val(long n)
+ {
+ return BigInteger.ValueOf(n);
+ }
+
+ private static BigInteger mersenne(int e)
+ {
+ return two.Pow(e).Subtract(one);
+ }
+
+ private static readonly BigInteger minusTwo = BigInteger.Two.Negate();
+ private static readonly BigInteger minusOne = BigInteger.One.Negate();
+ private static readonly BigInteger zero = BigInteger.Zero;
+ private static readonly BigInteger one = BigInteger.One;
+ private static readonly BigInteger two = BigInteger.Two;
+ private static readonly BigInteger three = BigInteger.Three;
+
+ private static int[] firstPrimes = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 };
+ private static int[] nonPrimes = { 0, 1, 4, 10, 20, 21, 22, 25, 26, 27 };
+
+ private static int[] mersennePrimeExponents = { 2, 3, 5, 7, 13, 17, 19, 31, 61, 89 };
+ private static int[] nonPrimeExponents = { 1, 4, 6, 9, 11, 15, 23, 29, 37, 41 };
+ }
+}
|
