mcs/class/System.Numerics/Test/System.Numerics/BigIntegerTest.cs

   1 // BigIntegerTest.cs
   2 //
   3 // Authors:
   4 // Rodrigo Kumpera <rkumpera@novell.com>
   5 //
   6 // Copyright (C) 2010 Novell, Inc (http://www.novell.com)
   7 //
   8
   9 using System;
  10 using System.Numerics;
  11 using System.Globalization;
  12 using System.Threading;
  13 using NUnit.Framework;
  14
  15
  16 namespace MonoTests.System.Numerics
  17 {
  18         [TestFixture]
  19         public class BigIntegerTest
  20         {
  21                 static byte[] huge_a = new byte[] {0x1D, 0x33, 0xFB, 0xFE, 0xB1, 0x2, 0x85, 0x44, 0xCA, 0xDC, 0xFB, 0x70, 0xD, 0x39, 0xB1, 0x47, 0xB6, 0xE6, 0xA2, 0xD1, 0x19, 0x1E, 0x9F, 0xE4, 0x3C, 0x1E, 0x16, 0x56, 0x13, 0x9C, 0x4D, 0xD3, 0x5C, 0x74, 0xC9, 0xBD, 0xFA, 0x56, 0x40, 0x58, 0xAC, 0x20, 0x6B, 0x55, 0xA2, 0xD5, 0x41, 0x38, 0xA4, 0x6D, 0xF6, 0x8C, };
  22
  23                 static byte[] huge_b = new byte[] {0x96, 0x5, 0xDA, 0xFE, 0x93, 0x17, 0xC1, 0x93, 0xEC, 0x2F, 0x30, 0x2D, 0x8F, 0x28, 0x13, 0x99, 0x70, 0xF4, 0x4C, 0x60, 0xA6, 0x49, 0x24, 0xF9, 0xB3, 0x4A, 0x41, 0x67, 0xDC, 0xDD, 0xB1, 0xA5, 0xA6, 0xC0, 0x3D, 0x57, 0x9A, 0xCB, 0x29, 0xE2, 0x94, 0xAC, 0x6C, 0x7D, 0xEF, 0x3E, 0xC6, 0x7A, 0xC1, 0xA8, 0xC8, 0xB0, 0x20, 0x95, 0xE6, 0x4C, 0xE1, 0xE0, 0x4B, 0x49, 0xD5, 0x5A, 0xB7, };
  24
  25                 static byte[] huge_add = new byte[] {0xB3, 0x38, 0xD5, 0xFD, 0x45, 0x1A, 0x46, 0xD8, 0xB6, 0xC, 0x2C, 0x9E, 0x9C, 0x61, 0xC4, 0xE0, 0x26, 0xDB, 0xEF, 0x31, 0xC0, 0x67, 0xC3, 0xDD, 0xF0, 0x68, 0x57, 0xBD, 0xEF, 0x79, 0xFF, 0x78, 0x3, 0x35, 0x7, 0x15, 0x95, 0x22, 0x6A, 0x3A, 0x41, 0xCD, 0xD7, 0xD2, 0x91, 0x14, 0x8, 0xB3, 0x65, 0x16, 0xBF, 0x3D, 0x20, 0x95, 0xE6, 0x4C, 0xE1, 0xE0, 0x4B, 0x49, 0xD5, 0x5A, 0xB7, };
  26
  27                 static byte[] a_m_b = new byte[] { 0x87, 0x2D, 0x21, 0x0, 0x1E, 0xEB, 0xC3, 0xB0, 0xDD, 0xAC, 0xCB, 0x43, 0x7E, 0x10, 0x9E, 0xAE, 0x45, 0xF2, 0x55, 0x71, 0x73, 0xD4, 0x7A, 0xEB, 0x88, 0xD3, 0xD4, 0xEE, 0x36, 0xBE, 0x9B, 0x2D, 0xB6, 0xB3, 0x8B, 0x66, 0x60, 0x8B, 0x16, 0x76, 0x17, 0x74, 0xFE, 0xD7, 0xB2, 0x96, 0x7B, 0xBD, 0xE2, 0xC4, 0x2D, 0xDC, 0xDE, 0x6A, 0x19, 0xB3, 0x1E, 0x1F, 0xB4, 0xB6, 0x2A, 0xA5, 0x48, };
  28                 static byte[] b_m_a = new byte[] { 0x79, 0xD2, 0xDE, 0xFF, 0xE1, 0x14, 0x3C, 0x4F, 0x22, 0x53, 0x34, 0xBC, 0x81, 0xEF, 0x61, 0x51, 0xBA, 0xD, 0xAA, 0x8E, 0x8C, 0x2B, 0x85, 0x14, 0x77, 0x2C, 0x2B, 0x11, 0xC9, 0x41, 0x64, 0xD2, 0x49, 0x4C, 0x74, 0x99, 0x9F, 0x74, 0xE9, 0x89, 0xE8, 0x8B, 0x1, 0x28, 0x4D, 0x69, 0x84, 0x42, 0x1D, 0x3B, 0xD2, 0x23, 0x21, 0x95, 0xE6, 0x4C, 0xE1, 0xE0, 0x4B, 0x49, 0xD5, 0x5A, 0xB7, };
  29
  30                 static byte[] huge_mul = new byte[] { 0xFE, 0x83, 0xE1, 0x9B, 0x8D, 0x61, 0x40, 0xD1, 0x60, 0x19, 0xBD, 0x38, 0xF0, 0xFF, 0x90, 0xAE, 0xDD, 0xAE, 0x73, 0x2C, 0x20, 0x23, 0xCF, 0x6, 0x7A, 0xB4, 0x1C, 0xE7, 0xD9, 0x64, 0x96, 0x2C, 0x87, 0x7E, 0x1D, 0xB3, 0x8F, 0xD4, 0x33, 0xBA, 0xF4, 0x22, 0xB4, 0xDB, 0xC0, 0x5B, 0xA5, 0x64, 0xA0, 0xBC, 0xCA, 0x3E, 0x94, 0x95, 0xDA, 0x49, 0xE2, 0xA8, 0x33, 0xA2, 0x6A, 0x33, 0xB1, 0xF2, 0xEA, 0x99, 0x32, 0xD0, 0xB2, 0xAE, 0x55, 0x75, 0xBD, 0x19, 0xFC, 0x9A, 0xEC, 0x54, 0x87, 0x2A, 0x6, 0xCC, 0x78, 0xDA, 0x88, 0xBB, 0xAB, 0xA5, 0x47, 0xEF, 0xC7, 0x2B, 0xC7, 0x5B, 0x32, 0x31, 0xCD, 0xD9, 0x53, 0x96, 0x1A, 0x9D, 0x9A, 0x57, 0x40, 0x51, 0xB6, 0x5D, 0xC, 0x17, 0xD1, 0x86, 0xE9, 0xA4, 0x20, };
  31
  32                 static byte[] huge_div = new byte[] { 0x0, };
  33                 static byte[] huge_rem = new byte[] { 0x1D, 0x33, 0xFB, 0xFE, 0xB1, 0x2, 0x85, 0x44, 0xCA, 0xDC, 0xFB, 0x70, 0xD, 0x39, 0xB1, 0x47, 0xB6, 0xE6, 0xA2, 0xD1, 0x19, 0x1E, 0x9F, 0xE4, 0x3C, 0x1E, 0x16, 0x56, 0x13, 0x9C, 0x4D, 0xD3, 0x5C, 0x74, 0xC9, 0xBD, 0xFA, 0x56, 0x40, 0x58, 0xAC, 0x20, 0x6B, 0x55, 0xA2, 0xD5, 0x41, 0x38, 0xA4, 0x6D, 0xF6, 0x8C, };
  34                 static byte[][] add_a = new byte[][] {
  35                         new byte[] {1},
  36                         new byte[] {0xFF},
  37                         huge_a
  38                 };
  39
  40                 static byte[][] add_b = new byte[][] {
  41                         new byte[] {1},
  42                         new byte[] {1},
  43                         huge_b
  44                 };
  45
  46                 static byte[][] add_c = new byte[][] {
  47                         new byte[] {2},
  48                         new byte[] {0},
  49                         huge_add
  50                 };
  51
  52                 private NumberFormatInfo Nfi = NumberFormatInfo.InvariantInfo;
  53                 private NumberFormatInfo NfiUser;
  54
  55                 [TestFixtureSetUp]
  56                 public void SetUpFixture()
  57                 {
  58                         NfiUser = new NumberFormatInfo ();
  59                         NfiUser.CurrencyDecimalDigits = 3;
  60                         NfiUser.CurrencyDecimalSeparator = ":";
  61                         NfiUser.CurrencyGroupSeparator = "/";
  62                         NfiUser.CurrencyGroupSizes = new int[] { 2, 1, 0 };
  63                         NfiUser.CurrencyNegativePattern = 10;  // n $-
  64                         NfiUser.CurrencyPositivePattern = 3;  // n $
  65                         NfiUser.CurrencySymbol = "XYZ";
  66                         NfiUser.PercentDecimalDigits = 1;
  67                         NfiUser.PercentDecimalSeparator = ";";
  68                         NfiUser.PercentGroupSeparator = "~";
  69                         NfiUser.PercentGroupSizes = new int[] { 1 };
  70                         NfiUser.PercentNegativePattern = 2;
  71                         NfiUser.PercentPositivePattern = 2;
  72                         NfiUser.PercentSymbol = "%%%";
  73                 }
  74
  75                 [Test]
  76                 public void Mul () {
  77                         long[] values = new long [] { -1000000000L, -1000, -1, 0, 1, 1000, 100000000L };
  78                         for (int i = 0; i < values.Length; ++i) {
  79                                 for (int j = 0; j < values.Length; ++j) {
  80                                         var a = new BigInteger (values [i]);
  81                                         var b = new BigInteger (values [j]);
  82                                         var c = a * b;
  83                                         Assert.AreEqual (values [i] * values [j], (long)c, "#_" + i + "_" + j);
  84                                 }
  85                         }
  86                 }
  87
  88                 [Test]
  89                 public void TestHugeMul () {
  90                         var a = new BigInteger (huge_a);
  91                         var b = new BigInteger (huge_b);
  92                         Assert.AreEqual (huge_mul, (a * b).ToByteArray (), "#1");
  93                 }
  94
  95
  96                 [Test]
  97                 public void DivRem () {
  98                         long[] values = new long [] { -10000000330L, -5000, -1, 0, 1, 1000, 333, 10234544400L };
  99                         for (int i = 0; i < values.Length; ++i) {
 100                                 for (int j = 0; j < values.Length; ++j) {
 101                                         if (values [j] == 0)
 102                                                 continue;
 103                                         var a = new BigInteger (values [i]);
 104                                         var b = new BigInteger (values [j]);
 105                                         BigInteger c, d;
 106                                         c = BigInteger.DivRem (a, b, out d);
 107
 108                                         Assert.AreEqual (values [i] / values [j], (long)c, "#a_" + i + "_" + j);
 109                                         Assert.AreEqual (values [i] % values [j], (long)d, "#b_" + i + "_" + j);
 110                                 }
 111                         }
 112                 }
 113
 114                 [Test]
 115                 public void TestHugeDivRem () {
 116                         var a = new BigInteger (huge_a);
 117                         var b = new BigInteger (huge_b);
 118                         BigInteger c, d;
 119                         c = BigInteger.DivRem (a, b, out d);
 120
 121                         Assert.AreEqual (huge_div, c.ToByteArray (), "#1");
 122                         Assert.AreEqual (huge_rem, d.ToByteArray (), "#2");
 123                 }
 124
 125                 [Test]
 126                 public void Pow () {
 127                         try {
 128                                 BigInteger.Pow (1, -1);
 129                                 Assert.Fail ("#1");
 130                         } catch (ArgumentOutOfRangeException) {}
 131
 132                         Assert.AreEqual (1, (int)BigInteger.Pow (99999, 0), "#2");
 133                         Assert.AreEqual (99999, (int)BigInteger.Pow (99999, 1), "#5");
 134                         Assert.AreEqual (59049, (int)BigInteger.Pow (3, 10), "#4");
 135                         Assert.AreEqual (177147, (int)BigInteger.Pow (3, 11), "#5");
 136                         Assert.AreEqual (-177147, (int)BigInteger.Pow (-3, 11), "#6");
 137                 }
 138
 139                 [Test]
 140                 public void ModPow () {
 141                         try {
 142                                 BigInteger.ModPow (1, -1, 5);
 143                                 Assert.Fail ("#1");
 144                         } catch (ArgumentOutOfRangeException) {}
 145                         try {
 146                                 BigInteger.ModPow (1, 5, 0);
 147                                 Assert.Fail ("#2");
 148                         } catch (DivideByZeroException) {}
 149
 150                         Assert.AreEqual (4L, (long)BigInteger.ModPow (3, 2, 5), "#2");
 151                         Assert.AreEqual (20L, (long)BigInteger.ModPow (555, 10, 71), "#3");
 152                         Assert.AreEqual (20L, (long)BigInteger.ModPow (-555, 10, 71), "#3");
 153                         Assert.AreEqual (-24L, (long)BigInteger.ModPow (-555, 11, 71), "#3");
 154                 }
 155
 156                 [Test]
 157                 public void GCD () {
 158                         Assert.AreEqual (999999, (int)BigInteger.GreatestCommonDivisor (999999, 0), "#1");
 159                         Assert.AreEqual (999999, (int)BigInteger.GreatestCommonDivisor (0, 999999), "#2");
 160                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (999999, 1), "#3");
 161                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (1, 999999), "#4");
 162                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (1, 0), "#5");
 163                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (0, 1), "#6");
 164
 165                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (999999, -1), "#7");
 166                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (-1, 999999), "#8");
 167                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (-1, 0), "#9");
 168                         Assert.AreEqual (1, (int)BigInteger.GreatestCommonDivisor (0, -1), "#10");
 169
 170                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (12345678, 8765432), "#11");
 171                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (-12345678, 8765432), "#12");
 172                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (12345678, -8765432), "#13");
 173                         Assert.AreEqual (2, (int)BigInteger.GreatestCommonDivisor (-12345678, -8765432), "#14");
 174
 175                         Assert.AreEqual (40, (int)BigInteger.GreatestCommonDivisor (5581 * 40, 6671 * 40), "#15");
 176
 177                         Assert.AreEqual (5, (int)BigInteger.GreatestCommonDivisor (-5, 0), "#16");
 178                         Assert.AreEqual (5, (int)BigInteger.GreatestCommonDivisor (0, -5), "#17");
 179                 }
 180
 181                 [Test]
 182                 public void Log () {
 183                         double delta = 0.000000000000001d;
 184
 185                         Assert.AreEqual (double.NegativeInfinity, BigInteger.Log (0), "#1");
 186                         Assert.AreEqual (0d, BigInteger.Log (1), "#2");
 187                         Assert.AreEqual (double.NaN, BigInteger.Log (-1), "#3");
 188                         Assert.AreEqual (2.3025850929940459d, BigInteger.Log (10), delta, "#4");
 189                         Assert.AreEqual (6.9077552789821368d, BigInteger.Log (1000), delta, "#5");
 190                         Assert.AreEqual (double.NaN, BigInteger.Log (-234), "#6");
 191                 }
 192
 193                 [Test]
 194                 public void LogN () {
 195                         double delta = 0.000000000000001d;
 196
 197                         Assert.AreEqual (double.NaN, BigInteger.Log (10, 1), "#1");
 198                         Assert.AreEqual (double.NaN, BigInteger.Log (10, 0), "#2");
 199                         Assert.AreEqual (double.NaN, BigInteger.Log (10, -1), "#3");
 200
 201                         Assert.AreEqual (double.NaN, BigInteger.Log (10, double.NaN), "#4");
 202                         Assert.AreEqual (double.NaN, BigInteger.Log (10, double.NegativeInfinity), "#5");
 203                         Assert.AreEqual (double.NaN, BigInteger.Log (10, double.PositiveInfinity), "#6");
 204
 205                         Assert.AreEqual (0d, BigInteger.Log (1, 0), "#7");
 206                         Assert.AreEqual (double.NaN, BigInteger.Log (1, double.NegativeInfinity), "#8");
 207                         Assert.AreEqual (0, BigInteger.Log (1, double.PositiveInfinity), "#9");
 208                         Assert.AreEqual (double.NaN, BigInteger.Log (1, double.NaN), "#10");
 209
 210                         Assert.AreEqual (-2.5129415947320606d, BigInteger.Log (10, 0.4), delta, "#11");
 211                 }
 212
 213                 [Test]
 214                 public void DivRemByZero () {
 215                         try {
 216                                 BigInteger c, d;
 217                                 c = BigInteger.DivRem (100, 0, out d);
 218                                 Assert.Fail ("#1");
 219                         } catch (DivideByZeroException) {}
 220                 }
 221
 222                 [Test]
 223                 public void TestAdd () {
 224                         for (int i = 0; i < add_a.Length; ++i) {
 225                                 var a = new BigInteger (add_a [i]);
 226                                 var b = new BigInteger (add_b [i]);
 227                                 var c = new BigInteger (add_c [i]);
 228
 229                                 Assert.AreEqual (c, a + b, "#" + i + "a");
 230                                 Assert.AreEqual (c, b + a, "#" + i + "b");
 231                                 Assert.AreEqual (c, BigInteger.Add (a, b), "#" + i + "c");
 232                                 Assert.AreEqual (add_c [i], (a + b).ToByteArray (), "#" + i + "d");
 233                         }
 234                 }
 235
 236                 [Test]
 237                 public void TestAdd2 () {
 238                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 239                         for (int i = 0; i < values.Length; ++i) {
 240                                 for (int j = 0; j < values.Length; ++j) {
 241                                         var a = new BigInteger (values [i]);
 242                                         var b = new BigInteger (values [j]);
 243                                         var c = a + b;
 244                                         Assert.AreEqual (values [i] + values [j], (long)c, "#_" + i + "_" + j);
 245                                 }
 246                         }
 247                 }
 248
 249                 [Test]
 250                 public void TestHugeSub () {
 251                         var a = new BigInteger (huge_a);
 252                         var b = new BigInteger (huge_b);
 253                         Assert.AreEqual (a_m_b, (a - b).ToByteArray (), "#1");
 254                         Assert.AreEqual (b_m_a, (b - a).ToByteArray (), "#2");
 255                 }
 256
 257                 [Test]
 258                 public void TestSub () {
 259                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 260                         for (int i = 0; i < values.Length; ++i) {
 261                                 for (int j = 0; j < values.Length; ++j) {
 262                                         var a = new BigInteger (values [i]);
 263                                         var b = new BigInteger (values [j]);
 264                                         var c = a - b;
 265                                         var d = BigInteger.Subtract (a, b);
 266
 267                                         Assert.AreEqual (values [i] - values [j], (long)c, "#_" + i + "_" + j);
 268                                         Assert.AreEqual (values [i] - values [j], (long)d, "#_" + i + "_" + j);
 269                                 }
 270                         }
 271                 }
 272
 273                 [Test]
 274                 public void TestMin () {
 275                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 276                         for (int i = 0; i < values.Length; ++i) {
 277                                 for (int j = 0; j < values.Length; ++j) {
 278                                         var a = new BigInteger (values [i]);
 279                                         var b = new BigInteger (values [j]);
 280                                         var c = BigInteger.Min (a, b);
 281
 282                                         Assert.AreEqual (Math.Min (values [i], values [j]), (long)c, "#_" + i + "_" + j);
 283                                 }
 284                         }
 285                 }
 286
 287                 [Test]
 288                 public void TestMax () {
 289                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 290                         for (int i = 0; i < values.Length; ++i) {
 291                                 for (int j = 0; j < values.Length; ++j) {
 292                                         var a = new BigInteger (values [i]);
 293                                         var b = new BigInteger (values [j]);
 294                                         var c = BigInteger.Max (a, b);
 295
 296                                         Assert.AreEqual (Math.Max (values [i], values [j]), (long)c, "#_" + i + "_" + j);
 297                                 }
 298                         }
 299                 }
 300
 301                 [Test]
 302                 public void TestAbs () {
 303                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 304                         for (int i = 0; i < values.Length; ++i) {
 305                                 var a = new BigInteger (values [i]);
 306                                 var c = BigInteger.Abs (a);
 307
 308                                 Assert.AreEqual (Math.Abs (values [i]), (long)c, "#_" + i);
 309                         }
 310                 }
 311
 312                 [Test]
 313                 public void TestNegate () {
 314                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 315                         for (int i = 0; i < values.Length; ++i) {
 316                                 var a = new BigInteger (values [i]);
 317                                 var c = -a;
 318                                 var d = BigInteger.Negate (a);
 319
 320                                 Assert.AreEqual (-values [i], (long)c, "#_" + i);
 321                                 Assert.AreEqual (-values [i], (long)d, "#_" + i);
 322                         }
 323                 }
 324
 325                 [Test]
 326                 public void TestInc () {
 327                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 328                         for (int i = 0; i < values.Length; ++i) {
 329                                 var a = new BigInteger (values [i]);
 330                                 var b = ++a;
 331
 332                                 Assert.AreEqual (++values [i], (long)b, "#_" + i);
 333                         }
 334                 }
 335
 336                 [Test]
 337                 public void TestDec () {
 338                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 339                         for (int i = 0; i < values.Length; ++i) {
 340                                 var a = new BigInteger (values [i]);
 341                                 var b = --a;
 342
 343                                 Assert.AreEqual (--values [i], (long)b, "#_" + i);
 344                         }
 345                 }
 346
 347                 [Test]
 348                 public void TestBitwiseOps () {
 349                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L, 0xFFFF00000000L };
 350                         for (int i = 0; i < values.Length; ++i) {
 351                                 for (int j = 0; j < values.Length; ++j) {
 352                                         var a = new BigInteger (values [i]);
 353                                         var b = new BigInteger (values [j]);
 354
 355
 356                                         Assert.AreEqual (values [i] | values [j], (long)(a | b) , "#b_" + i + "_" + j);
 357                                         Assert.AreEqual (values [i] & values [j], (long)(a & b) , "#a_" + i + "_" + j);
 358                                         Assert.AreEqual (values [i] ^ values [j], (long)(a ^ b) , "#c_" + i + "_" + j);
 359                                         Assert.AreEqual (~values [i], (long)~a , "#d_" + i + "_" + j);
 360                                 }
 361                         }
 362                 }
 363
 364                 [Test]
 365                 public void TestLeftShift () {
 366                         Assert.AreEqual (new byte[] {0x00, 0x28},
 367                                 (new BigInteger(0x0A) << 10).ToByteArray (), "#1");
 368                         Assert.AreEqual (new byte[] {0x00, 0xD8},
 369                                 (new BigInteger(-10) << 10).ToByteArray (), "#2");
 370                         Assert.AreEqual (new byte[] {0x00, 0x00, 0xFF},
 371                                 (new BigInteger(-1) << 16).ToByteArray (), "#3");
 372                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A},
 373                                 (new BigInteger(0x0A) << 80).ToByteArray (), "#4");
 374                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6},
 375                                 (new BigInteger(-10) << 80).ToByteArray (), "#5");
 376                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF},
 377                                 (new BigInteger(-1) << 80).ToByteArray (), "#6");
 378                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xD9},
 379                                 (new BigInteger(-1234) << 75).ToByteArray (), "#7");
 380                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x91, 0x00},
 381                                 (new BigInteger(0x1234) << 75).ToByteArray (), "#8");
 382
 383                         Assert.AreEqual (new byte[] {0xFF, 0x00}, (new BigInteger(0xFF00) << -8).ToByteArray (), "#9");
 384                 }
 385
 386                 [Test]
 387                 public void TestRightShift () {
 388                         Assert.AreEqual (new byte[] {0x16, 0xB0, 0x4C, 0x02},
 389                                 (new BigInteger(1234567899L) >> 5).ToByteArray (), "#1");
 390
 391                         Assert.AreEqual (new byte[] {0x2C, 0x93, 0x00},
 392                                 (new BigInteger(1234567899L) >> 15).ToByteArray (), "#2");
 393
 394                         Assert.AreEqual (new byte[] {0xFF, 0xFF, 0x7F},
 395                                 (new BigInteger(long.MaxValue - 100) >> 40).ToByteArray (), "#3");
 396
 397                         Assert.AreEqual (new byte[] {0xE9, 0x4F, 0xB3, 0xFD},
 398                                 (new BigInteger(-1234567899L) >> 5).ToByteArray (), "#4");
 399
 400                         Assert.AreEqual (new byte[] {0xD3, 0x6C, 0xFF},
 401                                 (new BigInteger(-1234567899L) >> 15).ToByteArray (), "#5");
 402
 403                         Assert.AreEqual (new byte[] {0x00, 0x00, 0x80},
 404                                 (new BigInteger(long.MinValue + 100) >> 40).ToByteArray (), "#6");
 405
 406                         Assert.AreEqual (new byte[] { 0xFF },
 407                                 (new BigInteger(-1234567899L) >> 90).ToByteArray (), "#7");
 408
 409                         Assert.AreEqual (new byte[] {0x00},
 410                                 (new BigInteger(999999) >> 90).ToByteArray (), "#8");
 411
 412                         Assert.AreEqual (new byte[] {0x00, 0x00, 0xFF, 0x00}, (new BigInteger(0xFF00) >> -8).ToByteArray (), "#9");
 413                 }
 414
 415                 [Test]
 416                 public void CompareOps () {
 417                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L };
 418                         for (int i = 0; i < values.Length; ++i) {
 419                                 for (int j = 0; j < values.Length; ++j) {
 420                                         var a = new BigInteger (values [i]);
 421                                         var b = new BigInteger (values [j]);
 422
 423                                         Assert.AreEqual (values [i].CompareTo (values [j]), a.CompareTo (b), "#a_" + i + "_" + j);
 424                                         Assert.AreEqual (values [i].CompareTo (values [j]), BigInteger.Compare (a, b), "#b_" + i + "_" + j);
 425
 426                                         Assert.AreEqual (values [i] < values [j], a < b, "#c_" + i + "_" + j);
 427                                         Assert.AreEqual (values [i] <= values [j], a <= b, "#d_" + i + "_" + j);
 428                                         Assert.AreEqual (values [i] == values [j], a == b, "#e_" + i + "_" + j);
 429                                         Assert.AreEqual (values [i] != values [j], a != b, "#f_" + i + "_" + j);
 430                                         Assert.AreEqual (values [i] >= values [j], a >= b, "#g_" + i + "_" + j);
 431                                         Assert.AreEqual (values [i] > values [j], a > b, "#h_" + i + "_" + j);
 432                                 }
 433                         }
 434                 }
 435
 436                 [Test]
 437                 public void CompareOps2 () {
 438                         BigInteger a = new BigInteger (100000000000L);
 439                         BigInteger b = new BigInteger (28282828282UL);
 440
 441                         Assert.IsTrue (a >= b, "#1");
 442                         Assert.IsTrue (a >= b, "#2");
 443                         Assert.IsFalse (a < b, "#3");
 444                         Assert.IsFalse (a <= b, "#4");
 445                         Assert.AreEqual (1, a.CompareTo (b), "#5");
 446                 }
 447
 448                 [Test]
 449                 public void CompareULong () {
 450                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 100000000000L, 0xAA00000000L };
 451                         ulong[] uvalues = new ulong [] {0, 1, 1000, 100000000000L, 999999, 28282828282, 0xAA00000000, ulong.MaxValue };
 452                         for (int i = 0; i < values.Length; ++i) {
 453                                 for (int j = 0; j < uvalues.Length; ++j) {
 454                                         var a = new BigInteger (values [i]);
 455                                         var b = uvalues [j];
 456                                         var c = new BigInteger (b);
 457
 458                                         Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);
 459
 460                                         Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
 461                                         Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
 462                                         Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
 463                                         Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
 464                                         Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
 465                                         Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);
 466
 467                                         Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
 468                                         Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
 469                                         Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
 470                                         Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
 471                                         Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
 472                                         Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
 473                                 }
 474                         }
 475                 }
 476
 477                 [Test]
 478                 public void CompareLong () {
 479                         long[] values = new long [] { -100000000000L, -1000, -1, 0, 1, 1000, 9999999, 100000000000L, 0xAA00000000, long.MaxValue, long.MinValue };
 480
 481                         for (int i = 0; i < values.Length; ++i) {
 482                                 for (int j = 0; j < values.Length; ++j) {
 483                                         var a = new BigInteger (values [i]);
 484                                         var b = values [j];
 485                                         var c = new BigInteger (b);
 486
 487                                         Assert.AreEqual (a.CompareTo (c), a.CompareTo (b), "#a_" + i + "_" + j);
 488
 489                                         Assert.AreEqual (a > c, a > b, "#b_" + i + "_" + j);
 490                                         Assert.AreEqual (a < c, a < b, "#c_" + i + "_" + j);
 491                                         Assert.AreEqual (a <= c, a <= b, "#d_" + i + "_" + j);
 492                                         Assert.AreEqual (a == c, a == b, "#e_" + i + "_" + j);
 493                                         Assert.AreEqual (a != c, a != b, "#f_" + i + "_" + j);
 494                                         Assert.AreEqual (a >= c, a >= b, "#g_" + i + "_" + j);
 495
 496                                         Assert.AreEqual (c > a, b > a, "#ib_" + i + "_" + j);
 497                                         Assert.AreEqual (c < a, b < a, "#ic_" + i + "_" + j);
 498                                         Assert.AreEqual (c <= a, b <= a, "#id_" + i + "_" + j);
 499                                         Assert.AreEqual (c == a, b == a, "#ie_" + i + "_" + j);
 500                                         Assert.AreEqual (c != a, b != a, "#if_" + i + "_" + j);
 501                                         Assert.AreEqual (c >= a, b >= a, "#ig_" + i + "_" + j);
 502                                 }
 503                         }
 504                 }
 505
 506                 [Test]
 507                 public void TestEquals () {
 508                                 var a = new BigInteger (10);
 509                                 var b = new BigInteger (10);
 510                                 var c = new BigInteger (-10);
 511
 512                                 Assert.AreEqual (a, b, "#1");
 513                                 Assert.AreNotEqual (a, c, "#2");
 514                                 Assert.AreNotEqual (a, 10, "#3");
 515                 }
 516
 517                 [Test]
 518                 public void ByteArrayCtor ()
 519                 {
 520                         try {
 521                                 new BigInteger (null);
 522                                 Assert.Fail ("#1");
 523                         } catch (ArgumentNullException) {}
 524
 525                         Assert.AreEqual (0, (int)new BigInteger (new byte [0]), "#2");
 526
 527                         Assert.AreEqual (0, (int)new BigInteger (new byte [1]), "#3");
 528
 529                         Assert.AreEqual (0, (int)new BigInteger (new byte [2]), "#4");
 530                 }
 531
 532                 [Test]
 533                 public void IntCtorRoundTrip ()
 534                 {
 535                         int[] values = new int [] {
 536                                 int.MinValue, -0x2F33BB, -0x1F33, -0x33, 0, 0x33,
 537                                 0x80, 0x8190, 0xFF0011, 0x1234, 0x11BB99, 0x44BB22CC,
 538                                 int.MaxValue };
 539                         foreach (var val in values) {
 540                                 var a = new BigInteger (val);
 541                                 var b = new BigInteger (a.ToByteArray ());
 542
 543                                 Assert.AreEqual (val, (int)a, "#a_" + val);
 544                                 Assert.AreEqual (val, (int)b, "#b_" + val);
 545                         }
 546                 }
 547
 548                 [Test]
 549                 public void LongCtorRoundTrip ()
 550                 {
 551                         long[] values = new long [] {
 552                                 0, long.MinValue, long.MaxValue, -1, 1L + int.MaxValue, -1L + int.MinValue, 0x1234, 0xFFFFFFFFL, 0x1FFFFFFFFL, -0xFFFFFFFFL, -0x1FFFFFFFFL,
 553                                 0x100000000L, -0x100000000L, 0x100000001L, -0x100000001L };
 554                         foreach (var val in values) {
 555                                 var a = new BigInteger (val);
 556                                 var b = new BigInteger (a.ToByteArray ());
 557
 558                                 Assert.AreEqual (val, (long)a, "#a_" + val);
 559                                 Assert.AreEqual (val, (long)b, "#b_" + val);
 560                         }
 561                 }
 562
 563                 [Test]
 564                 public void ByteArrayCtorRoundTrip ()
 565                 {
 566                         var arr = new byte [] { 1,2,3,4,5,6,7,8,9 };
 567                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#1");
 568
 569                         arr = new byte [] { 1,2,3,4,5,6,7,8,0xFF, 0x0};
 570                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#2");
 571
 572                         arr = new byte [] { 1,2,3,4,5,6,7,8,9, 0xF0 };
 573                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#3");
 574
 575                         arr = new byte [] { 1};
 576                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#4");
 577
 578                         arr = new byte [] { 1,2 };
 579                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#5");
 580
 581                         arr = new byte [] { 1,2,3 };
 582                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#6");
 583
 584                         arr = new byte [] { 1,2,3,4 };
 585                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#7");
 586
 587                         arr = new byte [] { 1,2,3,4,5 };
 588                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#8");
 589
 590                         arr = new byte [] { 1,2,3,4,5,6 };
 591                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#9");
 592
 593                         arr = new byte [] { 1,2,3,4,5,6,7 };
 594                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#10");
 595
 596                         arr = new byte [] { 1,2,3,4,5 };
 597                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#11");
 598
 599                         arr = new byte [] { 0 };
 600                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#12");
 601
 602                         arr = new byte [] { 0xFF, 00 };
 603                         Assert.AreEqual (arr, new BigInteger (arr).ToByteArray (), "#13");
 604
 605                         arr = new byte [] { 1, 0, 0, 0, 0, 0, };
 606                         Assert.AreEqual (new byte [1] {1}, new BigInteger (arr).ToByteArray (), "#14");
 607                 }
 608
 609                 [Test]
 610                 public void TestIntCtorProperties ()
 611                 {
 612                         BigInteger a = new BigInteger (10);
 613                         Assert.IsTrue (a.IsEven, "#1");
 614                         Assert.IsFalse (a.IsOne, "#2");
 615                         Assert.IsFalse (a.IsPowerOfTwo, "#3");
 616                         Assert.IsFalse (a.IsZero, "#4");
 617                         Assert.AreEqual (1, a.Sign, "#5");
 618
 619                         Assert.IsFalse (new BigInteger (11).IsEven, "#6");
 620                         Assert.IsTrue (new BigInteger (1).IsOne, "#7");
 621                         Assert.IsTrue (new BigInteger (32).IsPowerOfTwo, "#8");
 622                         Assert.IsTrue (new BigInteger (0).IsZero, "#9");
 623                         Assert.AreEqual (0, new BigInteger (0).Sign, "#10");
 624                         Assert.AreEqual (-1, new BigInteger (-99999).Sign, "#11");
 625
 626                         Assert.IsFalse (new BigInteger (0).IsPowerOfTwo, "#12");
 627                         Assert.IsFalse (new BigInteger (-16).IsPowerOfTwo, "#13");
 628                         Assert.IsTrue (new BigInteger (1).IsPowerOfTwo, "#14");
 629                 }
 630
 631                 [Test]
 632                 public void TestIntCtorToString ()
 633                 {
 634                         Assert.AreEqual ("5555", new BigInteger (5555).ToString (), "#1");
 635                         Assert.AreEqual ("-99999", new BigInteger (-99999).ToString (), "#2");
 636                 }
 637
 638                 [Test]
 639                 public void TestToStringFmt ()
 640                 {
 641                         Assert.AreEqual ("123456789123456", new BigInteger (123456789123456).ToString ("D2"), "#1");
 642                         Assert.AreEqual ("0000000005", new BigInteger (5).ToString ("d10"), "#2");
 643                         Assert.AreEqual ("0A8", new BigInteger (168).ToString ("X"), "#3");
 644                         Assert.AreEqual ("0", new BigInteger (0).ToString ("X"), "#4");
 645                         Assert.AreEqual ("1", new BigInteger (1).ToString ("X"), "#5");
 646                         Assert.AreEqual ("0A", new BigInteger (10).ToString ("X"), "#6");
 647                         Assert.AreEqual ("F6", new BigInteger (-10).ToString ("X"), "#7");
 648
 649                         Assert.AreEqual ("10000000000000000000000000000000000000000000000000000000", BigInteger.Pow (10, 55).ToString ("G"), "#8");
 650
 651                         Assert.AreEqual ("10000000000000000000000000000000000000000000000000000000", BigInteger.Pow (10, 55).ToString ("R"), "#9");
 652
 653
 654                         Assert.AreEqual ("000000000A", new BigInteger (10).ToString ("X10"), "#10");
 655                         Assert.AreEqual ("0000000010", new BigInteger (10).ToString ("G10"), "#11");
 656                 }
 657
 658                 [Test]
 659                 public void TestToStringFmtProvider ()
 660                 {
 661                         NumberFormatInfo info = new NumberFormatInfo ();
 662                         info.NegativeSign = ">";
 663                         info.PositiveSign = "%";
 664
 665                         Assert.AreEqual ("10", new BigInteger (10).ToString (info), "#1");
 666                         Assert.AreEqual (">10", new BigInteger (-10).ToString (info), "#2");
 667                         Assert.AreEqual ("0A", new BigInteger (10).ToString ("X", info), "#3");
 668                         Assert.AreEqual ("F6", new BigInteger (-10).ToString ("X", info), "#4");
 669                         Assert.AreEqual ("10", new BigInteger (10).ToString ("G", info), "#5");
 670                         Assert.AreEqual (">10", new BigInteger (-10).ToString ("G", info), "#6");
 671                         Assert.AreEqual ("10", new BigInteger (10).ToString ("D", info), "#7");
 672                         Assert.AreEqual (">10", new BigInteger (-10).ToString ("D", info), "#8");
 673                         Assert.AreEqual ("10", new BigInteger (10).ToString ("R", info), "#9");
 674                         Assert.AreEqual (">10", new BigInteger (-10).ToString ("R", info), "#10");
 675
 676                         info = new NumberFormatInfo ();
 677                         info.NegativeSign = "#$%";
 678                         Assert.AreEqual ("#$%10", new BigInteger (-10).ToString (info), "#2");
 679                         Assert.AreEqual ("#$%10", new BigInteger (-10).ToString (null, info), "#2");
 680
 681                         info = new NumberFormatInfo ();
 682                         Assert.AreEqual ("-10", new BigInteger (-10).ToString (info), "#2");
 683
 684                 }
 685
 686                 [Test]
 687                 public void TestToIntOperator ()
 688                 {
 689                         try {
 690                                 int v = (int)new BigInteger (huge_a);
 691                                 Assert.Fail ("#1");
 692                         } catch (OverflowException) {}
 693
 694                         try {
 695                                 int v = (int)new BigInteger (1L + int.MaxValue);
 696                                 Assert.Fail ("#2");
 697                         } catch (OverflowException) {}
 698
 699                         try {
 700                                 int v = (int)new BigInteger (-1L + int.MinValue);
 701                                 Assert.Fail ("#3");
 702                         } catch (OverflowException) {}
 703
 704                         Assert.AreEqual (int.MaxValue, (int)new BigInteger (int.MaxValue), "#4");
 705                         Assert.AreEqual (int.MinValue, (int)new BigInteger (int.MinValue), "#5");
 706                 }
 707
 708
 709                 [Test]
 710                 public void TestToLongOperator ()
 711                 {
 712                         try {
 713                                 long v = (long)new BigInteger (huge_a);
 714                                 Assert.Fail ("#1");
 715                         } catch (OverflowException) {}
 716
 717                         //long.MaxValue + 1
 718                         try {
 719                                 long v = (long)new BigInteger (new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00 });
 720                                 Assert.Fail ("#2");
 721                         } catch (OverflowException) {}
 722
 723                         //TODO long.MinValue - 1
 724                         try {
 725                                 long v = (long)new BigInteger (new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF });
 726                                 Assert.Fail ("#3");
 727                         } catch (OverflowException) {}
 728
 729                         Assert.AreEqual (long.MaxValue, (long)new BigInteger (long.MaxValue), "#4");
 730                         Assert.AreEqual (long.MinValue, (long)new BigInteger (long.MinValue), "#5");
 731                 }
 732
 733                 [Test]
 734                 public void TestIntCtorToByteArray ()
 735                 {
 736                         Assert.AreEqual (new byte[] { 0xFF }, new BigInteger (-1).ToByteArray (), "#1");
 737                         Assert.AreEqual (new byte[] { 0xD4, 0xFE }, new BigInteger (-300).ToByteArray (), "#2");
 738                         Assert.AreEqual (new byte[] { 0x80, 0x00 }, new BigInteger (128).ToByteArray (), "#3");
 739                         Assert.AreEqual (new byte[] { 0x00, 0x60 }, new BigInteger (0x6000).ToByteArray (), "#4");
 740                         Assert.AreEqual (new byte[] { 0x00, 0x80, 0x00 }, new BigInteger (0x8000).ToByteArray (), "#5");
 741                         Assert.AreEqual (new byte[] { 0xDD, 0xBC, 0x00, 0x7A }, new BigInteger (0x7A00BCDD).ToByteArray (), "#6");
 742                         Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0x7F }, new BigInteger (int.MaxValue).ToByteArray (), "#7");
 743                         Assert.AreEqual (new byte[] { 0x00, 0x00, 0x00, 0x80 }, new BigInteger (int.MinValue).ToByteArray (), "#8");
 744                         Assert.AreEqual (new byte[] { 0x01, 0x00, 0x00, 0x80 }, new BigInteger (int.MinValue + 1).ToByteArray (), "#9");
 745                         Assert.AreEqual (new byte[] { 0x7F }, new BigInteger (0x7F).ToByteArray (), "#10");
 746                         Assert.AreEqual (new byte[] { 0x45, 0xCC, 0xD0 }, new BigInteger (-0x2F33BB).ToByteArray (), "#11");
 747                         Assert.AreEqual (new byte[] { 0 }, new BigInteger (0).ToByteArray (), "#12");
 748                 }
 749
 750                 [Test]
 751                 public void TestLongCtorToByteArray ()
 752                 {
 753                         Assert.AreEqual (new byte[] { 0x01 }, new BigInteger (0x01L).ToByteArray (), "#1");
 754                         Assert.AreEqual (new byte[] { 0x02, 0x01 }, new BigInteger (0x0102L).ToByteArray (), "#2");
 755                         Assert.AreEqual (new byte[] { 0x03, 0x02, 0x01 }, new BigInteger (0x010203L).ToByteArray (), "#3");
 756                         Assert.AreEqual (new byte[] { 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x01020304L).ToByteArray (), "#4");
 757                         Assert.AreEqual (new byte[] { 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x0102030405L).ToByteArray (), "#5");
 758                         Assert.AreEqual (new byte[] { 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x010203040506L).ToByteArray (), "#6");
 759                         Assert.AreEqual (new byte[] { 0x07, 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x01020304050607L).ToByteArray (), "#7");
 760                         Assert.AreEqual (new byte[] { 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x2, 0x01 }, new BigInteger (0x0102030405060708L).ToByteArray (), "#8");
 761
 762                         Assert.AreEqual (new byte[] { 0xFF }, new BigInteger (-0x01L).ToByteArray (), "#1m");
 763                         Assert.AreEqual (new byte[] { 0xFE, 0xFE}, new BigInteger (-0x0102L).ToByteArray (), "#2m");
 764                         Assert.AreEqual (new byte[] { 0xFD, 0xFD, 0xFE }, new BigInteger (-0x010203L).ToByteArray (), "#3m");
 765                         Assert.AreEqual (new byte[] { 0xFC, 0xFC, 0xFD, 0xFE}, new BigInteger (-0x01020304L).ToByteArray (), "#4m");
 766                         Assert.AreEqual (new byte[] { 0xFB, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x0102030405L).ToByteArray (), "#5m");
 767                         Assert.AreEqual (new byte[] { 0xFA, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x010203040506L).ToByteArray (), "#6m");
 768                         Assert.AreEqual (new byte[] { 0xF9, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x01020304050607L).ToByteArray (), "#7m");
 769                         Assert.AreEqual (new byte[] { 0xF8, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE }, new BigInteger (-0x0102030405060708L).ToByteArray (), "#8m");
 770
 771
 772                         Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F }, new BigInteger (long.MaxValue).ToByteArray (), "#9");
 773                         Assert.AreEqual (new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }, new BigInteger (long.MinValue).ToByteArray (), "#10");
 774
 775                         Assert.AreEqual (new byte[] { 0xFF, 0xFF, 0xFF, 0x7F, 0xFF }, new BigInteger (-2147483649L).ToByteArray (), "11");
 776                 }
 777
 778                 [Test]
 779                 public void IComparable () {
 780                         var a = new BigInteger (99);
 781                         Assert.AreEqual (-1, a.CompareTo (100), "#1");
 782                         Assert.AreEqual (1, a.CompareTo (null), "#2");
 783                 }
 784
 785                 [Test]
 786                 public void ShortOperators () {
 787                         Assert.AreEqual (22, (int)new BigInteger ((short)22), "#1");
 788                         Assert.AreEqual (-22, (int)new BigInteger ((short)-22), "#2");
 789
 790                         try {
 791                                 short x = (short)new BigInteger (10000000);
 792                                 Assert.Fail ("#3");
 793                         } catch (OverflowException) {}
 794
 795                         try {
 796                                 short x = (short)new BigInteger (-10000000);
 797                                 Assert.Fail ("#4");
 798                         } catch (OverflowException) {}
 799                 }
 800
 801                 [Test]
 802                 public void DoubleCtor () {
 803                         try {
 804                                 new BigInteger (double.NaN);
 805                                 Assert.Fail ("#1");
 806                         } catch (OverflowException) {}
 807                         try {
 808                                 new BigInteger (double.NegativeInfinity);
 809                                 Assert.Fail ("#2");
 810                         } catch (OverflowException) {}
 811                         try {
 812                                 new BigInteger (double.PositiveInfinity);
 813                                 Assert.Fail ("#3");
 814                         } catch (OverflowException) {}
 815
 816                         Assert.AreEqual (10000, (int)new BigInteger (10000.2), "#4");
 817                         Assert.AreEqual (10000, (int)new BigInteger (10000.9), "#5");
 818
 819                         Assert.AreEqual (10000, (int)new BigInteger (10000.2), "#6");
 820                         Assert.AreEqual (0, (int)new BigInteger (0.9), "#7");
 821
 822                         Assert.AreEqual (12345678999L, (long)new BigInteger (12345678999.33), "#8");
 823                 }
 824
 825                 [Test]
 826                 public void DoubleConversion () {
 827                         Assert.AreEqual (999d, (double)new BigInteger (999), "#1");
 828                         Assert.AreEqual (double.PositiveInfinity, (double)BigInteger.Pow (2, 1024), "#2");
 829                         Assert.AreEqual (double.NegativeInfinity, (double)BigInteger.Pow (-2, 1025), "#3");
 830
 831                 }
 832
 833                 [Test]
 834                 public void DecimalCtor () {
 835                         Assert.AreEqual (999, (int)new BigInteger (999.99m), "#1");
 836                         Assert.AreEqual (-10000, (int)new BigInteger (-10000m), "#2");
 837                         Assert.AreEqual (0, (int)new BigInteger (0m), "#3");
 838                 }
 839
 840                 [Test]
 841                 public void DecimalConversion () {
 842                         Assert.AreEqual (999m, (decimal)new BigInteger (999), "#1");
 843
 844                         try {
 845                                 var x = (decimal)BigInteger.Pow (2, 1024);
 846                                 Assert.Fail ("#2");
 847                         } catch (OverflowException) {}
 848
 849                         try {
 850                                 var x = (decimal)BigInteger.Pow (-2, 1025);
 851                                 Assert.Fail ("#3");
 852                         } catch (OverflowException) {}
 853
 854                         Assert.AreEqual (0m, (decimal)new BigInteger (0), "#4");
 855                         Assert.AreEqual (1m, (decimal)new BigInteger (1), "#5");
 856                         Assert.AreEqual (-1m, (decimal)new BigInteger (-1), "#6");
 857                         Assert.AreEqual (9999999999999999999999999999m,
 858                                 (decimal)new BigInteger (9999999999999999999999999999m), "#7");
 859                 }
 860
 861                 [Test]
 862                 public void Parse () {
 863                         try {
 864                                 BigInteger.Parse (null);
 865                                 Assert.Fail ("#1");
 866                         } catch (ArgumentNullException) {}
 867
 868                         try {
 869                                 BigInteger.Parse ("");
 870                                 Assert.Fail ("#2");
 871                         } catch (FormatException) {}
 872
 873
 874                         try {
 875                                 BigInteger.Parse ("  ");
 876                                 Assert.Fail ("#3");
 877                         } catch (FormatException) {}
 878
 879                         try {
 880                                 BigInteger.Parse ("hh");
 881                                 Assert.Fail ("#4");
 882                         } catch (FormatException) {}
 883
 884                         try {
 885                                 BigInteger.Parse ("-");
 886                                 Assert.Fail ("#5");
 887                         } catch (FormatException) {}
 888
 889                         try {
 890                                 BigInteger.Parse ("-+");
 891                                 Assert.Fail ("#6");
 892                         } catch (FormatException) {}
 893
 894                         Assert.AreEqual (10, (int)BigInteger.Parse("+10"), "#7");
 895                         Assert.AreEqual (10, (int)BigInteger.Parse("10 "), "#8");
 896                         Assert.AreEqual (-10, (int)BigInteger.Parse("-10 "), "#9");
 897                         Assert.AreEqual (10, (int)BigInteger.Parse("    10 "), "#10");
 898                         Assert.AreEqual (-10, (int)BigInteger.Parse("  -10 "), "#11");
 899
 900                         Assert.AreEqual (-1, (int)BigInteger.Parse("F", NumberStyles.AllowHexSpecifier), "#12");
 901                         Assert.AreEqual (-8, (int)BigInteger.Parse("8", NumberStyles.AllowHexSpecifier), "#13");
 902                         Assert.AreEqual (8, (int)BigInteger.Parse("08", NumberStyles.AllowHexSpecifier), "#14");
 903                         Assert.AreEqual (15, (int)BigInteger.Parse("0F", NumberStyles.AllowHexSpecifier), "#15");
 904                         Assert.AreEqual (-1, (int)BigInteger.Parse("FF", NumberStyles.AllowHexSpecifier), "#16");
 905                         Assert.AreEqual (255, (int)BigInteger.Parse("0FF", NumberStyles.AllowHexSpecifier), "#17");
 906
 907                         Assert.AreEqual (-17, (int)BigInteger.Parse("   (17)   ", NumberStyles.AllowParentheses | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite), "#18");
 908                         Assert.AreEqual (-23, (int)BigInteger.Parse("  -23  ", NumberStyles.AllowLeadingSign | NumberStyles.AllowLeadingWhite | NumberStyles.AllowTrailingWhite), "#19");
 909
 910                         Assert.AreEqual (300000, (int)BigInteger.Parse("3E5", NumberStyles.AllowExponent), "#20");
 911                         Assert.AreEqual (250, (int)BigInteger.Parse("2"+Nfi.NumberDecimalSeparator+"5E2", NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint), "#21");//2.5E2 = 250
 912                         Assert.AreEqual (25, (int)BigInteger.Parse("2500E-2", NumberStyles.AllowExponent), "#22");
 913
 914                         Assert.AreEqual ("136236974127783066520110477975349088954559032721408", BigInteger.Parse("136236974127783066520110477975349088954559032721408", NumberStyles.None).ToString(), "#23");
 915                         Assert.AreEqual ("136236974127783066520110477975349088954559032721408", BigInteger.Parse("136236974127783066520110477975349088954559032721408").ToString(), "#24");
 916
 917                         try {
 918                                 BigInteger.Parse ("2E3.0", NumberStyles.AllowExponent); // decimal notation for the exponent
 919                                 Assert.Fail ("#25");
 920                         } catch (FormatException) {
 921                         }
 922
 923                         try {
 924                                 Int32.Parse ("2.09E1",  NumberStyles.AllowDecimalPoint | NumberStyles.AllowExponent);
 925                                 Assert.Fail ("#26");
 926                         } catch (OverflowException) {
 927                         }
 928                 }
 929
 930                 [Test]
 931                 public void TryParse () {
 932                         BigInteger x = BigInteger.One;
 933                         Assert.IsFalse (BigInteger.TryParse (null, out x), "#1");
 934                         Assert.AreEqual (0, (int)x, "#1a");
 935                         Assert.IsFalse (BigInteger.TryParse ("", out x), "#2");
 936                         Assert.IsFalse (BigInteger.TryParse (" ", out x), "#3");
 937                         Assert.IsFalse (BigInteger.TryParse (" -", out x), "#4");
 938                         Assert.IsFalse (BigInteger.TryParse (" +", out x), "#5");
 939                         Assert.IsFalse (BigInteger.TryParse (" FF", out x), "#6");
 940
 941                         Assert.IsTrue (BigInteger.TryParse (" 99", out x), "#7");
 942                         Assert.AreEqual (99, (int)x, "#8");
 943
 944                         Assert.IsTrue (BigInteger.TryParse ("+133", out x), "#9");
 945                         Assert.AreEqual (133, (int)x, "#10");
 946
 947                         Assert.IsTrue (BigInteger.TryParse ("-010", out x), "#11");
 948                         Assert.AreEqual (-10, (int)x, "#12");
 949
 950                         //Number style and format provider
 951
 952                         Assert.IsFalse (BigInteger.TryParse ("null", NumberStyles.None, null, out x), "#13");
 953                         Assert.AreEqual (0, (int)x, "#14");
 954                         Assert.IsFalse (BigInteger.TryParse ("-10", NumberStyles.None, null, out x), "#15");
 955                         Assert.IsFalse (BigInteger.TryParse ("(10)", NumberStyles.None, null, out x), "#16");
 956                         Assert.IsFalse (BigInteger.TryParse (" 10", NumberStyles.None, null, out x), "#17");
 957                         Assert.IsFalse (BigInteger.TryParse ("10 ", NumberStyles.None, null, out x), "#18");
 958
 959                         Assert.IsTrue (BigInteger.TryParse ("-10", NumberStyles.AllowLeadingSign, null, out x), "#19");
 960                         Assert.AreEqual (-10, (int)x, "#20");
 961                         Assert.IsTrue (BigInteger.TryParse ("(10)", NumberStyles.AllowParentheses, null, out x), "#21");
 962                         Assert.AreEqual (-10, (int)x, "#22");
 963                         Assert.IsTrue (BigInteger.TryParse (" 10", NumberStyles.AllowLeadingWhite, null, out x), "#23");
 964                         Assert.AreEqual (10, (int)x, "#24");
 965                         Assert.IsTrue (BigInteger.TryParse ("10 ", NumberStyles.AllowTrailingWhite, null, out x), "#25");
 966                         Assert.AreEqual (10, (int)x, "#26");
 967
 968                         Assert.IsFalse (BigInteger.TryParse ("$10", NumberStyles.None, null, out x), "#26");
 969                         Assert.IsFalse (BigInteger.TryParse ("$10", NumberStyles.None, Nfi, out x), "#27");
 970                         Assert.IsFalse (BigInteger.TryParse ("%10", NumberStyles.None, Nfi, out x), "#28");
 971                         Assert.IsFalse (BigInteger.TryParse ("10 ", NumberStyles.None, null, out x), "#29");
 972
 973                         Assert.IsTrue (BigInteger.TryParse ("10", NumberStyles.None, null, out x), "#30");
 974                         Assert.AreEqual (10, (int)x, "#31");
 975                         Assert.IsTrue (BigInteger.TryParse (Nfi.CurrencySymbol + "10", NumberStyles.AllowCurrencySymbol, Nfi, out x), "#32");
 976                         Assert.AreEqual (10, (int)x, "#33");
 977                         Assert.IsFalse (BigInteger.TryParse ("%10", NumberStyles.AllowCurrencySymbol, Nfi, out x), "#34");
 978                 }
 979
 980                 [Test]
 981                 public void TestUserCurrency ()
 982                 {
 983                         const int val1 = -1234567;
 984                         const int val2 = 1234567;
 985
 986                         string s = "";
 987                         BigInteger v;
 988                         s = val1.ToString ("c", NfiUser);
 989                         Assert.AreEqual ("1234/5/67:000 XYZ-", s, "Currency value type 1 is not what we want to try to parse");
 990                         v = BigInteger.Parse ("1234/5/67:000   XYZ-", NumberStyles.Currency, NfiUser);
 991                         Assert.AreEqual (val1, (int)v);
 992
 993                         s = val2.ToString ("c", NfiUser);
 994                         Assert.AreEqual ("1234/5/67:000 XYZ", s, "Currency value type 2 is not what we want to try to parse");
 995                         v = BigInteger.Parse (s, NumberStyles.Currency, NfiUser);
 996                         Assert.AreEqual (val2, (int)v);
 997                 }
 998
 999                 [Test]
