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                 public void TestConstructDouble ()
 633                 {
 634                         Decimal d;
 635
 636                         d = new Decimal (0.0);
 637                         Assert.IsTrue ((decimal) d == 0m);
 638
 639                         d = new Decimal (1.0);
 640                         Assert.IsTrue ((decimal) d == 1m);
 641                         Assert.IsTrue (1.0 == (double) d);
 642
 643                         d = new Decimal (-1.2345678901234);
 644                         Assert.IsTrue ((decimal) d == -1.2345678901234m);
 645                         Assert.IsTrue (-1.2345678901234 == (double) d);
 646
 647                         d = new Decimal (1.2345678901234);
 648                         Assert.IsTrue ((decimal) d == 1.2345678901234m);
 649
 650                         d = new Decimal (1.2345678901234e8);
 651                         Assert.IsTrue ((decimal) d == 123456789.01234m);
 652                         Assert.IsTrue (1.2345678901234e8 == (double) d);
 653
 654                         d = new Decimal (1.2345678901234e16);
 655                         Assert.IsTrue ((decimal) d == 12345678901234000m);
 656                         Assert.IsTrue (1.2345678901234e16 == (double) d);
 657
 658                         d = new Decimal (1.2345678901234e24);
 659                         Assert.IsTrue ((decimal) d == 1234567890123400000000000m);
 660                         Assert.IsTrue (1.2345678901234e24 == (double) d);
 661
 662                         d = new Decimal (1.2345678901234e28);
 663                         Assert.IsTrue ((decimal) d == 1.2345678901234e28m);
 664                         Assert.IsTrue (1.2345678901234e28 == (double) d);
 665
 666                         d = new Decimal (7.2345678901234e28);
 667                         Assert.IsTrue ((decimal) d == 7.2345678901234e28m);
 668                         Assert.IsTrue (new Decimal ((double) d) == d);
 669
 670                         d = new Decimal (1.2345678901234e-8);
 671                         Assert.IsTrue ((decimal) d == 1.2345678901234e-8m);
 672
 673                         d = new Decimal (1.2345678901234e-14);
 674                         Assert.IsTrue ((decimal) d == 1.2345678901234e-14m);
 675                         Assert.IsTrue (1.2345678901234e-14 == (double) d);
 676
 677                         d = new Decimal (1.2342278901234e-25);
 678                         Assert.AreEqual (d, 1.234e-25m, "A10");
 679
 680                         //
 681                         // Make sure that 0.6 is turned into
 682                         // the 96 bit value 6 with the magnitude set to
 683                         //
 684                         double mydouble = 0.6;
 685                         d = new Decimal (mydouble);
 686                         int [] bits = Decimal.GetBits (d);
 687                         Assert.AreEqual (bits [0], 6, "f1");
 688                         Assert.AreEqual (bits [1], 0, "f2");
 689                         Assert.AreEqual (bits [2], 0, "f3");
 690                         Assert.AreEqual (bits [3], 65536, "f4");
 691
 692                         //
 693                         // Make sure that we properly parse this value
 694                         // this in particular exposes a bug in the
 695                         // unmanaged version which rounds to 1234 instead
 696                         // of 1235, here to make sure we do not regress
 697                         // on the future.
 698                         //
 699                         mydouble = 1.2345679329684657e-25;
 700                         d = new Decimal (mydouble);
 701                         Assert.AreEqual (d.ToString (), "0.0000000000000000000000001235", "f5");
 702
 703                         // test exceptions
 704                         try {
 705                                 d = new Decimal (8e28);
 706                                 Assert.Fail ();
 707                         } catch (OverflowException) {
 708                         }
 709
 710                         try {
 711                                 d = new Decimal (8e48);
 712                                 Assert.Fail ();
 713                         } catch (OverflowException) {
 714                         }
 715
 716                         try {
 717                                 d = new Decimal (Double.NaN);
 718                                 Assert.Fail ();
 719                         } catch (OverflowException) {
 720                         }
 721
 722                         try {
 723                                 d = new Decimal (Double.PositiveInfinity);
 724                                 Assert.Fail ();
 725                         } catch (OverflowException) {
 726                         }
 727                 }
 728
 729                 [Test]
 730                 public void TestConstructDoubleRound ()
 731                 {
 732                         decimal d;
 733                         int TestNum = 1;
 734
 735                         try {
 736                                 d = new Decimal (1765.231234567857);
 737                                 Assert.AreEqual (1765.23123456786m, d, "A01");
 738
 739                                 TestNum++;
 740                                 d = new Decimal (1765.2312345678554);
 741                                 Assert.AreEqual (1765.23123456786m, d, "A02, failed banker's rule rounding test 1");
 742                                 Assert.AreEqual (1765.23123456786, (double) d, "A03");
 743
 744                                 TestNum++;
 745                                 d = new Decimal (1765.231234567853);
 746                                 Assert.IsTrue (d == 1765.23123456785m);
 747
 748                                 TestNum++;
 749                                 d = new Decimal (1765.231234567847);
 750                                 Assert.IsTrue (d == 1765.23123456785m);
 751
 752                                 TestNum++;
 753                                 d = new Decimal (1765.231234567843);
 754                                 Assert.IsTrue (d == 1765.23123456784m);
 755
 756                                 TestNum++;
 757                                 d = new Decimal (1.765231234567857e-9);
 758                                 Assert.IsTrue (d == 1.76523123456786e-9m);
 759
 760                                 TestNum++;
 761                                 d = new Decimal (1.7652312345678554e-9);
 762                                 Assert.IsTrue (d == 1.76523123456786e-9m, "failed banker's rule rounding test 3");
 763
 764                                 TestNum++;
 765                                 d = new Decimal (1.765231234567853e-9);
 766                                 Assert.IsTrue (d == 1.76523123456785e-9m);
 767
 768                                 TestNum++;
 769                                 d = new Decimal (1.765231234567857e+24);
 770                                 Assert.IsTrue (d == 1.76523123456786e+24m);
 771
 772                                 TestNum++;
 773                                 d = new Decimal (1.7652312345678554e+24);
 774                                 Assert.IsTrue (d == 1.76523123456786e+24m, "failed banker's rule rounding test 4");
 775
 776                                 TestNum++;
 777                                 d = new Decimal (1.765231234567853e+24);
 778                                 Assert.IsTrue (d == 1.76523123456785e+24m);
 779
 780                                 TestNum++;
 781                                 d = new Decimal (1765.2312345678454);
 782                                 Assert.IsTrue (d == 1765.23123456785m);
 783                         } catch (Exception e) {
 784                                 Assert.Fail ("At TestNum = " + TestNum + " unexpected exception. e = " + e);
 785                         }
 786                 }
 787
 788                 [Test]
 789                 public void TestNegate ()
 790                 {
 791                         decimal d;
 792
 793                         d = new Decimal (12345678);
 794                         Assert.IsTrue ((decimal) Decimal.Negate (d) == -12345678m);
 795                 }
 796
 797                 [Test]
 798                 public void TestPartConstruct ()
 799                 {
 800                         decimal d;
 801
 802                         d = new Decimal (parts0);
 803                         Assert.IsTrue (d == 0);
 804
 805                         d = new Decimal (parts1);
 806                         Assert.IsTrue (d == 1);
 807
 808                         d = new Decimal (parts2);
 809                         Assert.IsTrue (d == 4294967296m);
 810
 811                         d = new Decimal (parts3);
 812                         Assert.IsTrue (d == 18446744073709551616m);
 813
 814                         d = new Decimal (parts4);
 815                         Assert.IsTrue (d == 0m);
 816
 817                         d = new Decimal (parts5);
 818                         Assert.IsTrue (d == 18446744078004518913m);
 819
 820                         d = new Decimal (partsMaxValue);
 821                         Assert.IsTrue (d == Decimal.MaxValue);
 822
 823                         d = new Decimal (partsMinValue);
 824                         Assert.IsTrue (d == Decimal.MinValue);
 825
 826                         d = new Decimal (parts6);
 827                         int [] erg = Decimal.GetBits (d);
 828                         for (int i = 0; i < 4; i++) {
 829                                 Assert.IsTrue (erg [i] == parts6 [i]);
 830                         }
 831                 }
 832
 833                 [Test]
 834                 public void TestFloorTruncate ()
 835                 {
 836                         decimal [,] dtab = {
 837                                 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
 838                                 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
 839                                 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
 840                                 {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},
 841                                 {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},
 842                                 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
 843                                 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
 844                         };
 845
 846                         decimal d;
 847
 848                         for (int i = 0; i < dtab.GetLength (0); i++) {
 849                                 d = Decimal.Floor (dtab [i, 0]);
 850                                 if (d != dtab [i, 1]) {
 851                                         Assert.Fail ("Floor: Floor(" + dtab [i, 0] + ") != " + d);
 852                                 }
 853                                 d = Decimal.Truncate (dtab [i, 0]);
 854                                 if (d != dtab [i, 2]) {
 855                                         Assert.Fail ("Truncate: Truncate(" + dtab [i, 0] + ") != " + d);
 856                                 }
 857                         }
 858                 }
 859
 860                 [Test]
 861                 public void Truncate ()
 862                 {
 863                         decimal dd = 249.9m;
 864                         decimal dt = Decimal.Truncate (dd);
 865                         Assert.AreEqual (249.9m, dd, "Original");
 866                         Assert.AreEqual (249m, dt, "Truncate");
 867                         Assert.AreEqual (249, (byte) dd, "Cast-Byte");
 868                         Assert.AreEqual (249, (char) dd, "Cast-Char");
 869                         Assert.AreEqual (249, (short) dd, "Cast-Int16");
 870                         Assert.AreEqual (249, (ushort) dd, "Cast-UInt16");
 871                         Assert.AreEqual (249, (int) dd, "Cast-Int32");
 872                         Assert.AreEqual (249, (uint) dd, "Cast-UInt32");
 873                         Assert.AreEqual (249, (long) dd, "Cast-Int64");
 874                         Assert.AreEqual (249, (ulong) dd, "Cast-UInt64");
 875                 }
 876
 877                 [Test]
 878                 public void TestRound ()
 879                 {
 880                         decimal [,] dtab = {
 881                                 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
 882                                 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
 883                                 {1.2355m, 3, 1.236m},
 884                                 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
 885                                 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
 886                                 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
 887                                 {-47893764694.4578m, 5, -47893764694.4578m}
 888                         };
 889
 890                         decimal d;
 891
 892                         for (int i = 0; i < dtab.GetLength (0); i++) {
 893                                 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
 894                                 if (d != dtab [i, 2]) {
 895                                         Assert.Fail ("Round: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
 896                                 }
 897                         }
 898                 }
 899
 900                 [Test]
 901                 public void TestRoundFailures ()
 902                 {
 903                         decimal [,] dtab = {
 904                                 {1.2345m, 3, 1.234m}
 905                         };
 906
 907                         decimal d;
 908
 909                         for (int i = 0; i < dtab.GetLength (0); i++) {
 910                                 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
 911                                 if (d != dtab [i, 2]) {
 912                                         Assert.Fail ("FailRound: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
 913                                 }
 914                         }
 915                 }
 916
 917                 [Test]
 918                 public void ParseInt64 ()
 919                 {
 920                         long max = Int64.MaxValue;
 921                         Decimal dmax = Decimal.Parse (max.ToString ());
 922                         Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax), "Int64.MaxValue");
 923
 924                         long min = Int64.MinValue;
 925                         Decimal dmin = Decimal.Parse (min.ToString ());
 926                         Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin), "Int64.MinValue");
 927
 928                         dmax += 1.1m;
 929                         dmax = Decimal.Parse (dmax.ToString ());
 930                         Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m), "Int64.MaxValue+1.1");
 931
 932                         dmin -= 1.1m;
 933                         dmin = Decimal.Parse (dmin.ToString ());
 934                         Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m), "Int64.MinValue-1.1");
 935                 }
 936
 937                 [Test]
 938                 public void ToByte ()
 939                 {
 940                         Decimal d = 254.9m;
 941                         Assert.AreEqual (254, Decimal.ToByte (d), "Decimal.ToByte");
 942                         Assert.AreEqual (255, Convert.ToByte (d), "Convert.ToByte");
 943                         Assert.AreEqual (255, (d as IConvertible).ToByte (null), "IConvertible.ToByte");
 944                 }
 945
 946                 [Test]
 947                 public void ToSByte ()
 948                 {
 949                         Decimal d = 126.9m;
 950                         Assert.AreEqual (126, Decimal.ToSByte (d), "Decimal.ToSByte");
 951                         Assert.AreEqual (127, Convert.ToSByte (d), "Convert.ToSByte");
 952                         Assert.AreEqual (127, (d as IConvertible).ToSByte (null), "IConvertible.ToSByte");
 953                         d = -d;
 954                         Assert.AreEqual (-126, Decimal.ToSByte (d), "-Decimal.ToSByte");
 955                         Assert.AreEqual (-127, Convert.ToSByte (d), "-Convert.ToSByte");
 956                         Assert.AreEqual (-127, (d as IConvertible).ToSByte (null), "-IConvertible.ToSByte");
 957                 }
 958
 959                 [Test]
 960                 public void ToInt16 ()
 961                 {
 962                         Decimal d = 254.9m;
 963                         Assert.AreEqual (254, Decimal.ToInt16 (d), "Decimal.ToInt16");
 964                         Assert.AreEqual (255, Convert.ToInt16 (d), "Convert.ToInt16");
 965                         Assert.AreEqual (255, (d as IConvertible).ToInt16 (null), "IConvertible.ToInt16");
 966                         d = -d;
 967                         Assert.AreEqual (-254, Decimal.ToInt16 (d), "-Decimal.ToInt16");
 968                         Assert.AreEqual (-255, Convert.ToInt16 (d), "-Convert.ToInt16");
 969                         Assert.AreEqual (-255, (d as IConvertible).ToInt16 (null), "-IConvertible.ToInt16");
 970                 }
 971
 972                 [Test]
 973                 public void ToUInt16 ()
 974                 {
 975                         Decimal d = 254.9m;
 976                         Assert.AreEqual (254, Decimal.ToUInt16 (d), "Decimal.ToUInt16");
 977                         Assert.AreEqual (255, Convert.ToUInt16 (d), "Convert.ToUInt16");
 978                         Assert.AreEqual (255, (d as IConvertible).ToUInt16 (null), "IConvertible.ToUInt16");
 979                 }
 980
 981                 [Test]
 982                 public void ToInt32 ()
 983                 {
 984                         Decimal d = 254.9m;
 985                         Assert.AreEqual (254, Decimal.ToInt32 (d), "Decimal.ToInt32");
 986                         Assert.AreEqual (255, Convert.ToInt32 (d), "Convert.ToInt32");
 987                         Assert.AreEqual (255, (d as IConvertible).ToInt32 (null), "IConvertible.ToInt32");
 988                         d = -d;
 989                         Assert.AreEqual (-254, Decimal.ToInt32 (d), "-Decimal.ToInt32");
 990                         Assert.AreEqual (-255, Convert.ToInt32 (d), "-Convert.ToInt32");
 991                         Assert.AreEqual (-255, (d as IConvertible).ToInt32 (null), "-IConvertible.ToInt32");
 992                 }
 993
 994                 [Test]
 995                 public void ToUInt32 ()
 996                 {
 997                         Decimal d = 254.9m;
 998                         Assert.AreEqual (254, Decimal.ToUInt32 (d), "Decimal.ToUInt32");
 999                         Assert.AreEqual (255, Convert.ToUInt32 (d), "Convert.ToUInt32");
1000                         Assert.AreEqual (255, (d as IConvertible).ToUInt32 (null), "IConvertible.ToUInt32");
1001                 }
1002
1003                 [Test]
1004                 public void ToInt64 ()
1005                 {
1006                         Decimal d = 254.9m;
1007                         Assert.AreEqual (254, Decimal.ToInt64 (d), "Decimal.ToInt64");
1008                         Assert.AreEqual (255, Convert.ToInt64 (d), "Convert.ToInt64");
1009                         Assert.AreEqual (255, (d as IConvertible).ToInt64 (null), "IConvertible.ToInt64");
1010                         d = -d;
1011                         Assert.AreEqual (-254, Decimal.ToInt64 (d), "-Decimal.ToInt64");
1012                         Assert.AreEqual (-255, Convert.ToInt64 (d), "-Convert.ToInt64");
1013                         Assert.AreEqual (-255, (d as IConvertible).ToInt64 (null), "-IConvertible.ToInt64");
1014                 }
1015
1016                 [Test]
1017                 [ExpectedException (typeof (OverflowException))]
1018                 public void ToInt64_TooBig ()
1019                 {
1020                         Decimal d = (Decimal) Int64.MaxValue;
1021                         d += 1.1m;
1022                         long value = Decimal.ToInt64 (d);
1023                 }
1024
1025                 [Test]
1026                 [ExpectedException (typeof (OverflowException))]
1027                 public void ToInt64_TooSmall ()
1028                 {
1029                         Decimal d = (Decimal) Int64.MinValue;
1030                         d -= 1.1m;
1031                         long value = Decimal.ToInt64 (d);
1032                 }
1033
1034                 [Test]
1035                 public void ToUInt64 ()
1036                 {
1037                         Decimal d = 254.9m;
1038                         Assert.AreEqual (254, Decimal.ToUInt64 (d), "Decimal.ToUInt64");
1039                         Assert.AreEqual (255, Convert.ToUInt64 (d), "Convert.ToUInt64");
1040                         Assert.AreEqual (255, (d as IConvertible).ToUInt64 (null), "IConvertible.ToUInt64");
1041                 }
1042
1043                 [Test]
1044                 public void ToSingle ()
1045                 {
1046                         Decimal d = 254.9m;
1047                         Assert.AreEqual (254.9f, Decimal.ToSingle (d), "Decimal.ToSingle");
1048                         Assert.AreEqual (254.9f, Convert.ToSingle (d), "Convert.ToSingle");
1049                         Assert.AreEqual (254.9f, (d as IConvertible).ToSingle (null), "IConvertible.ToSingle");
1050                         d = -d;
1051                         Assert.AreEqual (-254.9f, Decimal.ToSingle (d), "-Decimal.ToSingle");
1052                         Assert.AreEqual (-254.9f, Convert.ToSingle (d), "-Convert.ToSingle");
1053                         Assert.AreEqual (-254.9f, (d as IConvertible).ToSingle (null), "-IConvertible.ToSingle");
1054                 }
1055
1056                 [Test]
1057                 public void ToDouble ()
1058                 {
1059                         Decimal d = 254.9m;
1060                         Assert.AreEqual (254.9d, Decimal.ToDouble (d), "Decimal.ToDouble");
1061                         Assert.AreEqual (254.9d, Convert.ToDouble (d), "Convert.ToDouble");
1062                         Assert.AreEqual (254.9d, (d as IConvertible).ToDouble (null), "IConvertible.ToDouble");
1063                         d = -d;
1064                         Assert.AreEqual (-254.9d, Decimal.ToDouble (d), "-Decimal.ToDouble");
1065                         Assert.AreEqual (-254.9d, Convert.ToDouble (d), "-Convert.ToDouble");
1066                         Assert.AreEqual (-254.9d, (d as IConvertible).ToDouble (null), "-IConvertible.ToDouble");
1067                 }
1068
1069                 [Test]
1070                 public void ToString_Defaults ()
1071                 {
1072                         Decimal d = 254.9m;
1073                         // everything defaults to "G"
1074                         string def = d.ToString ("G");
1075                         Assert.AreEqual (def, d.ToString (), "ToString()");
1076                         Assert.AreEqual (def, d.ToString ((IFormatProvider) null), "ToString((IFormatProvider)null)");
1077                         Assert.AreEqual (def, d.ToString ((string) null), "ToString((string)null)");
1078                         Assert.AreEqual (def, d.ToString (String.Empty), "ToString(empty)");
1079                         Assert.AreEqual (def, d.ToString (null, null), "ToString(null,null)");
1080                         Assert.AreEqual (def, d.ToString (String.Empty, null), "ToString(empty,null)");
1081
1082                         Assert.AreEqual ("254.9", def, "ToString()");
1083                 }
1084
1085                 [Test]
1086                 public void CastTruncRounding ()
1087                 {
1088                         // casting truncs decimal value (not normal nor banker's rounding)
1089                         Assert.AreEqual (254, (long) (254.9m), "254.9==254");
1090                         Assert.AreEqual (-254, (long) (-254.9m), "-254.9=-254");
1091                         Assert.AreEqual (255, (long) (255.9m), "255.9==256");
1092                         Assert.AreEqual (-255, (long) (-255.9m), "-255.9=-256");
1093                 }
1094
1095                 [Test]
1096                 public void ParseFractions ()
1097                 {
1098                         decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);
1099                         Assert.AreEqual (0.5234567890123454678901234568m, d1, "f1");
1100                         decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);
1101                         Assert.AreEqual (0.4921420654348652943463423146m, d2, "f2");
1102                 }
1103
1104                 [Test]
1105                 [ExpectedException (typeof (OverflowException))]
1106                 public void Parse_Int64_Overflow ()
1107                 {
1108                         // Int64.MaxValue + 1 + small fraction to allow 30 digits
1109                         // 123456789012345678901234567890
1110                         decimal d = Decimal.Parse ("9223372036854775808.0000000009", CultureInfo.InvariantCulture);
1111                         long l = (long) d;
1112                 }
1113
1114 #if NET_2_0
1115                 [Test]
1116                 [Category ("TargetJvmNotWorking")]
1117                 public void TryParse ()
1118                 {
1119                         Decimal r;
1120
1121                         // These should return false
1122                         Assert.AreEqual (false, Decimal.TryParse ("79228162514264337593543950336", out r));
1123                         Assert.AreEqual (false, Decimal.TryParse ("123nx", NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1124                         Assert.AreEqual (false, Decimal.TryParse (null, NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1125
1126                         // These should pass
1127                         for (int i = 0; i < tab.Length; i++) {
1128                                 Assert.AreEqual (!tab [i].exceptionFlag,
1129                                         Decimal.TryParse (tab [i].str, tab [i].style,
1130                                         NumberFormatInfo.InvariantInfo, out r));
1131                         }
1132                 }
1133 #endif
1134
1135                 [Test]
1136                 [ExpectedException (typeof (DivideByZeroException))]
1137                 public void Remainder_ByZero ()
1138                 {
1139                         Decimal.Remainder (254.9m, 0m);
1140                 }
1141
1142                 [Test]
1143                 public void Remainder ()
1144                 {
1145                         decimal p1 = 254.9m;
1146                         decimal p2 = 12.1m;
1147                         decimal n1 = -254.9m;
1148                         decimal n2 = -12.1m;
1149
1150                         Assert.AreEqual (0.8m, Decimal.Remainder (p1, p2), "254.9 % 12.1");
1151                         Assert.AreEqual (-0.8m, Decimal.Remainder (n1, p2), "-254.9 % 12.1");
1152                         Assert.AreEqual (0.8m, Decimal.Remainder (p1, n2), "254.9 % -12.1");
1153                         Assert.AreEqual (-0.8m, Decimal.Remainder (n1, n2), "-254.9 % -12.1");
1154
1155                         Assert.AreEqual (12.1m, Decimal.Remainder (p2, p1), "12.1 % 254.9");
1156                         Assert.AreEqual (-12.1m, Decimal.Remainder (n2, p1), "-12.1 % 254.9");
1157                         Assert.AreEqual (12.1m, Decimal.Remainder (p2, n1), "12.1 % -254.9");
1158                         Assert.AreEqual (-12.1m, Decimal.Remainder (n2, n1), "-12.1 % -254.9");
1159 #if NET_2_0
1160                         Assert.AreEqual (0.0m, Decimal.Remainder (p1, p1), "12.1 % 12.1");
1161                         Assert.AreEqual (0.0m, Decimal.Remainder (n1, p1), "-12.1 % 12.1");
1162                         Assert.AreEqual (0.0m, Decimal.Remainder (p1, n1), "12.1 % -12.1");
1163                         Assert.AreEqual (0.0m, Decimal.Remainder (n1, n1), "-12.1 % -12.1");
1164 #else
1165                         Assert.AreEqual (0, Decimal.Remainder (p1, p1), "12.1 % 12.1");
1166                         Assert.AreEqual (0, Decimal.Remainder (n1, p1), "-12.1 % 12.1");
1167                         Assert.AreEqual (0, Decimal.Remainder (p1, n1), "12.1 % -12.1");
1168                         Assert.AreEqual (0, Decimal.Remainder (n1, n1), "-12.1 % -12.1");
1169 #endif
1170                 }
1171
1172                 [Test]
1173                 public void Remainder2 ()
1174                 {
1175                         decimal a = 20.0M;
1176                         decimal b = 10.0M;
1177                         decimal c = 10.00M;
1178
1179                         Assert.AreEqual (0.00m, a % c, "20.0M % 10.00M");
1180
1181                 }
1182
1183                 [Test]
1184                 [ExpectedException (typeof (DivideByZeroException))]
1185                 public void Divide_ByZero ()
1186                 {
1187                         Decimal.Divide (254.9m, 0m);
1188                 }
1189
1190                 [Test]
1191                 public void Divide ()
1192                 {
1193                         decimal p1 = 254.9m;
1194                         decimal p2 = 12.1m;
1195                         decimal n1 = -254.9m;
1196                         decimal n2 = -12.1m;
1197
1198                         decimal c1 = 21.066115702479338842975206612m;
1199                         decimal c2 = 0.0474695959199686151431934092m;
1200
1201                         Assert.AreEqual (c1, Decimal.Divide (p1, p2), "254.9 / 12.1");
1202                         Assert.AreEqual (-c1, Decimal.Divide (n1, p2), "-254.9 / 12.1");
1203                         Assert.AreEqual (-c1, Decimal.Divide (p1, n2), "254.9 / -12.1");
1204                         Assert.AreEqual (c1, Decimal.Divide (n1, n2), "-254.9 / -12.1");
1205
1206                         Assert.AreEqual (c2, Decimal.Divide (p2, p1), "12.1 / 254.9");
1207                         Assert.AreEqual (-c2, Decimal.Divide (n2, p1), "-12.1 / 254.9");
1208                         Assert.AreEqual (-c2, Decimal.Divide (p2, n1), "12.1 / -254.9");
1209                         Assert.AreEqual (c2, Decimal.Divide (n2, n1), "-12.1 / -254.9");
1210
1211                         Assert.AreEqual (1, Decimal.Divide (p1, p1), "12.1 / 12.1");
1212                         Assert.AreEqual (-1, Decimal.Divide (n1, p1), "-12.1 / 12.1");
1213                         Assert.AreEqual (-1, Decimal.Divide (p1, n1), "12.1 / -12.1");
1214                         Assert.AreEqual (1, Decimal.Divide (n1, n1), "-12.1 / -12.1");
1215                 }
1216
1217                 [Test]
1218                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1219                 public void Round_InvalidDecimals_Negative ()
1220                 {
1221                         Decimal.Round (254.9m, -1);
1222                 }
1223
1224                 [Test]
1225                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1226                 public void Round_InvalidDecimals_TooHigh ()
1227                 {
1228                         Decimal.Round (254.9m, 29);
1229                 }
1230
1231                 [Test]
1232                 public void Round_OddValue ()
1233                 {
1234                         decimal five = 5.5555555555555555555555555555m;
1235                         Assert.AreEqual (6, Decimal.Round (five, 0), "5,5_,00");
1236                         Assert.AreEqual (5.6m, Decimal.Round (five, 1), "5,5_,01");
1237                         Assert.AreEqual (5.56m, Decimal.Round (five, 2), "5,5_,02");
1238                         Assert.AreEqual (5.556m, Decimal.Round (five, 3), "5,5_,03");
1239                         Assert.AreEqual (5.5556m, Decimal.Round (five, 4), "5,5_,04");
1240                         Assert.AreEqual (5.55556m, Decimal.Round (five, 5), "5,5_,05");
1241                         Assert.AreEqual (5.555556m, Decimal.Round (five, 6), "5,5_,06");
1242                         Assert.AreEqual (5.5555556m, Decimal.Round (five, 7), "5,5_,07");
1243                         Assert.AreEqual (5.55555556m, Decimal.Round (five, 8), "5,5_,08");
1244                         Assert.AreEqual (5.555555556m, Decimal.Round (five, 9), "5,5_,09");
1245                         Assert.AreEqual (5.5555555556m, Decimal.Round (five, 10), "5,5_,10");
1246                         Assert.AreEqual (5.55555555556m, Decimal.Round (five, 11), "5,5_,11");
1247                         Assert.AreEqual (5.555555555556m, Decimal.Round (five, 12), "5,5_,12");
1248                         Assert.AreEqual (5.5555555555556m, Decimal.Round (five, 13), "5,5_,13");
1249                         Assert.AreEqual (5.55555555555556m, Decimal.Round (five, 14), "5,5_,14");
1250                         Assert.AreEqual (5.555555555555556m, Decimal.Round (five, 15), "5,5_,15");
1251                         Assert.AreEqual (5.5555555555555556m, Decimal.Round (five, 16), "5,5_,16");
1252                         Assert.AreEqual (5.55555555555555556m, Decimal.Round (five, 17), "5,5_,17");
1253                         Assert.AreEqual (5.555555555555555556m, Decimal.Round (five, 18), "5,5_,18");
1254                         Assert.AreEqual (5.5555555555555555556m, Decimal.Round (five, 19), "5,5_,19");
1255                         Assert.AreEqual (5.55555555555555555556m, Decimal.Round (five, 20), "5,5_,20");
1256                         Assert.AreEqual (5.555555555555555555556m, Decimal.Round (five, 21), "5,5_,21");
1257                         Assert.AreEqual (5.5555555555555555555556m, Decimal.Round (five, 22), "5,5_,22");
1258                         Assert.AreEqual (5.55555555555555555555556m, Decimal.Round (five, 23), "5,5_,23");
1259                         Assert.AreEqual (5.555555555555555555555556m, Decimal.Round (five, 24), "5,5_,24");
1260                         Assert.AreEqual (5.5555555555555555555555556m, Decimal.Round (five, 25), "5,5_,25");
1261                         Assert.AreEqual (5.55555555555555555555555556m, Decimal.Round (five, 26), "5,5_,26");
1262                         Assert.AreEqual (5.555555555555555555555555556m, Decimal.Round (five, 27), "5,5_,27");
1263                         Assert.AreEqual (5.5555555555555555555555555555m, Decimal.Round (five, 28), "5.5_,28");
1264                 }
1265
1266                 [Test]
1267                 public void Round_EvenValue ()
1268                 {
1269                         Assert.AreEqual (2, Decimal.Round (2.5m, 0), "2,2_5,00");
1270                         Assert.AreEqual (2.2m, Decimal.Round (2.25m, 1), "2,2_5,01");
1271                         Assert.AreEqual (2.22m, Decimal.Round (2.225m, 2), "2,2_5,02");
1272                         Assert.AreEqual (2.222m, Decimal.Round (2.2225m, 3), "2,2_5,03");
1273                         Assert.AreEqual (2.2222m, Decimal.Round (2.22225m, 4), "2,2_5,04");
1274                         Assert.AreEqual (2.22222m, Decimal.Round (2.222225m, 5), "2,2_5,05");
1275                         Assert.AreEqual (2.222222m, Decimal.Round (2.2222225m, 6), "2,2_5,06");
1276                         Assert.AreEqual (2.2222222m, Decimal.Round (2.22222225m, 7), "2,2_5,07");
1277                         Assert.AreEqual (2.22222222m, Decimal.Round (2.222222225m, 8), "2,2_5,08");
1278                         Assert.AreEqual (2.222222222m, Decimal.Round (2.2222222225m, 9), "2,2_5,09");
1279                         Assert.AreEqual (2.2222222222m, Decimal.Round (2.22222222225m, 10), "2,2_5,10");
1280                         Assert.AreEqual (2.22222222222m, Decimal.Round (2.222222222225m, 11), "2,2_5,11");
1281                         Assert.AreEqual (2.222222222222m, Decimal.Round (2.2222222222225m, 12), "2,2_5,12");
1282                         Assert.AreEqual (2.2222222222222m, Decimal.Round (2.22222222222225m, 13), "2,2_5,13");
1283                         Assert.AreEqual (2.22222222222222m, Decimal.Round (2.222222222222225m, 14), "2,2_5,14");
1284                         Assert.AreEqual (2.222222222222222m, Decimal.Round (2.2222222222222225m, 15), "2,2_5,15");
1285                         Assert.AreEqual (2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16), "2,2_5,16");
1286                         Assert.AreEqual (2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17), "2,2_5,17");
1287                         Assert.AreEqual (2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18), "2,2_5,18");
1288                         Assert.AreEqual (2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19), "2,2_5,19");
1289                         Assert.AreEqual (2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20), "2,2_5,20");
1290                         Assert.AreEqual (2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21), "2,2_5,21");
1291                         Assert.AreEqual (2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22), "2,2_5,22");
1292                         Assert.AreEqual (2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23), "2,2_5,23");
1293                         Assert.AreEqual (2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24), "2,2_5,24");
1294                         Assert.AreEqual (2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25), "2,2_5,25");
1295                         Assert.AreEqual (2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26), "2,2_5,26");
1296                         Assert.AreEqual (2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27), "2,2_5,27");
1297                         Assert.AreEqual (2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28), "2,2_5,28");
1298                 }
1299
1300                 [Test]
1301                 public void Round_OddValue_Negative ()
1302                 {
1303                         decimal five = -5.5555555555555555555555555555m;
1304                         Assert.AreEqual (-6, Decimal.Round (five, 0), "-5,5_,00");
1305                         Assert.AreEqual (-5.6m, Decimal.Round (five, 1), "-5,5_,01");
1306                         Assert.AreEqual (-5.56m, Decimal.Round (five, 2), "-5,5_,02");
1307                         Assert.AreEqual (-5.556m, Decimal.Round (five, 3), "-5,5_,03");
1308                         Assert.AreEqual (-5.5556m, Decimal.Round (five, 4), "-5,5_,04");
1309                         Assert.AreEqual (-5.55556m, Decimal.Round (five, 5), "-5,5_,05");
1310                         Assert.AreEqual (-5.555556m, Decimal.Round (five, 6), "-5,5_,06");
1311                         Assert.AreEqual (-5.5555556m, Decimal.Round (five, 7), "-5,5_,07");
1312                         Assert.AreEqual (-5.55555556m, Decimal.Round (five, 8), "-5,5_,08");
1313                         Assert.AreEqual (-5.555555556m, Decimal.Round (five, 9), "-5,5_,09");
1314                         Assert.AreEqual (-5.5555555556m, Decimal.Round (five, 10), "-5,5_,10");
1315                         Assert.AreEqual (-5.55555555556m, Decimal.Round (five, 11), "-5,5_,11");
1316                         Assert.AreEqual (-5.555555555556m, Decimal.Round (five, 12), "-5,5_,12");
1317                         Assert.AreEqual (-5.5555555555556m, Decimal.Round (five, 13), "-5,5_,13");
1318                         Assert.AreEqual (-5.55555555555556m, Decimal.Round (five, 14), "-5,5_,14");
1319                         Assert.AreEqual (-5.555555555555556m, Decimal.Round (five, 15), "-5,5_,15");
1320                         Assert.AreEqual (-5.5555555555555556m, Decimal.Round (five, 16), "-5,5_,16");
1321                         Assert.AreEqual (-5.55555555555555556m, Decimal.Round (five, 17), "-5,5_,17");
1322                         Assert.AreEqual (-5.555555555555555556m, Decimal.Round (five, 18), "-5,5_,18");
1323                         Assert.AreEqual (-5.5555555555555555556m, Decimal.Round (five, 19), "-5,5_,19");
1324                         Assert.AreEqual (-5.55555555555555555556m, Decimal.Round (five, 20), "-5,5_,20");
1325                         Assert.AreEqual (-5.555555555555555555556m, Decimal.Round (five, 21), "-5,5_,21");
1326                         Assert.AreEqual (-5.5555555555555555555556m, Decimal.Round (five, 22), "-5,5_,22");
1327                         Assert.AreEqual (-5.55555555555555555555556m, Decimal.Round (five, 23), "-5,5_,23");
1328                         Assert.AreEqual (-5.555555555555555555555556m, Decimal.Round (five, 24), "-5,5_,24");
1329                         Assert.AreEqual (-5.5555555555555555555555556m, Decimal.Round (five, 25), "-5,5_,25");
1330                         Assert.AreEqual (-5.55555555555555555555555556m, Decimal.Round (five, 26), "-5,5_,26");
1331                         Assert.AreEqual (-5.555555555555555555555555556m, Decimal.Round (five, 27), "-5,5_,27");
1332                         Assert.AreEqual (-5.5555555555555555555555555555m, Decimal.Round (five, 28), "-5.5_,28");
1333                 }
1334
1335                 [Test]
1336                 public void Round_EvenValue_Negative ()
1337                 {
1338                         Assert.AreEqual (-2, Decimal.Round (-2.5m, 0), "-2,2_5,00");
1339                         Assert.AreEqual (-2.2m, Decimal.Round (-2.25m, 1), "-2,2_5,01");
1340                         Assert.AreEqual (-2.22m, Decimal.Round (-2.225m, 2), "-2,2_5,02");
1341                         Assert.AreEqual (-2.222m, Decimal.Round (-2.2225m, 3), "-2,2_5,03");
1342                         Assert.AreEqual (-2.2222m, Decimal.Round (-2.22225m, 4), "-2,2_5,04");
1343                         Assert.AreEqual (-2.22222m, Decimal.Round (-2.222225m, 5), "-2,2_5,05");
1344                         Assert.AreEqual (-2.222222m, Decimal.Round (-2.2222225m, 6), "-2,2_5,06");
1345                         Assert.AreEqual (-2.2222222m, Decimal.Round (-2.22222225m, 7), "-2,2_5,07");
1346                         Assert.AreEqual (-2.22222222m, Decimal.Round (-2.222222225m, 8), "-2,2_5,08");
1347                         Assert.AreEqual (-2.222222222m, Decimal.Round (-2.2222222225m, 9), "-2,2_5,09");
1348                         Assert.AreEqual (-2.2222222222m, Decimal.Round (-2.22222222225m, 10), "-2,2_5,10");
1349                         Assert.AreEqual (-2.22222222222m, Decimal.Round (-2.222222222225m, 11), "-2,2_5,11");
1350                         Assert.AreEqual (-2.222222222222m, Decimal.Round (-2.2222222222225m, 12), "-2,2_5,12");
1351                         Assert.AreEqual (-2.2222222222222m, Decimal.Round (-2.22222222222225m, 13), "-2,2_5,13");
1352                         Assert.AreEqual (-2.22222222222222m, Decimal.Round (-2.222222222222225m, 14), "-2,2_5,14");
1353                         Assert.AreEqual (-2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15), "-2,2_5,15");
1354                         Assert.AreEqual (-2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16), "-2,2_5,16");
1355                         Assert.AreEqual (-2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17), "-2,2_5,17");
1356                         Assert.AreEqual (-2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18), "-2,2_5,18");
1357                         Assert.AreEqual (-2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19), "-2,2_5,19");
1358                         Assert.AreEqual (-2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20), "-2,2_5,20");
1359                         Assert.AreEqual (-2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21), "-2,2_5,21");
1360                         Assert.AreEqual (-2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22), "-2,2_5,22");
1361                         Assert.AreEqual (-2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23), "-2,2_5,23");
1362                         Assert.AreEqual (-2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24), "-2,2_5,24");
1363                         Assert.AreEqual (-2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25), "-2,2_5,25");
1364                         Assert.AreEqual (-2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26), "-2,2_5,26");
1365                         Assert.AreEqual (-2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27), "-2,2_5,27");
1366                         Assert.AreEqual (-2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28), "-2,2_5,28");
1367                 }
1368
1369                 [Test] // bug #59425
1370                 public void ParseAndKeepPrecision ()
1371                 {
1372                         string value = "5";
1373                         Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1374                         value += '.';
1375                         for (int i = 0; i < 28; i++) {
1376                                 value += "0";
1377                                 Assert.AreEqual (value, Decimal.Parse (value).ToString (), i.ToString ());
1378                         }
1379
1380                         value = "-5";
1381                         Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1382                         value += '.';
1383                         for (int i = 0; i < 28; i++) {
1384                                 value += "0";
1385                                 Assert.AreEqual (value, Decimal.Parse (value).ToString (), "-" + i.ToString ());
1386                         }
1387                 }
1388
1389                 [Test]
1390                 public void ToString_G ()
1391                 {
1392                         Assert.AreEqual ("1.0", (1.0m).ToString (), "00");
1393                         Assert.AreEqual ("0.1", (0.1m).ToString (), "01");
1394                         Assert.AreEqual ("0.01", (0.01m).ToString (), "02");
1395                         Assert.AreEqual ("0.001", (0.001m).ToString (), "03");
1396                         Assert.AreEqual ("0.0001", (0.0001m).ToString (), "04");
1397                         Assert.AreEqual ("0.00001", (0.00001m).ToString (), "05");
1398                         Assert.AreEqual ("0.000001", (0.000001m).ToString (), "06");
1399                         Assert.AreEqual ("0.0000001", (0.0000001m).ToString (), "07");
1400                         Assert.AreEqual ("0.00000001", (0.00000001m).ToString (), "08");
1401                         Assert.AreEqual ("0.000000001", (0.000000001m).ToString (), "09");
1402                         Assert.AreEqual ("0.0000000001", (0.0000000001m).ToString (), "10");
1403                         Assert.AreEqual ("0.00000000001", (0.00000000001m).ToString (), "11");
1404                         Assert.AreEqual ("0.000000000001", (0.000000000001m).ToString (), "12");
1405                         Assert.AreEqual ("0.0000000000001", (0.0000000000001m).ToString (), "13");
1406                         Assert.AreEqual ("0.00000000000001", (0.00000000000001m).ToString (), "14");
1407                         Assert.AreEqual ("0.000000000000001", (0.000000000000001m).ToString (), "15");
1408                         Assert.AreEqual ("0.0000000000000001", (0.0000000000000001m).ToString (), "16");
1409                         Assert.AreEqual ("0.00000000000000001", (0.00000000000000001m).ToString (), "17");
1410                         Assert.AreEqual ("0.000000000000000001", (0.000000000000000001m).ToString (), "18");
1411                         Assert.AreEqual ("0.0000000000000000001", (0.0000000000000000001m).ToString (), "19");
1412                         Assert.AreEqual ("0.00000000000000000001", (0.00000000000000000001m).ToString (), "20");
1413                         Assert.AreEqual ("0.000000000000000000001", (0.000000000000000000001m).ToString (), "21");
1414                         Assert.AreEqual ("0.0000000000000000000001", (0.0000000000000000000001m).ToString (), "22");
1415                         Assert.AreEqual ("0.00000000000000000000001", (0.00000000000000000000001m).ToString (), "23");
1416                         Assert.AreEqual ("0.000000000000000000000001", (0.000000000000000000000001m).ToString (), "24");
1417                         Assert.AreEqual ("0.0000000000000000000000001", (0.0000000000000000000000001m).ToString (), "25");
1418                         Assert.AreEqual ("0.00000000000000000000000001", (0.00000000000000000000000001m).ToString (), "26");
1419                         Assert.AreEqual ("0.000000000000000000000000001", (0.000000000000000000000000001m).ToString (), "27");
1420                         Assert.AreEqual ("0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString (), "28");
1421                 }
1422
1423 #if NET_2_0
1424                 [Test]
1425                 public void MidpointRoundingAwayFromZero ()
1426                 {
1427                         MidpointRounding m = MidpointRounding.AwayFromZero;
1428                         Assert.AreEqual (4, Math.Round (3.5M, m), "#1");
1429                         Assert.AreEqual (3, Math.Round (2.8M, m), "#2");
1430                         Assert.AreEqual (3, Math.Round (2.5M, m), "#3");
1431                         Assert.AreEqual (2, Math.Round (2.1M, m), "#4");
1432                         Assert.AreEqual (-2, Math.Round (-2.1M, m), "#5");
1433                         Assert.AreEqual (-3, Math.Round (-2.5M, m), "#6");
1434                         Assert.AreEqual (-3, Math.Round (-2.8M, m), "#7");
1435                         Assert.AreEqual (-4, Math.Round (-3.5M, m), "#8");
1436
1437                         Assert.AreEqual (3.1M, Math.Round (3.05M, 1, m), "#9");
1438                         Assert.AreEqual (2.1M, Math.Round (2.08M, 1, m), "#10");
1439                         Assert.AreEqual (2.1M, Math.Round (2.05M, 1, m), "#11");
1440                         Assert.AreEqual (2.0M, Math.Round (2.01M, 1, m), "#12");
1441                         Assert.AreEqual (-2.0M, Math.Round (-2.01M, 1, m), "#13");
1442                         Assert.AreEqual (-2.1M, Math.Round (-2.05M, 1, m), "#14");
1443                         Assert.AreEqual (-2.1M, Math.Round (-2.08M, 1, m), "#15");
1444                         Assert.AreEqual (-3.1M, Math.Round (-3.05M, 1, m), "#16");
1445                 }
1446 #endif
1447         }
1448 }