mcs/class/corlib/Test/System/DecimalTest.cs

   1 // DecimalTest.cs - NUnit Test Cases for the System.Decimal struct
   2 //
   3 // Authors:
   4 //      Martin Weindel (martin.weindel@t-online.de)
   5 //      Sebastien Pouliot  <sebastien@ximian.com>
   6 //
   7 // (C) Martin Weindel, 2001
   8 // Copyright (C) 2004 Novell (http://www.novell.com)
   9 //
  10
  11 using NUnit.Framework;
  12 using System;
  13
  14 using System.Globalization;
  15 using System.Runtime.CompilerServices;
  16 using System.Threading;
  17
  18 namespace MonoTests.System
  19 {
  20         internal struct ParseTest
  21         {
  22                 public ParseTest (String str, bool exceptionFlag)
  23                 {
  24                         this.str = str;
  25                         this.exceptionFlag = exceptionFlag;
  26                         this.style = NumberStyles.Number;
  27                         this.d = 0;
  28                 }
  29
  30                 public ParseTest (String str, Decimal d)
  31                 {
  32                         this.str = str;
  33                         this.exceptionFlag = false;
  34                         this.style = NumberStyles.Number;
  35                         this.d = d;
  36                 }
  37
  38                 public ParseTest (String str, Decimal d, NumberStyles style)
  39                 {
  40                         this.str = str;
  41                         this.exceptionFlag = false;
  42                         this.style = style;
  43                         this.d = d;
  44                 }
  45
  46                 public String str;
  47                 public Decimal d;
  48                 public NumberStyles style;
  49                 public bool exceptionFlag;
  50         }
  51
  52         internal struct ToStringTest
  53         {
  54                 public ToStringTest (String format, Decimal d, String str)
  55                 {
  56                         this.format = format;
  57                         this.d = d;
  58                         this.str = str;
  59                 }
  60
  61                 public String format;
  62                 public Decimal d;
  63                 public String str;
  64         }
  65
  66         [TestFixture]
  67         public class DecimalTest
  68         {
  69                 private const int negativeBitValue = unchecked ((int) 0x80000000);
  70                 private const int negativeScale4Value = unchecked ((int) 0x80040000);
  71                 private int [] parts0 = { 0, 0, 0, 0 }; //Positive Zero.
  72                 private int [] parts1 = { 1, 0, 0, 0 };
  73                 private int [] parts2 = { 0, 1, 0, 0 };
  74                 private int [] parts3 = { 0, 0, 1, 0 };
  75                 private int [] parts4 = { 0, 0, 0, negativeBitValue }; // Negative zero.
  76                 private int [] parts5 = { 1, 1, 1, 0 };
  77                 private int [] partsMaxValue = { -1, -1, -1, 0 };
  78                 private int [] partsMinValue = { -1, -1, -1, negativeBitValue };
  79                 private int [] parts6 = { 1234, 5678, 8888, negativeScale4Value };
  80                 private NumberFormatInfo NfiUser, NfiBroken;
  81
  82                 private CultureInfo old_culture;
  83
  84                 [TestFixtureSetUp]
  85                 public void FixtureSetUp ()
  86                 {
  87                         old_culture = Thread.CurrentThread.CurrentCulture;
  88
  89                         // Set culture to en-US and don't let the user override.
  90                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
  91
  92                         NfiUser = new NumberFormatInfo ();
  93                         NfiUser.CurrencyDecimalDigits = 3;
  94                         NfiUser.CurrencyDecimalSeparator = ",";
  95                         NfiUser.CurrencyGroupSeparator = "_";
  96                         NfiUser.CurrencyGroupSizes = new int [] { 2, 1, 0 };
  97                         NfiUser.CurrencyNegativePattern = 10;
  98                         NfiUser.CurrencyPositivePattern = 3;
  99                         NfiUser.CurrencySymbol = "XYZ";
 100                         NfiUser.NumberDecimalSeparator = "##";
 101                         NfiUser.NumberDecimalDigits = 4;
 102                         NfiUser.NumberGroupSeparator = "__";
 103                         NfiUser.NumberGroupSizes = new int [] { 2, 1 };
 104                         NfiUser.PercentDecimalDigits = 1;
 105                         NfiUser.PercentDecimalSeparator = ";";
 106                         NfiUser.PercentGroupSeparator = "~";
 107                         NfiUser.PercentGroupSizes = new int [] { 1 };
 108                         NfiUser.PercentNegativePattern = 2;
 109                         NfiUser.PercentPositivePattern = 2;
 110                         NfiUser.PercentSymbol = "%%%";
 111
 112                         NfiBroken = new NumberFormatInfo ();
 113                         NfiBroken.NumberDecimalSeparator = ".";
 114                         NfiBroken.NumberGroupSeparator = ".";
 115                         NfiBroken.CurrencyDecimalSeparator = ".";
 116                         NfiBroken.CurrencyGroupSeparator = ".";
 117                 }
 118
 119                 [TestFixtureTearDown]
 120                 public void FixtureTearDown ()
 121                 {
 122                         Thread.CurrentThread.CurrentCulture = old_culture;
 123                 }
 124
 125                 [Test]
 126                 public void TestToString ()
 127                 {
 128                         ToStringTest [] tab = {
 129                                 new ToStringTest ("F", 12.345678m, "12.35"),
 130                                 new ToStringTest ("F3", 12.345678m, "12.346"),
 131                                 new ToStringTest ("F0", 12.345678m, "12"),
 132                                 new ToStringTest ("F7", 12.345678m, "12.3456780"),
 133                                 new ToStringTest ("g", 12.345678m, "12.345678"),
 134                                 new ToStringTest ("E", 12.345678m, "1.234568E+001"),
 135                                 new ToStringTest ("E3", 12.345678m, "1.235E+001"),
 136                                 new ToStringTest ("E0", 12.345678m, "1E+001"),
 137                                 new ToStringTest ("e8", 12.345678m, "1.23456780e+001"),
 138                                 new ToStringTest ("F", 0.0012m, "0.00"),
 139                                 new ToStringTest ("F3", 0.0012m, "0.001"),
 140                                 new ToStringTest ("F0", 0.0012m, "0"),
 141                                 new ToStringTest ("F6", 0.0012m, "0.001200"),
 142                                 new ToStringTest ("e", 0.0012m, "1.200000e-003"),
 143                                 new ToStringTest ("E3", 0.0012m, "1.200E-003"),
 144                                 new ToStringTest ("E0", 0.0012m, "1E-003"),
 145                                 new ToStringTest ("E6", 0.0012m, "1.200000E-003"),
 146                                 new ToStringTest ("F4", -0.001234m, "-0.0012"),
 147                                 new ToStringTest ("E3", -0.001234m, "-1.234E-003"),
 148                                 new ToStringTest ("g", -0.000012m, "-0.000012"),
 149                                 new ToStringTest ("g0", -0.000012m, "-1.2e-05"),
 150                                 new ToStringTest ("g2", -0.000012m, "-1.2e-05"),
 151                                 new ToStringTest ("g20", -0.000012m, "-1.2e-05"),
 152                                 new ToStringTest ("g", -0.00012m, "-0.00012"),
 153                                 new ToStringTest ("g4", -0.00012m, "-0.00012"),
 154                                 new ToStringTest ("g7", -0.00012m, "-0.00012"),
 155                                 new ToStringTest ("g", -0.0001234m, "-0.0001234"),
 156                                 new ToStringTest ("g", -0.0012m, "-0.0012"),
 157                                 new ToStringTest ("g", -0.001234m, "-0.001234"),
 158                                 new ToStringTest ("g", -0.012m, "-0.012"),
 159                                 new ToStringTest ("g4", -0.012m, "-0.012"),
 160                                 new ToStringTest ("g", -0.12m, "-0.12"),
 161                                 new ToStringTest ("g", -1.2m, "-1.2"),
 162                                 new ToStringTest ("g4", -120m, "-120"),
 163                                 new ToStringTest ("g", -12.000m, "-12.000"),
 164                                 new ToStringTest ("g0", -12.000m, "-12"),
 165                                 new ToStringTest ("g6", -12.000m, "-12"),
 166                                 new ToStringTest ("g", -12m, "-12"),
 167                                 new ToStringTest ("g", -120m, "-120"),
 168                                 new ToStringTest ("g", -1200m, "-1200"),
 169                                 new ToStringTest ("g4", -1200m, "-1200"),
 170                                 new ToStringTest ("g", -1234m, "-1234"),
 171                                 new ToStringTest ("g", -12000m, "-12000"),
 172                                 new ToStringTest ("g4", -12000m, "-1.2e+04"),
 173                                 new ToStringTest ("g5", -12000m, "-12000"),
 174                                 new ToStringTest ("g", -12345m, "-12345"),
 175                                 new ToStringTest ("g", -120000m, "-120000"),
 176                                 new ToStringTest ("g4", -120000m, "-1.2e+05"),
 177                                 new ToStringTest ("g5", -120000m, "-1.2e+05"),
 178                                 new ToStringTest ("g6", -120000m, "-120000"),
 179                                 new ToStringTest ("g", -123456.1m, "-123456.1"),
 180                                 new ToStringTest ("g5", -123456.1m, "-1.2346e+05"),
 181                                 new ToStringTest ("g6", -123456.1m, "-123456"),
 182                                 new ToStringTest ("g", -1200000m, "-1200000"),
 183                                 new ToStringTest ("g", -123456.1m, "-123456.1"),
 184                                 new ToStringTest ("g", -123456.1m, "-123456.1"),
 185                                 new ToStringTest ("g", -1234567.1m, "-1234567.1"),
 186                                 new ToStringTest ("g", -12000000m, "-12000000"),
 187                                 new ToStringTest ("g", -12345678.1m, "-12345678.1"),
 188                                 new ToStringTest ("g", -12000000000000000000m, "-12000000000000000000"),
 189                                 new ToStringTest ("F", -123, "-123.00"),
 190                                 new ToStringTest ("F3", -123, "-123.000"),
 191                                 new ToStringTest ("F0", -123, "-123"),
 192                                 new ToStringTest ("E3", -123, "-1.230E+002"),
 193                                 new ToStringTest ("E0", -123, "-1E+002"),
 194                                 new ToStringTest ("E", -123, "-1.230000E+002"),
 195                                 new ToStringTest ("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),
 196                                 new ToStringTest ("F", Decimal.MinValue, "-79228162514264337593543950335.00"),
 197                                 new ToStringTest ("F0", Decimal.MinValue, "-79228162514264337593543950335"),
 198                                 new ToStringTest ("E", Decimal.MinValue, "-7.922816E+028"),
 199                                 new ToStringTest ("E3", Decimal.MinValue, "-7.923E+028"),
 200                                 new ToStringTest ("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),
 201 #if !TARGET_JVM // TargetJvmNotWorking
 202                                 new ToStringTest ("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),
 203 #endif
 204                                 new ToStringTest ("E0", Decimal.MinValue, "-8E+028"),
 205                                 new ToStringTest ("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
 206                                 new ToStringTest ("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
 207                                 new ToStringTest ("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
 208                                 new ToStringTest ("n3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
 209                                 new ToStringTest ("n0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
 210                                 new ToStringTest ("n", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
 211                                 new ToStringTest ("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),
 212                                 new ToStringTest ("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),
 213                                 new ToStringTest ("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),
 214                                 new ToStringTest ("P", 123456.7891m, "12,345,678.91 %"),
 215                                 new ToStringTest ("P", -123456.7892m, "-12,345,678.92 %"),
 216                                 new ToStringTest ("P3", 1234.56789m, "123,456.789 %"),
 217                         };
 218
 219                         NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
 220
 221                         for (int i = 0; i < tab.Length; i++) {
 222                                 try {
 223                                         string s = tab [i].d.ToString (tab [i].format, nfi);
 224                                         Assert.AreEqual (tab [i].str, s, "A01 tab[" + i + "].format = '" + tab [i].format + "')");
 225                                 } catch (OverflowException) {
 226                                         Assert.Fail (tab [i].d.ToString (tab [i].format, nfi) + " (format = '" + tab [i].format + "'): unexpected exception !");
 227                                 } catch (NUnit.Framework.AssertionException e) {
 228                                         throw e;
 229                                 } catch (Exception e) {
 230                                         Assert.Fail ("Unexpected Exception when i = " + i + ". e = " + e);
 231                                 }
 232                         }
 233                 }
 234
 235                 [Test]
 236                 public void TestCurrencyPattern ()
 237                 {
 238                         NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
 239                         Decimal d = -1234567.8976m;
 240                         string [] ergCurrencyNegativePattern = new String [16] {
 241                                 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
 242                                 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
 243                                 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
 244                                 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
 245                         };
 246
 247                         for (int i = 0; i < ergCurrencyNegativePattern.Length; i++) {
 248                                 nfi2.CurrencyNegativePattern = i;
 249                                 if (d.ToString ("C", nfi2) != ergCurrencyNegativePattern [i]) {
 250                                         Assert.Fail ("CurrencyNegativePattern #" + i + " failed: " +
 251                                                 d.ToString ("C", nfi2) + " != " + ergCurrencyNegativePattern [i]);
 252                                 }
 253                         }
 254
 255                         d = 1234567.8976m;
 256                         string [] ergCurrencyPositivePattern = new String [4] {
 257                                 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
 258                         };
 259
 260                         for (int i = 0; i < ergCurrencyPositivePattern.Length; i++) {
 261                                 nfi2.CurrencyPositivePattern = i;
 262                                 if (d.ToString ("C", nfi2) != ergCurrencyPositivePattern [i]) {
 263                                         Assert.Fail ("CurrencyPositivePattern #" + i + " failed: " +
 264                                                 d.ToString ("C", nfi2) + " != " + ergCurrencyPositivePattern [i]);
 265                                 }
 266                         }
 267                 }
 268
 269                 [Test]
 270                 public void TestNumberNegativePattern ()
 271                 {
 272                         NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
 273                         Decimal d = -1234.89765m;
 274                         string [] ergNumberNegativePattern = new String [5] {
 275                                 "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",
 276                         };
 277
 278                         for (int i = 0; i < ergNumberNegativePattern.Length; i++) {
 279                                 nfi2.NumberNegativePattern = i;
 280                                 Assert.AreEqual (ergNumberNegativePattern [i], d.ToString ("N", nfi2), "NumberNegativePattern #" + i);
 281                         }
 282                 }
 283
 284                 [Test]
 285                 public void TestBrokenNFI ()
 286                 {
 287                         Assert.AreEqual (5.3m, decimal.Parse ("5.3", NumberStyles.Number, NfiBroken), "Parsing with broken NFI");
 288                 }
 289
 290                 [Test]
 291                 [Category ("TargetJvmNotWorking")]
 292                 public void TestPercentPattern ()
 293                 {
 294                         NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
 295                         Decimal d = -1234.8976m;
 296                         string [] ergPercentNegativePattern = new String [3] {
 297                                 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
 298                         };
 299
 300                         for (int i = 0; i < ergPercentNegativePattern.Length; i++) {
 301                                 nfi2.PercentNegativePattern = i;
 302                                 if (d.ToString ("P", nfi2) != ergPercentNegativePattern [i]) {
 303                                         Assert.Fail ("PercentNegativePattern #" + i + " failed: " +
 304                                                 d.ToString ("P", nfi2) + " != " + ergPercentNegativePattern [i]);
 305                                 }
 306                         }
 307
 308                         d = 1234.8976m;
 309                         string [] ergPercentPositivePattern = new String [3] {
 310                                 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
 311                         };
 312
 313                         for (int i = 0; i < ergPercentPositivePattern.Length; i++) {
 314                                 nfi2.PercentPositivePattern = i;
 315                                 if (d.ToString ("P", nfi2) != ergPercentPositivePattern [i]) {
 316                                         Assert.Fail ("PercentPositivePattern #" + i + " failed: " +
 317                                                 d.ToString ("P", nfi2) + " != " + ergPercentPositivePattern [i]);
 318                                 }
 319                         }
 320                 }
 321
 322                 ParseTest [] tab = {
 323                                 new ParseTest("1.2345", 1.2345m),
 324                                 new ParseTest("1.2345\0", 1.2345m),
 325                                 new ParseTest("1.2345\0\0\0\0", 1.2345m),
 326                                 new ParseTest("-9876543210", -9876543210m),
 327                                 new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol
 328                                         + " (  79,228,162,514,264,337,593,543,950,335.000 ) ",
 329                                         Decimal.MinValue, NumberStyles.Currency),
 330                                 new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),
 331                                 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
 332                                 new ParseTest("  47896396.457983645462346E10  ", 478963964579836454.62346m, NumberStyles.Float),
 333                                 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
 334                                 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
 335                                 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
 336                                 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
 337                                 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
 338                                 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
 339                 };
 340
 341                 [Test]
 342                 [Category ("TargetJvmNotWorking")]
 343                 public void TestParse ()
 344                 {
 345
 346                         Decimal d;
 347                         for (int i = 0; i < tab.Length; i++) {
 348                                 try {
 349                                         d = Decimal.Parse (tab [i].str, tab [i].style, NumberFormatInfo.InvariantInfo);
 350                                         if (tab [i].exceptionFlag) {
 351                                                 Assert.Fail (tab [i].str + ": missing exception !");
 352                                         } else if (d != tab [i].d) {
 353                                                 Assert.Fail (tab [i].str + " != " + d);
 354                                         }
 355                                 } catch (OverflowException) {
 356                                         if (!tab [i].exceptionFlag) {
 357                                                 Assert.Fail (tab [i].str + ": unexpected exception !");
 358                                         }
 359                                 }
 360                         }
 361
 362                         try {
 363                                 d = Decimal.Parse (null);
 364                                 Assert.Fail ("Expected ArgumentNullException");
 365                         } catch (ArgumentNullException) {
 366                                 //ok
 367                         }
 368
 369                         try {
 370                                 d = Decimal.Parse ("123nx");
 371                                 Assert.Fail ("Expected FormatException");
 372                         } catch (FormatException) {
 373                                 //ok
 374                         }
 375
 376                         try {
 377                                 d = Decimal.Parse ("79228162514264337593543950336");
 378                                 Assert.Fail ("Expected OverflowException" + d);
 379                         } catch (OverflowException) {
 380                                 //ok
 381                         }
 382
 383                         try {
 384                                 d = Decimal.Parse ("5\05");
 385                                 Assert.Fail ("Expected FormatException" + d);
 386                         } catch (FormatException) {
 387                                 //ok
 388                         }
 389                 }
 390
 391                 [Test]
 392                 public void TestConstants ()
 393                 {
 394                         Assert.AreEqual (0m, Decimal.Zero, "Zero");
 395                         Assert.AreEqual (1m, Decimal.One, "One");
 396                         Assert.AreEqual (-1m, Decimal.MinusOne, "MinusOne");
 397                         Assert.AreEqual (79228162514264337593543950335m, Decimal.MaxValue, "MaxValue");
 398                         Assert.AreEqual (-79228162514264337593543950335m, Decimal.MinValue, "MinValue");
 399                         Assert.IsTrue (-1m == Decimal.MinusOne, "MinusOne 2");
 400                 }
 401
 402                 [Test]
 403                 public void TestConstructInt32 ()
 404                 {
 405                         decimal [] dtab = { 0m, 1m, -1m, 123456m, -1234567m };
 406                         int [] itab = { 0, 1, -1, 123456, -1234567 };
 407
 408                         Decimal d;
 409
 410                         for (int i = 0; i < dtab.GetLength (0); i++) {
 411                                 d = new Decimal (itab [i]);
 412                                 if ((decimal) d != dtab [i]) {
 413                                         Assert.Fail ("Int32 -> Decimal: " + itab [i] + " != " + d);
 414                                 } else {
 415                                         int n = (int) d;
 416                                         if (n != itab [i]) {
 417                                                 Assert.Fail ("Decimal -> Int32: " + d + " != " + itab [i]);
 418                                         }
 419                                 }
 420                         }
 421
 422                         d = new Decimal (Int32.MaxValue);
 423                         Assert.IsTrue ((int) d == Int32.MaxValue);
 424
 425                         d = new Decimal (Int32.MinValue);
 426                         Assert.IsTrue ((int) d == Int32.MinValue);
 427                 }
 428
 429                 [Test]
 430                 public void TestConstructUInt32 ()
 431                 {
 432                         decimal [] dtab = { 0m, 1m, 123456m, 123456789m };
 433                         uint [] itab = { 0, 1, 123456, 123456789 };
 434
 435                         Decimal d;
 436
 437                         for (int i = 0; i < dtab.GetLength (0); i++) {
 438                                 d = new Decimal (itab [i]);
 439                                 if ((decimal) d != dtab [i]) {
 440                                         Assert.Fail ("UInt32 -> Decimal: " + itab [i] + " != " + d);
 441                                 } else {
 442                                         uint n = (uint) d;
 443                                         if (n != itab [i]) {
 444                                                 Assert.Fail ("Decimal -> UInt32: " + d + " != " + itab [i]);
 445                                         }
 446                                 }
 447                         }
 448
 449                         d = new Decimal (UInt32.MaxValue);
 450                         Assert.IsTrue ((uint) d == UInt32.MaxValue);
 451
 452                         d = new Decimal (UInt32.MinValue);
 453                         Assert.IsTrue ((uint) d == UInt32.MinValue);
 454                 }
 455
 456                 [Test]
 457                 public void TestConstructInt64 ()
 458                 {
 459                         decimal [] dtab = { 0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m };
 460                         long [] itab = { 0, 1, -1, 9876543, -9876543210L, 12345678987654321L };
 461
 462                         Decimal d;
 463
 464                         for (int i = 0; i < dtab.GetLength (0); i++) {
 465                                 d = new Decimal (itab [i]);
 466                                 if ((decimal) d != dtab [i]) {
 467                                         Assert.Fail ("Int64 -> Decimal: " + itab [i] + " != " + d);
 468                                 } else {
 469                                         long n = (long) d;
 470                                         if (n != itab [i]) {
 471                                                 Assert.Fail ("Decimal -> Int64: " + d + " != " + itab [i]);
 472                                         }
 473                                 }
 474                         }
 475
 476                         d = new Decimal (Int64.MaxValue);
 477                         Assert.IsTrue ((long) d == Int64.MaxValue);
 478
 479                         d = new Decimal (Int64.MinValue);
 480                         Assert.IsTrue ((long) d == Int64.MinValue);
 481                 }
 482
 483                 [Test]
 484                 public void TestConstructUInt64 ()
 485                 {
 486                         decimal [] dtab = { 0m, 1m, 987654321m, 123456789876543210m };
 487                         ulong [] itab = { 0, 1, 987654321, 123456789876543210L };
 488
 489                         Decimal d;
 490
 491                         for (int i = 0; i < dtab.GetLength (0); i++) {
 492                                 d = new Decimal (itab [i]);
 493                                 if ((decimal) d != dtab [i]) {
 494                                         Assert.Fail ("UInt64 -> Decimal: " + itab [i] + " != " + d);
 495                                 } else {
 496                                         ulong n = (ulong) d;
 497                                         if (n != itab [i]) {
 498                                                 Assert.Fail ("Decimal -> UInt64: " + d + " != " + itab [i]);
 499                                         }
 500                                 }
 501                         }
 502
 503                         d = new Decimal (UInt64.MaxValue);
 504                         Assert.IsTrue ((ulong) d == UInt64.MaxValue);
 505
 506                         d = new Decimal (UInt64.MinValue);
 507                         Assert.IsTrue ((ulong) d == UInt64.MinValue);
 508                 }
 509
 510                 [Test]
 511                 public void TestConstructSingle ()
 512                 {
 513                         Decimal d;
 514
 515                         d = new Decimal (-1.2345678f);
 516                         Assert.AreEqual (-1.234568m, (decimal) d, "A#01");
 517
 518                         d = 3;
 519                         Assert.AreEqual (3.0f, (float) d, "A#02");
 520
 521                         d = new Decimal (0.0f);
 522                         Assert.AreEqual (0m, (decimal) d, "A#03");
 523                         Assert.AreEqual (0.0f, (float) d, "A#04");
 524
 525                         d = new Decimal (1.0f);
 526                         Assert.AreEqual (1m, (decimal) d, "A#05");
 527                         Assert.AreEqual (1.0f, (float) d, "A#06");
 528
 529                         d = new Decimal (-1.2345678f);
 530                         Assert.AreEqual (-1.234568m, (decimal) d, "A#07");
 531                         Assert.AreEqual (-1.234568f, (float) d, "A#08");
 532
 533                         d = new Decimal (1.2345673f);
 534                         Assert.AreEqual (1.234567m, (decimal) d, "A#09");
 535
 536                         d = new Decimal (1.2345673e7f);
 537                         Assert.AreEqual (12345670m, (decimal) d, "A#10");
 538
 539                         d = new Decimal (1.2345673e-17f);
 540                         Assert.AreEqual (0.00000000000000001234567m, (decimal) d, "A#11");
 541                         Assert.AreEqual (1.234567e-17f, (float) d, "A#12");
 542
 543                         // test exceptions
 544                         try {
 545                                 d = new Decimal (Single.MaxValue);
 546                                 Assert.Fail ();
 547                         } catch (OverflowException) {
 548                         }
 549
 550                         try {
 551                                 d = new Decimal (Single.NaN);
 552                                 Assert.Fail ();
 553                         } catch (OverflowException) {
 554                         }
 555
 556                         try {
 557                                 d = new Decimal (Single.PositiveInfinity);
 558                                 Assert.Fail ();
 559                         } catch (OverflowException) {
 560                         }
 561                 }
 562
 563                 [Test]
 564                 public void TestConstructSingleRounding_NowWorking ()
 565                 {
 566                         decimal d;
 567
 568                         d = new Decimal (1765.23454f);
 569                         Assert.AreEqual (1765.234m, d, "failed banker's rule rounding test 2");
 570
 571                         d = new Decimal (0.00017652356f);
 572                         Assert.AreEqual (0.0001765236m, d, "06");
 573
 574                         d = new Decimal (0.000176523554f);
 575                         Assert.AreEqual (0.0001765236m, d, "failed banker's rule rounding test 3");
 576
 577                         d = new Decimal (0.00017652354f);
 578                         Assert.AreEqual (0.0001765235m, d, "08");
 579
 580                         d = new Decimal (0.00017652346f);
 581                         Assert.AreEqual (0.0001765235m, d, "09");
 582
 583                         d = new Decimal (0.000176523454f);
 584                         Assert.AreEqual (0.0001765234m, d, "failed banker's rule rounding test 4");
 585
 586                         d = new Decimal (0.00017652344f);
 587                         Assert.AreEqual (0.0001765234m, d, "11");
 588                 }
 589
 590                 public void TestConstructSingleRounding ()
 591                 {
 592                         decimal d;
 593
 594                         d = new Decimal (1765.2356f);
 595                         Assert.IsTrue (d == 1765.236m, "01");
 596
 597                         d = new Decimal (1765.23554f);
 598                         Assert.IsTrue (d == 1765.236m, "failed banker's rule rounding test 1");
 599
 600                         d = new Decimal (1765.2354f);
 601                         Assert.IsTrue (d == 1765.235m, "03");
 602
 603                         d = new Decimal (1765.2346f);
 604                         Assert.IsTrue (d == 1765.235m, "04");
 605
 606                         d = new Decimal (1765.2344f);
 607                         Assert.IsTrue (d == 1765.234m, "05");
 608
 609                         d = new Decimal (3.7652356e10f);
 610                         Assert.IsTrue (d == 37652360000m, "12");
 611
 612                         d = new Decimal (3.7652356e20f);
 613                         Assert.IsTrue (d == 376523600000000000000m, "13");
 614
 615                         d = new Decimal (3.76523554e20f);
 616                         Assert.IsTrue (d == 376523600000000000000m, "failed banker's rule rounding test 5");
 617
 618                         d = new Decimal (3.7652352e20f);
 619                         Assert.IsTrue (d == 376523500000000000000m, "15");
 620
 621                         d = new Decimal (3.7652348e20f);
 622                         Assert.IsTrue (d == 376523500000000000000m, "16");
 623
 624                         d = new Decimal (3.76523454e20f);
 625                         Assert.IsTrue (d == 376523400000000000000m, "failed banker's rule rounding test 6");
 626
 627                         d = new Decimal (3.7652342e20f);
 628                         Assert.IsTrue (d == 376523400000000000000m, "18");
 629                 }
 630
 631                 [Test]
 632                 [SetCulture("en-US")]
 633                 public void TestConstructDouble ()
 634                 {
 635                         Decimal d;
 636
 637                         d = new Decimal (0.0);
 638                         Assert.IsTrue ((decimal) d == 0m);
 639
 640                         d = new Decimal (1.0);
 641                         Assert.IsTrue ((decimal) d == 1m);
 642                         Assert.IsTrue (1.0 == (double) d);
 643
 644                         d = new Decimal (-1.2345678901234);
 645                         Assert.IsTrue ((decimal) d == -1.2345678901234m);
 646                         Assert.IsTrue (-1.2345678901234 == (double) d);
 647
 648                         d = new Decimal (1.2345678901234);
 649                         Assert.IsTrue ((decimal) d == 1.2345678901234m);
 650
 651                         d = new Decimal (1.2345678901234e8);
 652                         Assert.IsTrue ((decimal) d == 123456789.01234m);
 653                         Assert.IsTrue (1.2345678901234e8 == (double) d);
 654
 655                         d = new Decimal (1.2345678901234e16);
 656                         Assert.IsTrue ((decimal) d == 12345678901234000m);
 657                         Assert.IsTrue (1.2345678901234e16 == (double) d);
 658
 659                         d = new Decimal (1.2345678901234e24);
 660                         Assert.IsTrue ((decimal) d == 1234567890123400000000000m);
 661                         Assert.IsTrue (1.2345678901234e24 == (double) d);
 662
 663                         d = new Decimal (1.2345678901234e28);
 664                         Assert.IsTrue ((decimal) d == 1.2345678901234e28m);
 665                         Assert.IsTrue (1.2345678901234e28 == (double) d);
 666
 667                         d = new Decimal (7.2345678901234e28);
 668                         Assert.IsTrue ((decimal) d == 7.2345678901234e28m);
 669                         Assert.IsTrue (new Decimal ((double) d) == d);
 670
 671                         d = new Decimal (1.2345678901234e-8);
 672                         Assert.IsTrue ((decimal) d == 1.2345678901234e-8m);
 673
 674                         d = new Decimal (1.2345678901234e-14);
 675                         Assert.IsTrue ((decimal) d == 1.2345678901234e-14m);
 676                         Assert.IsTrue (1.2345678901234e-14 == (double) d);
 677
 678                         d = new Decimal (1.2342278901234e-25);
 679                         Assert.AreEqual (d, 1.234e-25m, "A10");
 680
 681                         //
 682                         // Make sure that 0.6 is turned into
 683                         // the 96 bit value 6 with the magnitude set to
 684                         //
 685                         double mydouble = 0.6;
 686                         d = new Decimal (mydouble);
 687                         int [] bits = Decimal.GetBits (d);
 688                         Assert.AreEqual (bits [0], 6, "f1");
 689                         Assert.AreEqual (bits [1], 0, "f2");
 690                         Assert.AreEqual (bits [2], 0, "f3");
 691                         Assert.AreEqual (bits [3], 65536, "f4");
 692
 693                         //
 694                         // Make sure that we properly parse this value
 695                         // this in particular exposes a bug in the
 696                         // unmanaged version which rounds to 1234 instead
 697                         // of 1235, here to make sure we do not regress
 698                         // on the future.
 699                         //
 700                         mydouble = 1.2345679329684657e-25;
 701                         d = new Decimal (mydouble);
 702                         Assert.AreEqual (d.ToString (), "0.0000000000000000000000001235", "f5");
 703
 704                         // test exceptions
 705                         try {
 706                                 d = new Decimal (8e28);
 707                                 Assert.Fail ();
 708                         } catch (OverflowException) {
 709                         }
 710
 711                         try {
 712                                 d = new Decimal (8e48);
 713                                 Assert.Fail ();
 714                         } catch (OverflowException) {
 715                         }
 716
 717                         try {
 718                                 d = new Decimal (Double.NaN);
 719                                 Assert.Fail ();
 720                         } catch (OverflowException) {
 721                         }
 722
 723                         try {
 724                                 d = new Decimal (Double.PositiveInfinity);
 725                                 Assert.Fail ();
 726                         } catch (OverflowException) {
 727                         }
 728                 }
 729
 730                 [Test]
 731                 public void TestConstructDoubleRound ()
 732                 {
 733                         decimal d;
 734                         int TestNum = 1;
 735
 736                         try {
 737                                 d = new Decimal (1765.231234567857);
 738                                 Assert.AreEqual (1765.23123456786m, d, "A01");
 739
 740                                 TestNum++;
 741                                 d = new Decimal (1765.2312345678554);
 742                                 Assert.AreEqual (1765.23123456786m, d, "A02, failed banker's rule rounding test 1");
 743                                 Assert.AreEqual (1765.23123456786, (double) d, "A03");
 744
 745                                 TestNum++;
 746                                 d = new Decimal (1765.231234567853);
 747                                 Assert.IsTrue (d == 1765.23123456785m);
 748
 749                                 TestNum++;
 750                                 d = new Decimal (1765.231234567847);
 751                                 Assert.IsTrue (d == 1765.23123456785m);
 752
 753                                 TestNum++;
 754                                 d = new Decimal (1765.231234567843);
 755                                 Assert.IsTrue (d == 1765.23123456784m);
 756
 757                                 TestNum++;
 758                                 d = new Decimal (1.765231234567857e-9);
 759                                 Assert.IsTrue (d == 1.76523123456786e-9m);
 760
 761                                 TestNum++;
 762                                 d = new Decimal (1.7652312345678554e-9);
 763                                 Assert.IsTrue (d == 1.76523123456786e-9m, "failed banker's rule rounding test 3");
 764
 765                                 TestNum++;
 766                                 d = new Decimal (1.765231234567853e-9);
 767                                 Assert.IsTrue (d == 1.76523123456785e-9m);
 768
 769                                 TestNum++;
 770                                 d = new Decimal (1.765231234567857e+24);
 771                                 Assert.IsTrue (d == 1.76523123456786e+24m);
 772
 773                                 TestNum++;
 774                                 d = new Decimal (1.7652312345678554e+24);
 775                                 Assert.IsTrue (d == 1.76523123456786e+24m, "failed banker's rule rounding test 4");
 776
 777                                 TestNum++;
 778                                 d = new Decimal (1.765231234567853e+24);
 779                                 Assert.IsTrue (d == 1.76523123456785e+24m);
 780
 781                                 TestNum++;
 782                                 d = new Decimal (1765.2312345678454);
 783                                 Assert.IsTrue (d == 1765.23123456785m);
 784                         } catch (Exception e) {
 785                                 Assert.Fail ("At TestNum = " + TestNum + " unexpected exception. e = " + e);
 786                         }
 787                 }
 788
 789                 [Test]
 790                 public void TestNegate ()
 791                 {
 792                         decimal d;
 793
 794                         d = new Decimal (12345678);
 795                         Assert.IsTrue ((decimal) Decimal.Negate (d) == -12345678m);
 796                 }
 797
 798                 [Test]
 799                 public void TestPartConstruct ()
 800                 {
 801                         decimal d;
 802
 803                         d = new Decimal (parts0);
 804                         Assert.IsTrue (d == 0);
 805
 806                         d = new Decimal (parts1);
 807                         Assert.IsTrue (d == 1);
 808
 809                         d = new Decimal (parts2);
 810                         Assert.IsTrue (d == 4294967296m);
 811
 812                         d = new Decimal (parts3);
 813                         Assert.IsTrue (d == 18446744073709551616m);
 814
 815                         d = new Decimal (parts4);
 816                         Assert.IsTrue (d == 0m);
 817
 818                         d = new Decimal (parts5);
 819                         Assert.IsTrue (d == 18446744078004518913m);
 820
 821                         d = new Decimal (partsMaxValue);
 822                         Assert.IsTrue (d == Decimal.MaxValue);
 823
 824                         d = new Decimal (partsMinValue);
 825                         Assert.IsTrue (d == Decimal.MinValue);
 826
 827                         d = new Decimal (parts6);
 828                         int [] erg = Decimal.GetBits (d);
 829                         for (int i = 0; i < 4; i++) {
 830                                 Assert.IsTrue (erg [i] == parts6 [i]);
 831                         }
 832                 }
 833
 834                 [Test]
 835                 public void TestFloorTruncate ()
 836                 {
 837                         decimal [,] dtab = {
 838                                 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
 839                                 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
 840                                 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
 841                                 {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},
 842                                 {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},
 843                                 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
 844                                 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
 845                         };
 846
 847                         decimal d;
 848
 849                         for (int i = 0; i < dtab.GetLength (0); i++) {
 850                                 d = Decimal.Floor (dtab [i, 0]);
 851                                 if (d != dtab [i, 1]) {
 852                                         Assert.Fail ("Floor: Floor(" + dtab [i, 0] + ") != " + d);
 853                                 }
 854                                 d = Decimal.Truncate (dtab [i, 0]);
 855                                 if (d != dtab [i, 2]) {
 856                                         Assert.Fail ("Truncate: Truncate(" + dtab [i, 0] + ") != " + d);
 857                                 }
 858                         }
 859                 }
 860
 861                 [Test]
 862                 public void Truncate ()
 863                 {
 864                         decimal dd = 249.9m;
 865                         decimal dt = Decimal.Truncate (dd);
 866                         Assert.AreEqual (249.9m, dd, "Original");
 867                         Assert.AreEqual (249m, dt, "Truncate");
 868                         Assert.AreEqual (249, (byte) dd, "Cast-Byte");
 869                         Assert.AreEqual (249, (char) dd, "Cast-Char");
 870                         Assert.AreEqual (249, (short) dd, "Cast-Int16");
 871                         Assert.AreEqual (249, (ushort) dd, "Cast-UInt16");
 872                         Assert.AreEqual (249, (int) dd, "Cast-Int32");
 873                         Assert.AreEqual (249, (uint) dd, "Cast-UInt32");
 874                         Assert.AreEqual (249, (long) dd, "Cast-Int64");
 875                         Assert.AreEqual (249, (ulong) dd, "Cast-UInt64");
 876                 }
 877
 878                 [Test]
 879                 public void TestRound ()
 880                 {
 881                         decimal [,] dtab = {
 882                                 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
 883                                 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
 884                                 {1.2355m, 3, 1.236m},
 885                                 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
 886                                 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
 887                                 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
 888                                 {-47893764694.4578m, 5, -47893764694.4578m}
 889                         };
 890
 891                         decimal d;
 892
 893                         for (int i = 0; i < dtab.GetLength (0); i++) {
 894                                 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
 895                                 if (d != dtab [i, 2]) {
 896                                         Assert.Fail ("Round: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
 897                                 }
 898                         }
 899                 }
 900
 901                 [Test]
 902                 public void TestRoundFailures ()
 903                 {
 904                         decimal [,] dtab = {
 905                                 {1.2345m, 3, 1.234m}
 906                         };
 907
 908                         decimal d;
 909
 910                         for (int i = 0; i < dtab.GetLength (0); i++) {
 911                                 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
 912                                 if (d != dtab [i, 2]) {
 913                                         Assert.Fail ("FailRound: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
 914                                 }
 915                         }
 916                 }
 917
 918                 [Test]
 919                 public void ParseInt64 ()
 920                 {
 921                         long max = Int64.MaxValue;
 922                         Decimal dmax = Decimal.Parse (max.ToString ());
 923                         Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax), "Int64.MaxValue");
 924
 925                         long min = Int64.MinValue;
 926                         Decimal dmin = Decimal.Parse (min.ToString ());
 927                         Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin), "Int64.MinValue");
 928
 929                         dmax += 1.1m;
 930                         dmax = Decimal.Parse (dmax.ToString ());
 931                         Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m), "Int64.MaxValue+1.1");
 932
 933                         dmin -= 1.1m;
 934                         dmin = Decimal.Parse (dmin.ToString ());
 935                         Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m), "Int64.MinValue-1.1");
 936                 }
 937
 938                 [Test]
 939                 public void ToByte ()
 940                 {
 941                         Decimal d = 254.9m;
 942                         Assert.AreEqual (254, Decimal.ToByte (d), "Decimal.ToByte");
 943                         Assert.AreEqual (255, Convert.ToByte (d), "Convert.ToByte");
 944                         Assert.AreEqual (255, (d as IConvertible).ToByte (null), "IConvertible.ToByte");
 945                 }
 946
 947                 [Test]
 948                 public void ToSByte ()
 949                 {
 950                         Decimal d = 126.9m;
 951                         Assert.AreEqual (126, Decimal.ToSByte (d), "Decimal.ToSByte");
 952                         Assert.AreEqual (127, Convert.ToSByte (d), "Convert.ToSByte");
 953                         Assert.AreEqual (127, (d as IConvertible).ToSByte (null), "IConvertible.ToSByte");
 954                         d = -d;
 955                         Assert.AreEqual (-126, Decimal.ToSByte (d), "-Decimal.ToSByte");
 956                         Assert.AreEqual (-127, Convert.ToSByte (d), "-Convert.ToSByte");
 957                         Assert.AreEqual (-127, (d as IConvertible).ToSByte (null), "-IConvertible.ToSByte");
 958                 }
 959
 960                 [Test]
 961                 public void ToInt16 ()
 962                 {
 963                         Decimal d = 254.9m;
 964                         Assert.AreEqual (254, Decimal.ToInt16 (d), "Decimal.ToInt16");
 965                         Assert.AreEqual (255, Convert.ToInt16 (d), "Convert.ToInt16");
 966                         Assert.AreEqual (255, (d as IConvertible).ToInt16 (null), "IConvertible.ToInt16");
 967                         d = -d;
 968                         Assert.AreEqual (-254, Decimal.ToInt16 (d), "-Decimal.ToInt16");
 969                         Assert.AreEqual (-255, Convert.ToInt16 (d), "-Convert.ToInt16");
 970                         Assert.AreEqual (-255, (d as IConvertible).ToInt16 (null), "-IConvertible.ToInt16");
 971                 }
 972
 973                 [Test]
 974                 public void ToUInt16 ()
 975                 {
 976                         Decimal d = 254.9m;
 977                         Assert.AreEqual (254, Decimal.ToUInt16 (d), "Decimal.ToUInt16");
 978                         Assert.AreEqual (255, Convert.ToUInt16 (d), "Convert.ToUInt16");
 979                         Assert.AreEqual (255, (d as IConvertible).ToUInt16 (null), "IConvertible.ToUInt16");
 980                 }
 981
 982                 [Test]
 983                 public void ToInt32 ()
 984                 {
 985                         Decimal d = 254.9m;
 986                         Assert.AreEqual (254, Decimal.ToInt32 (d), "Decimal.ToInt32");
 987                         Assert.AreEqual (255, Convert.ToInt32 (d), "Convert.ToInt32");
 988                         Assert.AreEqual (255, (d as IConvertible).ToInt32 (null), "IConvertible.ToInt32");
 989                         d = -d;
 990                         Assert.AreEqual (-254, Decimal.ToInt32 (d), "-Decimal.ToInt32");
 991                         Assert.AreEqual (-255, Convert.ToInt32 (d), "-Convert.ToInt32");
 992                         Assert.AreEqual (-255, (d as IConvertible).ToInt32 (null), "-IConvertible.ToInt32");
 993                 }
 994
 995                 [Test]
 996                 public void ToUInt32 ()
 997                 {
 998                         Decimal d = 254.9m;
 999                         Assert.AreEqual (254, Decimal.ToUInt32 (d), "Decimal.ToUInt32");
1000                         Assert.AreEqual (255, Convert.ToUInt32 (d), "Convert.ToUInt32");
1001                         Assert.AreEqual (255, (d as IConvertible).ToUInt32 (null), "IConvertible.ToUInt32");
1002                 }
1003
1004                 [Test]
1005                 public void ToInt64 ()
1006                 {
1007                         Decimal d = 254.9m;
1008                         Assert.AreEqual (254, Decimal.ToInt64 (d), "Decimal.ToInt64");
1009                         Assert.AreEqual (255, Convert.ToInt64 (d), "Convert.ToInt64");
1010                         Assert.AreEqual (255, (d as IConvertible).ToInt64 (null), "IConvertible.ToInt64");
1011                         d = -d;
1012                         Assert.AreEqual (-254, Decimal.ToInt64 (d), "-Decimal.ToInt64");
1013                         Assert.AreEqual (-255, Convert.ToInt64 (d), "-Convert.ToInt64");
1014                         Assert.AreEqual (-255, (d as IConvertible).ToInt64 (null), "-IConvertible.ToInt64");
1015                 }
1016
1017                 [Test]
1018                 [ExpectedException (typeof (OverflowException))]
1019                 public void ToInt64_TooBig ()
1020                 {
1021                         Decimal d = (Decimal) Int64.MaxValue;
1022                         d += 1.1m;
1023                         long value = Decimal.ToInt64 (d);
1024                 }
1025
1026                 [Test]
1027                 [ExpectedException (typeof (OverflowException))]
1028                 public void ToInt64_TooSmall ()
1029                 {
1030                         Decimal d = (Decimal) Int64.MinValue;
1031                         d -= 1.1m;
1032                         long value = Decimal.ToInt64 (d);
1033                 }
1034
1035                 [Test]
1036                 public void ToUInt64 ()
1037                 {
1038                         Decimal d = 254.9m;
1039                         Assert.AreEqual (254, Decimal.ToUInt64 (d), "Decimal.ToUInt64");
1040                         Assert.AreEqual (255, Convert.ToUInt64 (d), "Convert.ToUInt64");
1041                         Assert.AreEqual (255, (d as IConvertible).ToUInt64 (null), "IConvertible.ToUInt64");
1042                 }
1043
1044                 [Test]
1045                 public void ToSingle ()
1046                 {
1047                         Decimal d = 254.9m;
1048                         Assert.AreEqual (254.9f, Decimal.ToSingle (d), "Decimal.ToSingle");
1049                         Assert.AreEqual (254.9f, Convert.ToSingle (d), "Convert.ToSingle");
1050                         Assert.AreEqual (254.9f, (d as IConvertible).ToSingle (null), "IConvertible.ToSingle");
1051                         d = -d;
1052                         Assert.AreEqual (-254.9f, Decimal.ToSingle (d), "-Decimal.ToSingle");
1053                         Assert.AreEqual (-254.9f, Convert.ToSingle (d), "-Convert.ToSingle");
1054                         Assert.AreEqual (-254.9f, (d as IConvertible).ToSingle (null), "-IConvertible.ToSingle");
1055                 }
1056
1057                 [Test]
1058                 public void ToDouble ()
1059                 {
1060                         Decimal d = 254.9m;
1061                         Assert.AreEqual (254.9d, Decimal.ToDouble (d), "Decimal.ToDouble");
1062                         Assert.AreEqual (254.9d, Convert.ToDouble (d), "Convert.ToDouble");
1063                         Assert.AreEqual (254.9d, (d as IConvertible).ToDouble (null), "IConvertible.ToDouble");
1064                         d = -d;
1065                         Assert.AreEqual (-254.9d, Decimal.ToDouble (d), "-Decimal.ToDouble");
1066                         Assert.AreEqual (-254.9d, Convert.ToDouble (d), "-Convert.ToDouble");
1067                         Assert.AreEqual (-254.9d, (d as IConvertible).ToDouble (null), "-IConvertible.ToDouble");
1068                 }
1069
1070                 [Test]
1071                 [SetCulture("en-US")]
1072                 public void ToString_Defaults ()
1073                 {
1074                         Decimal d = 254.9m;
1075                         // everything defaults to "G"
1076                         string def = d.ToString ("G");
1077                         Assert.AreEqual (def, d.ToString (), "ToString()");
1078                         Assert.AreEqual (def, d.ToString ((IFormatProvider) null), "ToString((IFormatProvider)null)");
1079                         Assert.AreEqual (def, d.ToString ((string) null), "ToString((string)null)");
1080                         Assert.AreEqual (def, d.ToString (String.Empty), "ToString(empty)");
1081                         Assert.AreEqual (def, d.ToString (null, null), "ToString(null,null)");
1082                         Assert.AreEqual (def, d.ToString (String.Empty, null), "ToString(empty,null)");
1083
1084                         Assert.AreEqual ("254.9", def, "ToString()");
1085                 }
1086
1087                 [Test]
1088                 public void CastTruncRounding ()
1089                 {
1090                         // casting truncs decimal value (not normal nor banker's rounding)
1091                         Assert.AreEqual (254, (long) (254.9m), "254.9==254");
1092                         Assert.AreEqual (-254, (long) (-254.9m), "-254.9=-254");
1093                         Assert.AreEqual (255, (long) (255.9m), "255.9==256");
1094                         Assert.AreEqual (-255, (long) (-255.9m), "-255.9=-256");
1095                 }
1096
1097                 [Test]
1098                 public void ParseFractions ()
1099                 {
1100                         decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);
1101                         Assert.AreEqual (0.5234567890123454678901234568m, d1, "f1");
1102                         decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);
1103                         Assert.AreEqual (0.4921420654348652943463423146m, d2, "f2");
1104                 }
1105
1106                 [Test]
1107                 [ExpectedException (typeof (OverflowException))]
1108                 public void Parse_Int64_Overflow ()
1109                 {
1110                         // Int64.MaxValue + 1 + small fraction to allow 30 digits
1111                         // 123456789012345678901234567890
1112                         decimal d = Decimal.Parse ("9223372036854775808.0000000009", CultureInfo.InvariantCulture);
1113                         long l = (long) d;
1114                 }
1115 /* Not yet fixed
1116                 [Test]
1117                 public void ParseEmptyNumberGroupSeparator ()
1118                 {
1119                         CultureInfo originalCulture = CultureInfo.CurrentCulture;
1120                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1121                         try {
1122                                 var nf = new NumberFormatInfo ();
1123                                 nf.NumberDecimalSeparator = ".";
1124                                 nf.NumberGroupSeparator = "";
1125                                 decimal d = decimal.Parse ("4.5", nf);
1126                                 Assert.AreEqual (4.5, d);
1127                         } finally {
1128                                 Thread.CurrentThread.CurrentCulture = originalCulture;
1129                         }
1130                 }
1131 */
1132
1133                 [Test]
1134                 public void ParseCultureSeparator ()
1135                 {
1136                         Assert.AreEqual (2.2m, decimal.Parse ("2.2", new CultureInfo("es-MX")));
1137                 }
1138
1139                 [Test]
1140                 [Category ("TargetJvmNotWorking")]
1141                 public void TryParse ()
1142                 {
1143                         Decimal r;
1144
1145                         // These should return false
1146                         Assert.AreEqual (false, Decimal.TryParse ("79228162514264337593543950336", out r));
1147                         Assert.AreEqual (false, Decimal.TryParse ("123nx", NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1148                         Assert.AreEqual (false, Decimal.TryParse (null, NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1149
1150                         // These should pass
1151                         for (int i = 0; i < tab.Length; i++) {
1152                                 Assert.AreEqual (!tab [i].exceptionFlag,
1153                                         Decimal.TryParse (tab [i].str, tab [i].style,
1154                                         NumberFormatInfo.InvariantInfo, out r));
1155                         }
1156                 }
1157
1158                 [Test]
1159                 [ExpectedException (typeof (DivideByZeroException))]
1160                 public void Remainder_ByZero ()
1161                 {
1162                         Decimal.Remainder (254.9m, 0m);
1163                 }
1164
1165                 [Test]
1166                 public void Remainder ()
1167                 {
1168                         decimal p1 = 254.9m;
1169                         decimal p2 = 12.1m;
1170                         decimal n1 = -254.9m;
1171                         decimal n2 = -12.1m;
1172
1173                         Assert.AreEqual (0.8m, Decimal.Remainder (p1, p2), "254.9 % 12.1");
1174                         Assert.AreEqual (-0.8m, Decimal.Remainder (n1, p2), "-254.9 % 12.1");
1175                         Assert.AreEqual (0.8m, Decimal.Remainder (p1, n2), "254.9 % -12.1");
1176                         Assert.AreEqual (-0.8m, Decimal.Remainder (n1, n2), "-254.9 % -12.1");
1177
1178                         Assert.AreEqual (12.1m, Decimal.Remainder (p2, p1), "12.1 % 254.9");
1179                         Assert.AreEqual (-12.1m, Decimal.Remainder (n2, p1), "-12.1 % 254.9");
1180                         Assert.AreEqual (12.1m, Decimal.Remainder (p2, n1), "12.1 % -254.9");
1181                         Assert.AreEqual (-12.1m, Decimal.Remainder (n2, n1), "-12.1 % -254.9");
1182
1183                         Assert.AreEqual (0.0m, Decimal.Remainder (p1, p1), "12.1 % 12.1");
1184                         Assert.AreEqual (0.0m, Decimal.Remainder (n1, p1), "-12.1 % 12.1");
1185                         Assert.AreEqual (0.0m, Decimal.Remainder (p1, n1), "12.1 % -12.1");
1186                         Assert.AreEqual (0.0m, Decimal.Remainder (n1, n1), "-12.1 % -12.1");
1187                 }
1188
1189                 [Test]
1190                 public void Remainder2 ()
1191                 {
1192                         decimal a = 20.0M;
1193                         decimal b = 10.0M;
1194                         decimal c = 10.00M;
1195
1196                         Assert.AreEqual (0.00m, a % c, "20.0M % 10.00M");
1197
1198                 }
1199
1200                 [Test]
1201                 [ExpectedException (typeof (DivideByZeroException))]
1202                 public void Divide_ByZero ()
1203                 {
1204                         Decimal.Divide (254.9m, 0m);
1205                 }
1206
1207                 [Test]
1208                 public void Divide ()
1209                 {
1210                         decimal p1 = 254.9m;
1211                         decimal p2 = 12.1m;
1212                         decimal n1 = -254.9m;
1213                         decimal n2 = -12.1m;
1214
1215                         decimal c1 = 21.066115702479338842975206612m;
1216                         decimal c2 = 0.0474695959199686151431934092m;
1217
1218                         Assert.AreEqual (c1, Decimal.Divide (p1, p2), "254.9 / 12.1");
1219                         Assert.AreEqual (-c1, Decimal.Divide (n1, p2), "-254.9 / 12.1");
1220                         Assert.AreEqual (-c1, Decimal.Divide (p1, n2), "254.9 / -12.1");
1221                         Assert.AreEqual (c1, Decimal.Divide (n1, n2), "-254.9 / -12.1");
1222
1223                         Assert.AreEqual (c2, Decimal.Divide (p2, p1), "12.1 / 254.9");
1224                         Assert.AreEqual (-c2, Decimal.Divide (n2, p1), "-12.1 / 254.9");
1225                         Assert.AreEqual (-c2, Decimal.Divide (p2, n1), "12.1 / -254.9");
1226                         Assert.AreEqual (c2, Decimal.Divide (n2, n1), "-12.1 / -254.9");
1227
1228                         Assert.AreEqual (1, Decimal.Divide (p1, p1), "12.1 / 12.1");
1229                         Assert.AreEqual (-1, Decimal.Divide (n1, p1), "-12.1 / 12.1");
1230                         Assert.AreEqual (-1, Decimal.Divide (p1, n1), "12.1 / -12.1");
1231                         Assert.AreEqual (1, Decimal.Divide (n1, n1), "-12.1 / -12.1");
1232                 }
1233
1234                 [Test]
1235                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1236                 public void Round_InvalidDecimals_Negative ()
1237                 {
1238                         Decimal.Round (254.9m, -1);
1239                 }
1240
1241                 [Test]
1242                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1243                 public void Round_InvalidDecimals_TooHigh ()
1244                 {
1245                         Decimal.Round (254.9m, 29);
1246                 }
1247
1248                 [Test]
1249                 public void Round_OddValue ()
1250                 {
1251                         decimal five = 5.5555555555555555555555555555m;
1252                         Assert.AreEqual (6, Decimal.Round (five, 0), "5,5_,00");
1253                         Assert.AreEqual (5.6m, Decimal.Round (five, 1), "5,5_,01");
1254                         Assert.AreEqual (5.56m, Decimal.Round (five, 2), "5,5_,02");
1255                         Assert.AreEqual (5.556m, Decimal.Round (five, 3), "5,5_,03");
1256                         Assert.AreEqual (5.5556m, Decimal.Round (five, 4), "5,5_,04");
1257                         Assert.AreEqual (5.55556m, Decimal.Round (five, 5), "5,5_,05");
1258                         Assert.AreEqual (5.555556m, Decimal.Round (five, 6), "5,5_,06");
1259                         Assert.AreEqual (5.5555556m, Decimal.Round (five, 7), "5,5_,07");
1260                         Assert.AreEqual (5.55555556m, Decimal.Round (five, 8), "5,5_,08");
1261                         Assert.AreEqual (5.555555556m, Decimal.Round (five, 9), "5,5_,09");
1262                         Assert.AreEqual (5.5555555556m, Decimal.Round (five, 10), "5,5_,10");
1263                         Assert.AreEqual (5.55555555556m, Decimal.Round (five, 11), "5,5_,11");
1264                         Assert.AreEqual (5.555555555556m, Decimal.Round (five, 12), "5,5_,12");
1265                         Assert.AreEqual (5.5555555555556m, Decimal.Round (five, 13), "5,5_,13");
1266                         Assert.AreEqual (5.55555555555556m, Decimal.Round (five, 14), "5,5_,14");
1267                         Assert.AreEqual (5.555555555555556m, Decimal.Round (five, 15), "5,5_,15");
1268                         Assert.AreEqual (5.5555555555555556m, Decimal.Round (five, 16), "5,5_,16");
1269                         Assert.AreEqual (5.55555555555555556m, Decimal.Round (five, 17), "5,5_,17");
1270                         Assert.AreEqual (5.555555555555555556m, Decimal.Round (five, 18), "5,5_,18");
1271                         Assert.AreEqual (5.5555555555555555556m, Decimal.Round (five, 19), "5,5_,19");
1272                         Assert.AreEqual (5.55555555555555555556m, Decimal.Round (five, 20), "5,5_,20");
1273                         Assert.AreEqual (5.555555555555555555556m, Decimal.Round (five, 21), "5,5_,21");
1274                         Assert.AreEqual (5.5555555555555555555556m, Decimal.Round (five, 22), "5,5_,22");
1275                         Assert.AreEqual (5.55555555555555555555556m, Decimal.Round (five, 23), "5,5_,23");
1276                         Assert.AreEqual (5.555555555555555555555556m, Decimal.Round (five, 24), "5,5_,24");
1277                         Assert.AreEqual (5.5555555555555555555555556m, Decimal.Round (five, 25), "5,5_,25");
1278                         Assert.AreEqual (5.55555555555555555555555556m, Decimal.Round (five, 26), "5,5_,26");
1279                         Assert.AreEqual (5.555555555555555555555555556m, Decimal.Round (five, 27), "5,5_,27");
1280                         Assert.AreEqual (5.5555555555555555555555555555m, Decimal.Round (five, 28), "5.5_,28");
1281                 }
1282
1283                 [Test]
1284                 public void Round_EvenValue ()
1285                 {
1286                         Assert.AreEqual (2, Decimal.Round (2.5m, 0), "2,2_5,00");
1287                         Assert.AreEqual (2.2m, Decimal.Round (2.25m, 1), "2,2_5,01");
1288                         Assert.AreEqual (2.22m, Decimal.Round (2.225m, 2), "2,2_5,02");
1289                         Assert.AreEqual (2.222m, Decimal.Round (2.2225m, 3), "2,2_5,03");
1290                         Assert.AreEqual (2.2222m, Decimal.Round (2.22225m, 4), "2,2_5,04");
1291                         Assert.AreEqual (2.22222m, Decimal.Round (2.222225m, 5), "2,2_5,05");
1292                         Assert.AreEqual (2.222222m, Decimal.Round (2.2222225m, 6), "2,2_5,06");
1293                         Assert.AreEqual (2.2222222m, Decimal.Round (2.22222225m, 7), "2,2_5,07");
1294                         Assert.AreEqual (2.22222222m, Decimal.Round (2.222222225m, 8), "2,2_5,08");
1295                         Assert.AreEqual (2.222222222m, Decimal.Round (2.2222222225m, 9), "2,2_5,09");
1296                         Assert.AreEqual (2.2222222222m, Decimal.Round (2.22222222225m, 10), "2,2_5,10");
1297                         Assert.AreEqual (2.22222222222m, Decimal.Round (2.222222222225m, 11), "2,2_5,11");
1298                         Assert.AreEqual (2.222222222222m, Decimal.Round (2.2222222222225m, 12), "2,2_5,12");
1299                         Assert.AreEqual (2.2222222222222m, Decimal.Round (2.22222222222225m, 13), "2,2_5,13");
1300                         Assert.AreEqual (2.22222222222222m, Decimal.Round (2.222222222222225m, 14), "2,2_5,14");
1301                         Assert.AreEqual (2.222222222222222m, Decimal.Round (2.2222222222222225m, 15), "2,2_5,15");
1302                         Assert.AreEqual (2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16), "2,2_5,16");
1303                         Assert.AreEqual (2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17), "2,2_5,17");
1304                         Assert.AreEqual (2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18), "2,2_5,18");
1305                         Assert.AreEqual (2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19), "2,2_5,19");
1306                         Assert.AreEqual (2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20), "2,2_5,20");
1307                         Assert.AreEqual (2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21), "2,2_5,21");
1308                         Assert.AreEqual (2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22), "2,2_5,22");
1309                         Assert.AreEqual (2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23), "2,2_5,23");
1310                         Assert.AreEqual (2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24), "2,2_5,24");
1311                         Assert.AreEqual (2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25), "2,2_5,25");
1312                         Assert.AreEqual (2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26), "2,2_5,26");
1313                         Assert.AreEqual (2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27), "2,2_5,27");
1314                         Assert.AreEqual (2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28), "2,2_5,28");
1315                 }
1316
1317                 [Test]
1318                 public void Round_OddValue_Negative ()
1319                 {
1320                         decimal five = -5.5555555555555555555555555555m;
1321                         Assert.AreEqual (-6, Decimal.Round (five, 0), "-5,5_,00");
1322                         Assert.AreEqual (-5.6m, Decimal.Round (five, 1), "-5,5_,01");
1323                         Assert.AreEqual (-5.56m, Decimal.Round (five, 2), "-5,5_,02");
1324                         Assert.AreEqual (-5.556m, Decimal.Round (five, 3), "-5,5_,03");
1325                         Assert.AreEqual (-5.5556m, Decimal.Round (five, 4), "-5,5_,04");
1326                         Assert.AreEqual (-5.55556m, Decimal.Round (five, 5), "-5,5_,05");
1327                         Assert.AreEqual (-5.555556m, Decimal.Round (five, 6), "-5,5_,06");
1328                         Assert.AreEqual (-5.5555556m, Decimal.Round (five, 7), "-5,5_,07");
1329                         Assert.AreEqual (-5.55555556m, Decimal.Round (five, 8), "-5,5_,08");
1330                         Assert.AreEqual (-5.555555556m, Decimal.Round (five, 9), "-5,5_,09");
1331                         Assert.AreEqual (-5.5555555556m, Decimal.Round (five, 10), "-5,5_,10");
1332                         Assert.AreEqual (-5.55555555556m, Decimal.Round (five, 11), "-5,5_,11");
1333                         Assert.AreEqual (-5.555555555556m, Decimal.Round (five, 12), "-5,5_,12");
1334                         Assert.AreEqual (-5.5555555555556m, Decimal.Round (five, 13), "-5,5_,13");
1335                         Assert.AreEqual (-5.55555555555556m, Decimal.Round (five, 14), "-5,5_,14");
1336                         Assert.AreEqual (-5.555555555555556m, Decimal.Round (five, 15), "-5,5_,15");
1337                         Assert.AreEqual (-5.5555555555555556m, Decimal.Round (five, 16), "-5,5_,16");
1338                         Assert.AreEqual (-5.55555555555555556m, Decimal.Round (five, 17), "-5,5_,17");
1339                         Assert.AreEqual (-5.555555555555555556m, Decimal.Round (five, 18), "-5,5_,18");
1340                         Assert.AreEqual (-5.5555555555555555556m, Decimal.Round (five, 19), "-5,5_,19");
1341                         Assert.AreEqual (-5.55555555555555555556m, Decimal.Round (five, 20), "-5,5_,20");
1342                         Assert.AreEqual (-5.555555555555555555556m, Decimal.Round (five, 21), "-5,5_,21");
1343                         Assert.AreEqual (-5.5555555555555555555556m, Decimal.Round (five, 22), "-5,5_,22");
1344                         Assert.AreEqual (-5.55555555555555555555556m, Decimal.Round (five, 23), "-5,5_,23");
1345                         Assert.AreEqual (-5.555555555555555555555556m, Decimal.Round (five, 24), "-5,5_,24");
1346                         Assert.AreEqual (-5.5555555555555555555555556m, Decimal.Round (five, 25), "-5,5_,25");
1347                         Assert.AreEqual (-5.55555555555555555555555556m, Decimal.Round (five, 26), "-5,5_,26");
1348                         Assert.AreEqual (-5.555555555555555555555555556m, Decimal.Round (five, 27), "-5,5_,27");
1349                         Assert.AreEqual (-5.5555555555555555555555555555m, Decimal.Round (five, 28), "-5.5_,28");
1350                 }
1351
1352                 [Test]
1353                 public void Round_EvenValue_Negative ()
1354                 {
1355                         Assert.AreEqual (-2, Decimal.Round (-2.5m, 0), "-2,2_5,00");
1356                         Assert.AreEqual (-2.2m, Decimal.Round (-2.25m, 1), "-2,2_5,01");
1357                         Assert.AreEqual (-2.22m, Decimal.Round (-2.225m, 2), "-2,2_5,02");
1358                         Assert.AreEqual (-2.222m, Decimal.Round (-2.2225m, 3), "-2,2_5,03");
1359                         Assert.AreEqual (-2.2222m, Decimal.Round (-2.22225m, 4), "-2,2_5,04");
1360                         Assert.AreEqual (-2.22222m, Decimal.Round (-2.222225m, 5), "-2,2_5,05");
1361                         Assert.AreEqual (-2.222222m, Decimal.Round (-2.2222225m, 6), "-2,2_5,06");
1362                         Assert.AreEqual (-2.2222222m, Decimal.Round (-2.22222225m, 7), "-2,2_5,07");
1363                         Assert.AreEqual (-2.22222222m, Decimal.Round (-2.222222225m, 8), "-2,2_5,08");
1364                         Assert.AreEqual (-2.222222222m, Decimal.Round (-2.2222222225m, 9), "-2,2_5,09");
1365                         Assert.AreEqual (-2.2222222222m, Decimal.Round (-2.22222222225m, 10), "-2,2_5,10");
1366                         Assert.AreEqual (-2.22222222222m, Decimal.Round (-2.222222222225m, 11), "-2,2_5,11");
1367                         Assert.AreEqual (-2.222222222222m, Decimal.Round (-2.2222222222225m, 12), "-2,2_5,12");
1368                         Assert.AreEqual (-2.2222222222222m, Decimal.Round (-2.22222222222225m, 13), "-2,2_5,13");
1369                         Assert.AreEqual (-2.22222222222222m, Decimal.Round (-2.222222222222225m, 14), "-2,2_5,14");
1370                         Assert.AreEqual (-2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15), "-2,2_5,15");
1371                         Assert.AreEqual (-2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16), "-2,2_5,16");
1372                         Assert.AreEqual (-2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17), "-2,2_5,17");
1373                         Assert.AreEqual (-2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18), "-2,2_5,18");
1374                         Assert.AreEqual (-2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19), "-2,2_5,19");
1375                         Assert.AreEqual (-2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20), "-2,2_5,20");
1376                         Assert.AreEqual (-2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21), "-2,2_5,21");
1377                         Assert.AreEqual (-2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22), "-2,2_5,22");
1378                         Assert.AreEqual (-2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23), "-2,2_5,23");
1379                         Assert.AreEqual (-2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24), "-2,2_5,24");
1380                         Assert.AreEqual (-2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25), "-2,2_5,25");
1381                         Assert.AreEqual (-2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26), "-2,2_5,26");
1382                         Assert.AreEqual (-2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27), "-2,2_5,27");
1383                         Assert.AreEqual (-2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28), "-2,2_5,28");
1384                 }
1385
1386                 [Test] // bug #59425
1387                 [SetCulture("en-US")]
1388                 public void ParseAndKeepPrecision ()
1389                 {
1390                         string value = "5";
1391                         Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1392                         value += '.';
1393                         for (int i = 0; i < 28; i++) {
1394                                 value += "0";
1395                                 Assert.AreEqual (value, Decimal.Parse (value).ToString (), i.ToString ());
1396                         }
1397
1398                         value = "-5";
1399                         Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1400                         value += '.';
1401                         for (int i = 0; i < 28; i++) {
1402                                 value += "0";
1403                                 Assert.AreEqual (value, Decimal.Parse (value).ToString (), "-" + i.ToString ());
1404                         }
1405                 }
1406
1407                 [Test]
1408                 [SetCulture("en-US")]
1409                 public void ToString_G ()
1410                 {
1411                         Assert.AreEqual ("1.0", (1.0m).ToString (), "00");
1412                         Assert.AreEqual ("0.1", (0.1m).ToString (), "01");
1413                         Assert.AreEqual ("0.01", (0.01m).ToString (), "02");
1414                         Assert.AreEqual ("0.001", (0.001m).ToString (), "03");
1415                         Assert.AreEqual ("0.0001", (0.0001m).ToString (), "04");
1416                         Assert.AreEqual ("0.00001", (0.00001m).ToString (), "05");
1417                         Assert.AreEqual ("0.000001", (0.000001m).ToString (), "06");
1418                         Assert.AreEqual ("0.0000001", (0.0000001m).ToString (), "07");
1419                         Assert.AreEqual ("0.00000001", (0.00000001m).ToString (), "08");
1420                         Assert.AreEqual ("0.000000001", (0.000000001m).ToString (), "09");
1421                         Assert.AreEqual ("0.0000000001", (0.0000000001m).ToString (), "10");
1422                         Assert.AreEqual ("0.00000000001", (0.00000000001m).ToString (), "11");
1423                         Assert.AreEqual ("0.000000000001", (0.000000000001m).ToString (), "12");
1424                         Assert.AreEqual ("0.0000000000001", (0.0000000000001m).ToString (), "13");
1425                         Assert.AreEqual ("0.00000000000001", (0.00000000000001m).ToString (), "14");
1426                         Assert.AreEqual ("0.000000000000001", (0.000000000000001m).ToString (), "15");
1427                         Assert.AreEqual ("0.0000000000000001", (0.0000000000000001m).ToString (), "16");
1428                         Assert.AreEqual ("0.00000000000000001", (0.00000000000000001m).ToString (), "17");
1429                         Assert.AreEqual ("0.000000000000000001", (0.000000000000000001m).ToString (), "18");
1430                         Assert.AreEqual ("0.0000000000000000001", (0.0000000000000000001m).ToString (), "19");
1431                         Assert.AreEqual ("0.00000000000000000001", (0.00000000000000000001m).ToString (), "20");
1432                         Assert.AreEqual ("0.000000000000000000001", (0.000000000000000000001m).ToString (), "21");
1433                         Assert.AreEqual ("0.0000000000000000000001", (0.0000000000000000000001m).ToString (), "22");
1434                         Assert.AreEqual ("0.00000000000000000000001", (0.00000000000000000000001m).ToString (), "23");
1435                         Assert.AreEqual ("0.000000000000000000000001", (0.000000000000000000000001m).ToString (), "24");
1436                         Assert.AreEqual ("0.0000000000000000000000001", (0.0000000000000000000000001m).ToString (), "25");
1437                         Assert.AreEqual ("0.00000000000000000000000001", (0.00000000000000000000000001m).ToString (), "26");
1438                         Assert.AreEqual ("0.000000000000000000000000001", (0.000000000000000000000000001m).ToString (), "27");
1439                         Assert.AreEqual ("0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString (), "28");
1440                 }
1441
1442                 [Test]
1443                 public void MidpointRoundingAwayFromZero ()
1444                 {
1445                         MidpointRounding m = MidpointRounding.AwayFromZero;
1446                         Assert.AreEqual (4, Math.Round (3.5M, m), "#1");
1447                         Assert.AreEqual (3, Math.Round (2.8M, m), "#2");
1448                         Assert.AreEqual (3, Math.Round (2.5M, m), "#3");
1449                         Assert.AreEqual (2, Math.Round (2.1M, m), "#4");
1450                         Assert.AreEqual (-2, Math.Round (-2.1M, m), "#5");
1451                         Assert.AreEqual (-3, Math.Round (-2.5M, m), "#6");
1452                         Assert.AreEqual (-3, Math.Round (-2.8M, m), "#7");
1453                         Assert.AreEqual (-4, Math.Round (-3.5M, m), "#8");
1454
1455                         Assert.AreEqual (3.1M, Math.Round (3.05M, 1, m), "#9");
1456                         Assert.AreEqual (2.1M, Math.Round (2.08M, 1, m), "#10");
1457                         Assert.AreEqual (2.1M, Math.Round (2.05M, 1, m), "#11");
1458                         Assert.AreEqual (2.0M, Math.Round (2.01M, 1, m), "#12");
1459                         Assert.AreEqual (-2.0M, Math.Round (-2.01M, 1, m), "#13");
1460                         Assert.AreEqual (-2.1M, Math.Round (-2.05M, 1, m), "#14");
1461                         Assert.AreEqual (-2.1M, Math.Round (-2.08M, 1, m), "#15");
1462                         Assert.AreEqual (-3.1M, Math.Round (-3.05M, 1, m), "#16");
1463                 }
1464
1465                 [Test] // bug #4814
1466                 [SetCulture("")]
1467                 public void Parse_NumberGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
1468                 {
1469                         NumberFormatInfo nf = new NumberFormatInfo ();
1470                         nf.NumberGroupSeparator = "";
1471                         Decimal.Parse ("1.5", nf);
1472                 }
1473
1474                 [Test] // bug #4814
1475                 [SetCulture("")]
1476                 public void Parse_CurrencyGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
1477                 {
1478                         NumberFormatInfo nf = new NumberFormatInfo ();
1479                         nf.CurrencyGroupSeparator = "";
1480                         Decimal.Parse ("\u00A41.5", NumberStyles.Currency, nf);
1481                 }
1482
1483                 [Test] // bug #4814
1484                 [SetCulture("")]
1485                 public void Parse_LeadingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1486                 {
1487                         NumberFormatInfo nf = new NumberFormatInfo ();
1488                         nf.PositiveSign = "";
1489                         try {
1490                                 Decimal.Parse ("+15", nf);
1491                         } catch (FormatException) {
1492                                 return;
1493                         }
1494
1495                         Assert.Fail ("Expected FormatException");
1496                 }
1497
1498                 [Test] // bug #4814
1499                 [SetCulture("")]
1500                 public void Parse_LeadingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1501                 {
1502                         NumberFormatInfo nf = new NumberFormatInfo ();
1503                         nf.NegativeSign = "";
1504                         try {
1505                                 Decimal.Parse ("-15", nf);
1506                         } catch (FormatException) {
1507                                 return;
1508                         }
1509
1510                         Assert.Fail ("Expected FormatException");
1511                 }
1512
1513                 [Test] // bug #4814
1514                 [SetCulture("")]
1515                 public void Parse_TrailingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1516                 {
1517                         NumberFormatInfo nf = new NumberFormatInfo ();
1518                         nf.PositiveSign = "";
1519                         try {
1520                                 Decimal.Parse ("15+", nf);
1521                         } catch (FormatException) {
1522                                 return;
1523                         }
1524
1525                         Assert.Fail ("Expected FormatException");
1526                 }
1527
1528                 [Test] // bug #4814
1529                 [SetCulture("")]
1530                 public void Parse_TrailingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1531                 {
1532                         NumberFormatInfo nf = new NumberFormatInfo ();
1533                         nf.NegativeSign = "";
1534                         try {
1535                                 Decimal.Parse ("15-", nf);
1536                         } catch (FormatException) {
1537                                 return;
1538                         }
1539
1540                         Assert.Fail ("Expected FormatException");
1541                 }
1542
1543                 [Test]
1544                 [SetCulture("en-US")]
1545                 public void ParseZeros ()
1546                 {
1547                         var d = Decimal.Parse ("0.000");
1548                         var bits = Decimal.GetBits (d);
1549                         Assert.AreEqual (0, bits[0], "#1");
1550                         Assert.AreEqual (0, bits[1], "#2");
1551                         Assert.AreEqual (0, bits[2], "#3");
1552                         Assert.AreEqual (196608, bits[3], "#4");
1553                         Assert.AreEqual ("0.000", d.ToString (), "#5");
1554
1555                         d = Decimal.Parse("0.000000000000000000000000000000000000000000000000000000000000000000");
1556                         Assert.AreEqual ("0.0000000000000000000000000000", d.ToString (), "#10");
1557
1558                         d = Decimal.Parse ("0.");
1559                         Assert.AreEqual ("0", d.ToString (), "#11");
1560                 }
1561         }
1562 }