1000                 public void TryParseWeirdCulture () {
1001                         var old = Thread.CurrentThread.CurrentCulture;
1002                         var cur = (CultureInfo)old.Clone ();
1003
1004                         NumberFormatInfo ninfo = new NumberFormatInfo ();
1005                         ninfo.NegativeSign = ">";
1006                         ninfo.PositiveSign = "%";
1007                         cur.NumberFormat = ninfo;
1008
1009                         Thread.CurrentThread.CurrentCulture = cur;
1010
1011                         BigInteger x = BigInteger.Zero;
1012
1013                         try {
1014                                 Assert.IsTrue (BigInteger.TryParse ("%11", out x), "#1");
1015                                 Assert.AreEqual (11, (int)x, "#2");
1016
1017                                 Assert.IsTrue (BigInteger.TryParse (">11", out x), "#3");
1018                                 Assert.AreEqual (-11, (int)x, "#4");
1019                         } finally {
1020                                 Thread.CurrentThread.CurrentCulture = old;
1021                         }
1022                 }
1023
1024                 [Test]
1025                 public void CompareToLongToWithBigNumber () {
1026                         var a = BigInteger.Parse ("123456789123456789");
1027                         var b = BigInteger.Parse ("-123456789123456789");
1028                         Assert.AreEqual (1, a.CompareTo (2000));
1029                         Assert.AreEqual (1, a.CompareTo (-2000));
1030                         Assert.AreEqual (-1, b.CompareTo (2000));
1031                         Assert.AreEqual (-1, b.CompareTo (-2000));
1032                 }
1033
1034                 [Test]
1035                 public void LeftShitByInt ()
1036                 {
1037                         var v = BigInteger.Parse("230794411440927908251127453634");
1038
1039                         Assert.AreEqual ("230794411440927908251127453634", (v << 0).ToString (), "#0");
1040                         Assert.AreEqual ("461588822881855816502254907268", (v << 1).ToString (), "#1");
1041                         Assert.AreEqual ("923177645763711633004509814536", (v << 2).ToString (), "#2");
1042                         Assert.AreEqual ("1846355291527423266009019629072", (v << 3).ToString (), "#3");
1043                         Assert.AreEqual ("3692710583054846532018039258144", (v << 4).ToString (), "#4");
1044                         Assert.AreEqual ("7385421166109693064036078516288", (v << 5).ToString (), "#5");
1045                         Assert.AreEqual ("14770842332219386128072157032576", (v << 6).ToString (), "#6");
1046                         Assert.AreEqual ("29541684664438772256144314065152", (v << 7).ToString (), "#7");
1047                         Assert.AreEqual ("59083369328877544512288628130304", (v << 8).ToString (), "#8");
1048                         Assert.AreEqual ("118166738657755089024577256260608", (v << 9).ToString (), "#9");
1049                         Assert.AreEqual ("236333477315510178049154512521216", (v << 10).ToString (), "#10");
1050                         Assert.AreEqual ("472666954631020356098309025042432", (v << 11).ToString (), "#11");
1051                         Assert.AreEqual ("945333909262040712196618050084864", (v << 12).ToString (), "#12");
1052                         Assert.AreEqual ("1890667818524081424393236100169728", (v << 13).ToString (), "#13");
1053                         Assert.AreEqual ("3781335637048162848786472200339456", (v << 14).ToString (), "#14");
1054                         Assert.AreEqual ("7562671274096325697572944400678912", (v << 15).ToString (), "#15");
1055                         Assert.AreEqual ("15125342548192651395145888801357824", (v << 16).ToString (), "#16");
1056                         Assert.AreEqual ("30250685096385302790291777602715648", (v << 17).ToString (), "#17");
1057                         Assert.AreEqual ("60501370192770605580583555205431296", (v << 18).ToString (), "#18");
1058                         Assert.AreEqual ("121002740385541211161167110410862592", (v << 19).ToString (), "#19");
1059                         Assert.AreEqual ("242005480771082422322334220821725184", (v << 20).ToString (), "#20");
1060                         Assert.AreEqual ("484010961542164844644668441643450368", (v << 21).ToString (), "#21");
1061                         Assert.AreEqual ("968021923084329689289336883286900736", (v << 22).ToString (), "#22");
1062                         Assert.AreEqual ("1936043846168659378578673766573801472", (v << 23).ToString (), "#23");
1063                         Assert.AreEqual ("3872087692337318757157347533147602944", (v << 24).ToString (), "#24");
1064                         Assert.AreEqual ("7744175384674637514314695066295205888", (v << 25).ToString (), "#25");
1065                         Assert.AreEqual ("15488350769349275028629390132590411776", (v << 26).ToString (), "#26");
1066                         Assert.AreEqual ("30976701538698550057258780265180823552", (v << 27).ToString (), "#27");
1067                         Assert.AreEqual ("61953403077397100114517560530361647104", (v << 28).ToString (), "#28");
1068                         Assert.AreEqual ("123906806154794200229035121060723294208", (v << 29).ToString (), "#29");
1069                         Assert.AreEqual ("247813612309588400458070242121446588416", (v << 30).ToString (), "#30");
1070                         Assert.AreEqual ("495627224619176800916140484242893176832", (v << 31).ToString (), "#31");
1071                         Assert.AreEqual ("991254449238353601832280968485786353664", (v << 32).ToString (), "#32");
1072                         Assert.AreEqual ("1982508898476707203664561936971572707328", (v << 33).ToString (), "#33");
1073                         Assert.AreEqual ("3965017796953414407329123873943145414656", (v << 34).ToString (), "#34");
1074                         Assert.AreEqual ("7930035593906828814658247747886290829312", (v << 35).ToString (), "#35");
1075                         Assert.AreEqual ("15860071187813657629316495495772581658624", (v << 36).ToString (), "#36");
1076                         Assert.AreEqual ("31720142375627315258632990991545163317248", (v << 37).ToString (), "#37");
1077                         Assert.AreEqual ("63440284751254630517265981983090326634496", (v << 38).ToString (), "#38");
1078                         Assert.AreEqual ("126880569502509261034531963966180653268992", (v << 39).ToString (), "#39");
1079                         Assert.AreEqual ("253761139005018522069063927932361306537984", (v << 40).ToString (), "#40");
1080                         Assert.AreEqual ("507522278010037044138127855864722613075968", (v << 41).ToString (), "#41");
1081                         Assert.AreEqual ("1015044556020074088276255711729445226151936", (v << 42).ToString (), "#42");
1082                         Assert.AreEqual ("2030089112040148176552511423458890452303872", (v << 43).ToString (), "#43");
1083                         Assert.AreEqual ("4060178224080296353105022846917780904607744", (v << 44).ToString (), "#44");
1084                         Assert.AreEqual ("8120356448160592706210045693835561809215488", (v << 45).ToString (), "#45");
1085                         Assert.AreEqual ("16240712896321185412420091387671123618430976", (v << 46).ToString (), "#46");
1086                         Assert.AreEqual ("32481425792642370824840182775342247236861952", (v << 47).ToString (), "#47");
1087                         Assert.AreEqual ("64962851585284741649680365550684494473723904", (v << 48).ToString (), "#48");
1088                         Assert.AreEqual ("129925703170569483299360731101368988947447808", (v << 49).ToString (), "#49");
1089                         Assert.AreEqual ("259851406341138966598721462202737977894895616", (v << 50).ToString (), "#50");
1090                         Assert.AreEqual ("519702812682277933197442924405475955789791232", (v << 51).ToString (), "#51");
1091                         Assert.AreEqual ("1039405625364555866394885848810951911579582464", (v << 52).ToString (), "#52");
1092                         Assert.AreEqual ("2078811250729111732789771697621903823159164928", (v << 53).ToString (), "#53");
1093                         Assert.AreEqual ("4157622501458223465579543395243807646318329856", (v << 54).ToString (), "#54");
1094                         Assert.AreEqual ("8315245002916446931159086790487615292636659712", (v << 55).ToString (), "#55");
1095                         Assert.AreEqual ("16630490005832893862318173580975230585273319424", (v << 56).ToString (), "#56");
1096                         Assert.AreEqual ("33260980011665787724636347161950461170546638848", (v << 57).ToString (), "#57");
1097                         Assert.AreEqual ("66521960023331575449272694323900922341093277696", (v << 58).ToString (), "#58");
1098                         Assert.AreEqual ("133043920046663150898545388647801844682186555392", (v << 59).ToString (), "#59");
1099                         Assert.AreEqual ("266087840093326301797090777295603689364373110784", (v << 60).ToString (), "#60");
1100                         Assert.AreEqual ("532175680186652603594181554591207378728746221568", (v << 61).ToString (), "#61");
1101                         Assert.AreEqual ("1064351360373305207188363109182414757457492443136", (v << 62).ToString (), "#62");
1102                         Assert.AreEqual ("2128702720746610414376726218364829514914984886272", (v << 63).ToString (), "#63");
1103                         Assert.AreEqual ("4257405441493220828753452436729659029829969772544", (v << 64).ToString (), "#64");
1104                         Assert.AreEqual ("8514810882986441657506904873459318059659939545088", (v << 65).ToString (), "#65");
1105                         Assert.AreEqual ("17029621765972883315013809746918636119319879090176", (v << 66).ToString (), "#66");
1106                         Assert.AreEqual ("34059243531945766630027619493837272238639758180352", (v << 67).ToString (), "#67");
1107                         Assert.AreEqual ("68118487063891533260055238987674544477279516360704", (v << 68).ToString (), "#68");
1108                         Assert.AreEqual ("136236974127783066520110477975349088954559032721408", (v << 69).ToString (), "#69");
1109                 }
1110
1111
1112                 [Test]
1113                 public void RightShitByInt ()
1114                 {
1115                         var v = BigInteger.Parse("230794411440927908251127453634");
1116                         v = v * BigInteger.Pow (2, 70);
1117
1118                         Assert.AreEqual ("272473948255566133040220955950698177909118065442816", (v >> 0).ToString (), "#0");
1119                         Assert.AreEqual ("136236974127783066520110477975349088954559032721408", (v >> 1).ToString (), "#1");
1120                         Assert.AreEqual ("68118487063891533260055238987674544477279516360704", (v >> 2).ToString (), "#2");
1121                         Assert.AreEqual ("34059243531945766630027619493837272238639758180352", (v >> 3).ToString (), "#3");
1122                         Assert.AreEqual ("17029621765972883315013809746918636119319879090176", (v >> 4).ToString (), "#4");
1123                         Assert.AreEqual ("8514810882986441657506904873459318059659939545088", (v >> 5).ToString (), "#5");
1124                         Assert.AreEqual ("4257405441493220828753452436729659029829969772544", (v >> 6).ToString (), "#6");
1125                         Assert.AreEqual ("2128702720746610414376726218364829514914984886272", (v >> 7).ToString (), "#7");
1126                         Assert.AreEqual ("1064351360373305207188363109182414757457492443136", (v >> 8).ToString (), "#8");
1127                         Assert.AreEqual ("532175680186652603594181554591207378728746221568", (v >> 9).ToString (), "#9");
1128                         Assert.AreEqual ("266087840093326301797090777295603689364373110784", (v >> 10).ToString (), "#10");
1129                         Assert.AreEqual ("133043920046663150898545388647801844682186555392", (v >> 11).ToString (), "#11");
1130                         Assert.AreEqual ("66521960023331575449272694323900922341093277696", (v >> 12).ToString (), "#12");
1131                         Assert.AreEqual ("33260980011665787724636347161950461170546638848", (v >> 13).ToString (), "#13");
1132                         Assert.AreEqual ("16630490005832893862318173580975230585273319424", (v >> 14).ToString (), "#14");
1133                         Assert.AreEqual ("8315245002916446931159086790487615292636659712", (v >> 15).ToString (), "#15");
1134                         Assert.AreEqual ("4157622501458223465579543395243807646318329856", (v >> 16).ToString (), "#16");
1135                         Assert.AreEqual ("2078811250729111732789771697621903823159164928", (v >> 17).ToString (), "#17");
1136                         Assert.AreEqual ("1039405625364555866394885848810951911579582464", (v >> 18).ToString (), "#18");
1137                         Assert.AreEqual ("519702812682277933197442924405475955789791232", (v >> 19).ToString (), "#19");
1138                         Assert.AreEqual ("259851406341138966598721462202737977894895616", (v >> 20).ToString (), "#20");
1139                         Assert.AreEqual ("129925703170569483299360731101368988947447808", (v >> 21).ToString (), "#21");
1140                         Assert.AreEqual ("64962851585284741649680365550684494473723904", (v >> 22).ToString (), "#22");
1141                         Assert.AreEqual ("32481425792642370824840182775342247236861952", (v >> 23).ToString (), "#23");
1142                         Assert.AreEqual ("16240712896321185412420091387671123618430976", (v >> 24).ToString (), "#24");
1143                         Assert.AreEqual ("8120356448160592706210045693835561809215488", (v >> 25).ToString (), "#25");
1144                         Assert.AreEqual ("4060178224080296353105022846917780904607744", (v >> 26).ToString (), "#26");
1145                         Assert.AreEqual ("2030089112040148176552511423458890452303872", (v >> 27).ToString (), "#27");
1146                         Assert.AreEqual ("1015044556020074088276255711729445226151936", (v >> 28).ToString (), "#28");
1147                         Assert.AreEqual ("507522278010037044138127855864722613075968", (v >> 29).ToString (), "#29");
1148                         Assert.AreEqual ("253761139005018522069063927932361306537984", (v >> 30).ToString (), "#30");
1149                         Assert.AreEqual ("126880569502509261034531963966180653268992", (v >> 31).ToString (), "#31");
1150                         Assert.AreEqual ("63440284751254630517265981983090326634496", (v >> 32).ToString (), "#32");
1151                         Assert.AreEqual ("31720142375627315258632990991545163317248", (v >> 33).ToString (), "#33");
1152                         Assert.AreEqual ("15860071187813657629316495495772581658624", (v >> 34).ToString (), "#34");
1153                         Assert.AreEqual ("7930035593906828814658247747886290829312", (v >> 35).ToString (), "#35");
1154                         Assert.AreEqual ("3965017796953414407329123873943145414656", (v >> 36).ToString (), "#36");
1155                         Assert.AreEqual ("1982508898476707203664561936971572707328", (v >> 37).ToString (), "#37");
1156                         Assert.AreEqual ("991254449238353601832280968485786353664", (v >> 38).ToString (), "#38");
1157                         Assert.AreEqual ("495627224619176800916140484242893176832", (v >> 39).ToString (), "#39");
1158                         Assert.AreEqual ("247813612309588400458070242121446588416", (v >> 40).ToString (), "#40");
1159                         Assert.AreEqual ("123906806154794200229035121060723294208", (v >> 41).ToString (), "#41");
1160                         Assert.AreEqual ("61953403077397100114517560530361647104", (v >> 42).ToString (), "#42");
1161                         Assert.AreEqual ("30976701538698550057258780265180823552", (v >> 43).ToString (), "#43");
1162                         Assert.AreEqual ("15488350769349275028629390132590411776", (v >> 44).ToString (), "#44");
1163                         Assert.AreEqual ("7744175384674637514314695066295205888", (v >> 45).ToString (), "#45");
1164                         Assert.AreEqual ("3872087692337318757157347533147602944", (v >> 46).ToString (), "#46");
1165                         Assert.AreEqual ("1936043846168659378578673766573801472", (v >> 47).ToString (), "#47");
1166                         Assert.AreEqual ("968021923084329689289336883286900736", (v >> 48).ToString (), "#48");
1167                         Assert.AreEqual ("484010961542164844644668441643450368", (v >> 49).ToString (), "#49");
1168                         Assert.AreEqual ("242005480771082422322334220821725184", (v >> 50).ToString (), "#50");
1169                         Assert.AreEqual ("121002740385541211161167110410862592", (v >> 51).ToString (), "#51");
1170                         Assert.AreEqual ("60501370192770605580583555205431296", (v >> 52).ToString (), "#52");
1171                         Assert.AreEqual ("30250685096385302790291777602715648", (v >> 53).ToString (), "#53");
1172                         Assert.AreEqual ("15125342548192651395145888801357824", (v >> 54).ToString (), "#54");
1173                         Assert.AreEqual ("7562671274096325697572944400678912", (v >> 55).ToString (), "#55");
1174                         Assert.AreEqual ("3781335637048162848786472200339456", (v >> 56).ToString (), "#56");
1175                         Assert.AreEqual ("1890667818524081424393236100169728", (v >> 57).ToString (), "#57");
1176                         Assert.AreEqual ("945333909262040712196618050084864", (v >> 58).ToString (), "#58");
1177                         Assert.AreEqual ("472666954631020356098309025042432", (v >> 59).ToString (), "#59");
1178                         Assert.AreEqual ("236333477315510178049154512521216", (v >> 60).ToString (), "#60");
1179                         Assert.AreEqual ("118166738657755089024577256260608", (v >> 61).ToString (), "#61");
1180                         Assert.AreEqual ("59083369328877544512288628130304", (v >> 62).ToString (), "#62");
1181                         Assert.AreEqual ("29541684664438772256144314065152", (v >> 63).ToString (), "#63");
1182                         Assert.AreEqual ("14770842332219386128072157032576", (v >> 64).ToString (), "#64");
1183                         Assert.AreEqual ("7385421166109693064036078516288", (v >> 65).ToString (), "#65");
1184                         Assert.AreEqual ("3692710583054846532018039258144", (v >> 66).ToString (), "#66");
1185                         Assert.AreEqual ("1846355291527423266009019629072", (v >> 67).ToString (), "#67");
1186                         Assert.AreEqual ("923177645763711633004509814536", (v >> 68).ToString (), "#68");
1187                         Assert.AreEqual ("461588822881855816502254907268", (v >> 69).ToString (), "#69");
1188                 }
1189
1190                 [Test]
1191                 public void Bug10887 ()
1192                 {
1193                         BigInteger b = 0;
1194                         for(int i = 1; i <= 16; i++)
1195                                 b = b * 256 + i;
1196                         BigInteger p = BigInteger.Pow (2, 32);
1197                         Assert.AreEqual ("1339673755198158349044581307228491536", b.ToString (), "#1");
1198                         Assert.AreEqual ("1339673755198158349044581307228491536", ((b << 32) / p).ToString (), "#2");
1199                         Assert.AreEqual ("1339673755198158349044581307228491536", (b * p >> 32).ToString (), "#3");
1200                 }
1201
1202                 [Test]
1203                 public void DefaultCtorWorks ()
1204                 {
1205                         var a = new BigInteger ();
1206                         Assert.AreEqual (BigInteger.One, ++a, "#1");
1207
1208                         a = new BigInteger ();
1209                         Assert.AreEqual (BigInteger.MinusOne, --a, "#2");
1210
1211                         a = new BigInteger ();
1212                         Assert.AreEqual (BigInteger.MinusOne, ~a, "#3");
1213
1214                         a = new BigInteger ();
1215                         Assert.AreEqual ("0", a.ToString (), "#4");
1216
1217                         a = new BigInteger ();
1218                         Assert.AreEqual (true, a == a, "#5");
1219
1220                         a = new BigInteger ();
1221                         Assert.AreEqual (false, a < a, "#6");
1222
1223                         a = new BigInteger ();
1224                         Assert.AreEqual (true, a < 10l, "#7");
1225
1226                         a = new BigInteger ();
1227                         Assert.AreEqual (true, a.IsEven, "#8");
1228
1229                         a = new BigInteger ();
1230                         Assert.AreEqual (0, (int)a, "#9");
1231
1232                         a = new BigInteger ();
1233                         Assert.AreEqual (0, (uint)a, "#10");
1234
1235                         a = new BigInteger ();
1236                         Assert.AreEqual (0, (ulong)a, "#11");
1237
1238                         a = new BigInteger ();
1239                         Assert.AreEqual (true, a.Equals (a), "#12");
1240
1241                         a = new BigInteger ();
1242                         Assert.AreEqual (a, BigInteger.Min (a, a), "#13");
1243
1244                         a = new BigInteger ();
1245                         Assert.AreEqual (a, BigInteger.GreatestCommonDivisor (a, a), "#14");
1246
1247                         a = new BigInteger ();
1248                         Assert.AreEqual (BigInteger.Zero.GetHashCode (), a.GetHashCode (), "#15");
1249                 }
1250
1251                 [Test]
1252                 public void Bug16526 ()
1253                 {
1254                         var x = BigInteger.Pow(2, 63);
1255                         x *= -1;
1256                         x -= 1;
1257                         Assert.AreEqual ("-9223372036854775809", x.ToString (), "#1");
1258                         try {
1259                                 x = (long)x;
1260                                 Assert.Fail ("#2 Must OVF");
1261                         } catch (OverflowException) {
1262                         }
1263                 }
1264         }
1265 }