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                 [Test]
1133                 [Category ("TargetJvmNotWorking")]
1134                 public void TryParse ()
1135                 {
1136                         Decimal r;
1137
1138                         // These should return false
1139                         Assert.AreEqual (false, Decimal.TryParse ("79228162514264337593543950336", out r));
1140                         Assert.AreEqual (false, Decimal.TryParse ("123nx", NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1141                         Assert.AreEqual (false, Decimal.TryParse (null, NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1142
1143                         // These should pass
1144                         for (int i = 0; i < tab.Length; i++) {
1145                                 Assert.AreEqual (!tab [i].exceptionFlag,
1146                                         Decimal.TryParse (tab [i].str, tab [i].style,
1147                                         NumberFormatInfo.InvariantInfo, out r));
1148                         }
1149                 }
1150
1151                 [Test]
1152                 [ExpectedException (typeof (DivideByZeroException))]
1153                 public void Remainder_ByZero ()
1154                 {
1155                         Decimal.Remainder (254.9m, 0m);
1156                 }
1157
1158                 [Test]
1159                 public void Remainder ()
1160                 {
1161                         decimal p1 = 254.9m;
1162                         decimal p2 = 12.1m;
1163                         decimal n1 = -254.9m;
1164                         decimal n2 = -12.1m;
1165
1166                         Assert.AreEqual (0.8m, Decimal.Remainder (p1, p2), "254.9 % 12.1");
1167                         Assert.AreEqual (-0.8m, Decimal.Remainder (n1, p2), "-254.9 % 12.1");
1168                         Assert.AreEqual (0.8m, Decimal.Remainder (p1, n2), "254.9 % -12.1");
1169                         Assert.AreEqual (-0.8m, Decimal.Remainder (n1, n2), "-254.9 % -12.1");
1170
1171                         Assert.AreEqual (12.1m, Decimal.Remainder (p2, p1), "12.1 % 254.9");
1172                         Assert.AreEqual (-12.1m, Decimal.Remainder (n2, p1), "-12.1 % 254.9");
1173                         Assert.AreEqual (12.1m, Decimal.Remainder (p2, n1), "12.1 % -254.9");
1174                         Assert.AreEqual (-12.1m, Decimal.Remainder (n2, n1), "-12.1 % -254.9");
1175
1176                         Assert.AreEqual (0.0m, Decimal.Remainder (p1, p1), "12.1 % 12.1");
1177                         Assert.AreEqual (0.0m, Decimal.Remainder (n1, p1), "-12.1 % 12.1");
1178                         Assert.AreEqual (0.0m, Decimal.Remainder (p1, n1), "12.1 % -12.1");
1179                         Assert.AreEqual (0.0m, Decimal.Remainder (n1, n1), "-12.1 % -12.1");
1180                 }
1181
1182                 [Test]
1183                 public void Remainder2 ()
1184                 {
1185                         decimal a = 20.0M;
1186                         decimal b = 10.0M;
1187                         decimal c = 10.00M;
1188
1189                         Assert.AreEqual (0.00m, a % c, "20.0M % 10.00M");
1190
1191                 }
1192
1193                 [Test]
1194                 [ExpectedException (typeof (DivideByZeroException))]
1195                 public void Divide_ByZero ()
1196                 {
1197                         Decimal.Divide (254.9m, 0m);
1198                 }
1199
1200                 [Test]
1201                 public void Divide ()
1202                 {
1203                         decimal p1 = 254.9m;
1204                         decimal p2 = 12.1m;
1205                         decimal n1 = -254.9m;
1206                         decimal n2 = -12.1m;
1207
1208                         decimal c1 = 21.066115702479338842975206612m;
1209                         decimal c2 = 0.0474695959199686151431934092m;
1210
1211                         Assert.AreEqual (c1, Decimal.Divide (p1, p2), "254.9 / 12.1");
1212                         Assert.AreEqual (-c1, Decimal.Divide (n1, p2), "-254.9 / 12.1");
1213                         Assert.AreEqual (-c1, Decimal.Divide (p1, n2), "254.9 / -12.1");
1214                         Assert.AreEqual (c1, Decimal.Divide (n1, n2), "-254.9 / -12.1");
1215
1216                         Assert.AreEqual (c2, Decimal.Divide (p2, p1), "12.1 / 254.9");
1217                         Assert.AreEqual (-c2, Decimal.Divide (n2, p1), "-12.1 / 254.9");
1218                         Assert.AreEqual (-c2, Decimal.Divide (p2, n1), "12.1 / -254.9");
1219                         Assert.AreEqual (c2, Decimal.Divide (n2, n1), "-12.1 / -254.9");
1220
1221                         Assert.AreEqual (1, Decimal.Divide (p1, p1), "12.1 / 12.1");
1222                         Assert.AreEqual (-1, Decimal.Divide (n1, p1), "-12.1 / 12.1");
1223                         Assert.AreEqual (-1, Decimal.Divide (p1, n1), "12.1 / -12.1");
1224                         Assert.AreEqual (1, Decimal.Divide (n1, n1), "-12.1 / -12.1");
1225                 }
1226
1227                 [Test]
1228                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1229                 public void Round_InvalidDecimals_Negative ()
1230                 {
1231                         Decimal.Round (254.9m, -1);
1232                 }
1233
1234                 [Test]
1235                 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1236                 public void Round_InvalidDecimals_TooHigh ()
1237                 {
1238                         Decimal.Round (254.9m, 29);
1239                 }
1240
1241                 [Test]
1242                 public void Round_OddValue ()
1243                 {
1244                         decimal five = 5.5555555555555555555555555555m;
1245                         Assert.AreEqual (6, Decimal.Round (five, 0), "5,5_,00");
1246                         Assert.AreEqual (5.6m, Decimal.Round (five, 1), "5,5_,01");
1247                         Assert.AreEqual (5.56m, Decimal.Round (five, 2), "5,5_,02");
1248                         Assert.AreEqual (5.556m, Decimal.Round (five, 3), "5,5_,03");
1249                         Assert.AreEqual (5.5556m, Decimal.Round (five, 4), "5,5_,04");
1250                         Assert.AreEqual (5.55556m, Decimal.Round (five, 5), "5,5_,05");
1251                         Assert.AreEqual (5.555556m, Decimal.Round (five, 6), "5,5_,06");
1252                         Assert.AreEqual (5.5555556m, Decimal.Round (five, 7), "5,5_,07");
1253                         Assert.AreEqual (5.55555556m, Decimal.Round (five, 8), "5,5_,08");
1254                         Assert.AreEqual (5.555555556m, Decimal.Round (five, 9), "5,5_,09");
1255                         Assert.AreEqual (5.5555555556m, Decimal.Round (five, 10), "5,5_,10");
1256                         Assert.AreEqual (5.55555555556m, Decimal.Round (five, 11), "5,5_,11");
1257                         Assert.AreEqual (5.555555555556m, Decimal.Round (five, 12), "5,5_,12");
1258                         Assert.AreEqual (5.5555555555556m, Decimal.Round (five, 13), "5,5_,13");
1259                         Assert.AreEqual (5.55555555555556m, Decimal.Round (five, 14), "5,5_,14");
1260                         Assert.AreEqual (5.555555555555556m, Decimal.Round (five, 15), "5,5_,15");
1261                         Assert.AreEqual (5.5555555555555556m, Decimal.Round (five, 16), "5,5_,16");
1262                         Assert.AreEqual (5.55555555555555556m, Decimal.Round (five, 17), "5,5_,17");
1263                         Assert.AreEqual (5.555555555555555556m, Decimal.Round (five, 18), "5,5_,18");
1264                         Assert.AreEqual (5.5555555555555555556m, Decimal.Round (five, 19), "5,5_,19");
1265                         Assert.AreEqual (5.55555555555555555556m, Decimal.Round (five, 20), "5,5_,20");
1266                         Assert.AreEqual (5.555555555555555555556m, Decimal.Round (five, 21), "5,5_,21");
1267                         Assert.AreEqual (5.5555555555555555555556m, Decimal.Round (five, 22), "5,5_,22");
1268                         Assert.AreEqual (5.55555555555555555555556m, Decimal.Round (five, 23), "5,5_,23");
1269                         Assert.AreEqual (5.555555555555555555555556m, Decimal.Round (five, 24), "5,5_,24");
1270                         Assert.AreEqual (5.5555555555555555555555556m, Decimal.Round (five, 25), "5,5_,25");
1271                         Assert.AreEqual (5.55555555555555555555555556m, Decimal.Round (five, 26), "5,5_,26");
1272                         Assert.AreEqual (5.555555555555555555555555556m, Decimal.Round (five, 27), "5,5_,27");
1273                         Assert.AreEqual (5.5555555555555555555555555555m, Decimal.Round (five, 28), "5.5_,28");
1274                 }
1275
1276                 [Test]
1277                 public void Round_EvenValue ()
1278                 {
1279                         Assert.AreEqual (2, Decimal.Round (2.5m, 0), "2,2_5,00");
1280                         Assert.AreEqual (2.2m, Decimal.Round (2.25m, 1), "2,2_5,01");
1281                         Assert.AreEqual (2.22m, Decimal.Round (2.225m, 2), "2,2_5,02");
1282                         Assert.AreEqual (2.222m, Decimal.Round (2.2225m, 3), "2,2_5,03");
1283                         Assert.AreEqual (2.2222m, Decimal.Round (2.22225m, 4), "2,2_5,04");
1284                         Assert.AreEqual (2.22222m, Decimal.Round (2.222225m, 5), "2,2_5,05");
1285                         Assert.AreEqual (2.222222m, Decimal.Round (2.2222225m, 6), "2,2_5,06");
1286                         Assert.AreEqual (2.2222222m, Decimal.Round (2.22222225m, 7), "2,2_5,07");
1287                         Assert.AreEqual (2.22222222m, Decimal.Round (2.222222225m, 8), "2,2_5,08");
1288                         Assert.AreEqual (2.222222222m, Decimal.Round (2.2222222225m, 9), "2,2_5,09");
1289                         Assert.AreEqual (2.2222222222m, Decimal.Round (2.22222222225m, 10), "2,2_5,10");
1290                         Assert.AreEqual (2.22222222222m, Decimal.Round (2.222222222225m, 11), "2,2_5,11");
1291                         Assert.AreEqual (2.222222222222m, Decimal.Round (2.2222222222225m, 12), "2,2_5,12");
1292                         Assert.AreEqual (2.2222222222222m, Decimal.Round (2.22222222222225m, 13), "2,2_5,13");
1293                         Assert.AreEqual (2.22222222222222m, Decimal.Round (2.222222222222225m, 14), "2,2_5,14");
1294                         Assert.AreEqual (2.222222222222222m, Decimal.Round (2.2222222222222225m, 15), "2,2_5,15");
1295                         Assert.AreEqual (2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16), "2,2_5,16");
1296                         Assert.AreEqual (2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17), "2,2_5,17");
1297                         Assert.AreEqual (2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18), "2,2_5,18");
1298                         Assert.AreEqual (2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19), "2,2_5,19");
1299                         Assert.AreEqual (2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20), "2,2_5,20");
1300                         Assert.AreEqual (2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21), "2,2_5,21");
1301                         Assert.AreEqual (2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22), "2,2_5,22");
1302                         Assert.AreEqual (2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23), "2,2_5,23");
1303                         Assert.AreEqual (2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24), "2,2_5,24");
1304                         Assert.AreEqual (2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25), "2,2_5,25");
1305                         Assert.AreEqual (2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26), "2,2_5,26");
1306                         Assert.AreEqual (2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27), "2,2_5,27");
1307                         Assert.AreEqual (2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28), "2,2_5,28");
1308                 }
1309
1310                 [Test]
1311                 public void Round_OddValue_Negative ()
1312                 {
1313                         decimal five = -5.5555555555555555555555555555m;
1314                         Assert.AreEqual (-6, Decimal.Round (five, 0), "-5,5_,00");
1315                         Assert.AreEqual (-5.6m, Decimal.Round (five, 1), "-5,5_,01");
1316                         Assert.AreEqual (-5.56m, Decimal.Round (five, 2), "-5,5_,02");
1317                         Assert.AreEqual (-5.556m, Decimal.Round (five, 3), "-5,5_,03");
1318                         Assert.AreEqual (-5.5556m, Decimal.Round (five, 4), "-5,5_,04");
1319                         Assert.AreEqual (-5.55556m, Decimal.Round (five, 5), "-5,5_,05");
1320                         Assert.AreEqual (-5.555556m, Decimal.Round (five, 6), "-5,5_,06");
1321                         Assert.AreEqual (-5.5555556m, Decimal.Round (five, 7), "-5,5_,07");
1322                         Assert.AreEqual (-5.55555556m, Decimal.Round (five, 8), "-5,5_,08");
1323                         Assert.AreEqual (-5.555555556m, Decimal.Round (five, 9), "-5,5_,09");
1324                         Assert.AreEqual (-5.5555555556m, Decimal.Round (five, 10), "-5,5_,10");
1325                         Assert.AreEqual (-5.55555555556m, Decimal.Round (five, 11), "-5,5_,11");
1326                         Assert.AreEqual (-5.555555555556m, Decimal.Round (five, 12), "-5,5_,12");
1327                         Assert.AreEqual (-5.5555555555556m, Decimal.Round (five, 13), "-5,5_,13");
1328                         Assert.AreEqual (-5.55555555555556m, Decimal.Round (five, 14), "-5,5_,14");
1329                         Assert.AreEqual (-5.555555555555556m, Decimal.Round (five, 15), "-5,5_,15");
1330                         Assert.AreEqual (-5.5555555555555556m, Decimal.Round (five, 16), "-5,5_,16");
1331                         Assert.AreEqual (-5.55555555555555556m, Decimal.Round (five, 17), "-5,5_,17");
1332                         Assert.AreEqual (-5.555555555555555556m, Decimal.Round (five, 18), "-5,5_,18");
1333                         Assert.AreEqual (-5.5555555555555555556m, Decimal.Round (five, 19), "-5,5_,19");
1334                         Assert.AreEqual (-5.55555555555555555556m, Decimal.Round (five, 20), "-5,5_,20");
1335                         Assert.AreEqual (-5.555555555555555555556m, Decimal.Round (five, 21), "-5,5_,21");
1336                         Assert.AreEqual (-5.5555555555555555555556m, Decimal.Round (five, 22), "-5,5_,22");
1337                         Assert.AreEqual (-5.55555555555555555555556m, Decimal.Round (five, 23), "-5,5_,23");
1338                         Assert.AreEqual (-5.555555555555555555555556m, Decimal.Round (five, 24), "-5,5_,24");
1339                         Assert.AreEqual (-5.5555555555555555555555556m, Decimal.Round (five, 25), "-5,5_,25");
1340                         Assert.AreEqual (-5.55555555555555555555555556m, Decimal.Round (five, 26), "-5,5_,26");
1341                         Assert.AreEqual (-5.555555555555555555555555556m, Decimal.Round (five, 27), "-5,5_,27");
1342                         Assert.AreEqual (-5.5555555555555555555555555555m, Decimal.Round (five, 28), "-5.5_,28");
1343                 }
1344
1345                 [Test]
1346                 public void Round_EvenValue_Negative ()
1347                 {
1348                         Assert.AreEqual (-2, Decimal.Round (-2.5m, 0), "-2,2_5,00");
1349                         Assert.AreEqual (-2.2m, Decimal.Round (-2.25m, 1), "-2,2_5,01");
1350                         Assert.AreEqual (-2.22m, Decimal.Round (-2.225m, 2), "-2,2_5,02");
1351                         Assert.AreEqual (-2.222m, Decimal.Round (-2.2225m, 3), "-2,2_5,03");
1352                         Assert.AreEqual (-2.2222m, Decimal.Round (-2.22225m, 4), "-2,2_5,04");
1353                         Assert.AreEqual (-2.22222m, Decimal.Round (-2.222225m, 5), "-2,2_5,05");
1354                         Assert.AreEqual (-2.222222m, Decimal.Round (-2.2222225m, 6), "-2,2_5,06");
1355                         Assert.AreEqual (-2.2222222m, Decimal.Round (-2.22222225m, 7), "-2,2_5,07");
1356                         Assert.AreEqual (-2.22222222m, Decimal.Round (-2.222222225m, 8), "-2,2_5,08");
1357                         Assert.AreEqual (-2.222222222m, Decimal.Round (-2.2222222225m, 9), "-2,2_5,09");
1358                         Assert.AreEqual (-2.2222222222m, Decimal.Round (-2.22222222225m, 10), "-2,2_5,10");
1359                         Assert.AreEqual (-2.22222222222m, Decimal.Round (-2.222222222225m, 11), "-2,2_5,11");
1360                         Assert.AreEqual (-2.222222222222m, Decimal.Round (-2.2222222222225m, 12), "-2,2_5,12");
1361                         Assert.AreEqual (-2.2222222222222m, Decimal.Round (-2.22222222222225m, 13), "-2,2_5,13");
1362                         Assert.AreEqual (-2.22222222222222m, Decimal.Round (-2.222222222222225m, 14), "-2,2_5,14");
1363                         Assert.AreEqual (-2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15), "-2,2_5,15");
1364                         Assert.AreEqual (-2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16), "-2,2_5,16");
1365                         Assert.AreEqual (-2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17), "-2,2_5,17");
1366                         Assert.AreEqual (-2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18), "-2,2_5,18");
1367                         Assert.AreEqual (-2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19), "-2,2_5,19");
1368                         Assert.AreEqual (-2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20), "-2,2_5,20");
1369                         Assert.AreEqual (-2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21), "-2,2_5,21");
1370                         Assert.AreEqual (-2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22), "-2,2_5,22");
1371                         Assert.AreEqual (-2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23), "-2,2_5,23");
1372                         Assert.AreEqual (-2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24), "-2,2_5,24");
1373                         Assert.AreEqual (-2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25), "-2,2_5,25");
1374                         Assert.AreEqual (-2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26), "-2,2_5,26");
1375                         Assert.AreEqual (-2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27), "-2,2_5,27");
1376                         Assert.AreEqual (-2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28), "-2,2_5,28");
1377                 }
1378
1379                 [Test] // bug #59425
1380                 [SetCulture("en-US")]
1381                 public void ParseAndKeepPrecision ()
1382                 {
1383                         string value = "5";
1384                         Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1385                         value += '.';
1386                         for (int i = 0; i < 28; i++) {
1387                                 value += "0";
1388                                 Assert.AreEqual (value, Decimal.Parse (value).ToString (), i.ToString ());
1389                         }
1390
1391                         value = "-5";
1392                         Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1393                         value += '.';
1394                         for (int i = 0; i < 28; i++) {
1395                                 value += "0";
1396                                 Assert.AreEqual (value, Decimal.Parse (value).ToString (), "-" + i.ToString ());
1397                         }
1398                 }
1399
1400                 [Test]
1401                 [SetCulture("en-US")]
1402                 public void ToString_G ()
1403                 {
1404                         Assert.AreEqual ("1.0", (1.0m).ToString (), "00");
1405                         Assert.AreEqual ("0.1", (0.1m).ToString (), "01");
1406                         Assert.AreEqual ("0.01", (0.01m).ToString (), "02");
1407                         Assert.AreEqual ("0.001", (0.001m).ToString (), "03");
1408                         Assert.AreEqual ("0.0001", (0.0001m).ToString (), "04");
1409                         Assert.AreEqual ("0.00001", (0.00001m).ToString (), "05");
1410                         Assert.AreEqual ("0.000001", (0.000001m).ToString (), "06");
1411                         Assert.AreEqual ("0.0000001", (0.0000001m).ToString (), "07");
1412                         Assert.AreEqual ("0.00000001", (0.00000001m).ToString (), "08");
1413                         Assert.AreEqual ("0.000000001", (0.000000001m).ToString (), "09");
1414                         Assert.AreEqual ("0.0000000001", (0.0000000001m).ToString (), "10");
1415                         Assert.AreEqual ("0.00000000001", (0.00000000001m).ToString (), "11");
1416                         Assert.AreEqual ("0.000000000001", (0.000000000001m).ToString (), "12");
1417                         Assert.AreEqual ("0.0000000000001", (0.0000000000001m).ToString (), "13");
1418                         Assert.AreEqual ("0.00000000000001", (0.00000000000001m).ToString (), "14");
1419                         Assert.AreEqual ("0.000000000000001", (0.000000000000001m).ToString (), "15");
1420                         Assert.AreEqual ("0.0000000000000001", (0.0000000000000001m).ToString (), "16");
1421                         Assert.AreEqual ("0.00000000000000001", (0.00000000000000001m).ToString (), "17");
1422                         Assert.AreEqual ("0.000000000000000001", (0.000000000000000001m).ToString (), "18");
1423                         Assert.AreEqual ("0.0000000000000000001", (0.0000000000000000001m).ToString (), "19");
1424                         Assert.AreEqual ("0.00000000000000000001", (0.00000000000000000001m).ToString (), "20");
1425                         Assert.AreEqual ("0.000000000000000000001", (0.000000000000000000001m).ToString (), "21");
1426                         Assert.AreEqual ("0.0000000000000000000001", (0.0000000000000000000001m).ToString (), "22");
1427                         Assert.AreEqual ("0.00000000000000000000001", (0.00000000000000000000001m).ToString (), "23");
1428                         Assert.AreEqual ("0.000000000000000000000001", (0.000000000000000000000001m).ToString (), "24");
1429                         Assert.AreEqual ("0.0000000000000000000000001", (0.0000000000000000000000001m).ToString (), "25");
1430                         Assert.AreEqual ("0.00000000000000000000000001", (0.00000000000000000000000001m).ToString (), "26");
1431                         Assert.AreEqual ("0.000000000000000000000000001", (0.000000000000000000000000001m).ToString (), "27");
1432                         Assert.AreEqual ("0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString (), "28");
1433                 }
1434
1435                 [Test]
1436                 public void MidpointRoundingAwayFromZero ()
1437                 {
1438                         MidpointRounding m = MidpointRounding.AwayFromZero;
1439                         Assert.AreEqual (4, Math.Round (3.5M, m), "#1");
1440                         Assert.AreEqual (3, Math.Round (2.8M, m), "#2");
1441                         Assert.AreEqual (3, Math.Round (2.5M, m), "#3");
1442                         Assert.AreEqual (2, Math.Round (2.1M, m), "#4");
1443                         Assert.AreEqual (-2, Math.Round (-2.1M, m), "#5");
1444                         Assert.AreEqual (-3, Math.Round (-2.5M, m), "#6");
1445                         Assert.AreEqual (-3, Math.Round (-2.8M, m), "#7");
1446                         Assert.AreEqual (-4, Math.Round (-3.5M, m), "#8");
1447
1448                         Assert.AreEqual (3.1M, Math.Round (3.05M, 1, m), "#9");
1449                         Assert.AreEqual (2.1M, Math.Round (2.08M, 1, m), "#10");
1450                         Assert.AreEqual (2.1M, Math.Round (2.05M, 1, m), "#11");
1451                         Assert.AreEqual (2.0M, Math.Round (2.01M, 1, m), "#12");
1452                         Assert.AreEqual (-2.0M, Math.Round (-2.01M, 1, m), "#13");
1453                         Assert.AreEqual (-2.1M, Math.Round (-2.05M, 1, m), "#14");
1454                         Assert.AreEqual (-2.1M, Math.Round (-2.08M, 1, m), "#15");
1455                         Assert.AreEqual (-3.1M, Math.Round (-3.05M, 1, m), "#16");
1456                 }
1457
1458                 [Test] // bug #4814
1459                 [SetCulture("")]
1460                 public void Parse_NumberGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
1461                 {
1462                         NumberFormatInfo nf = new NumberFormatInfo ();
1463                         nf.NumberGroupSeparator = "";
1464                         Decimal.Parse ("1.5", nf);
1465                 }
1466
1467                 [Test] // bug #4814
1468                 [SetCulture("")]
1469                 public void Parse_CurrencyGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
1470                 {
1471                         NumberFormatInfo nf = new NumberFormatInfo ();
1472                         nf.CurrencyGroupSeparator = "";
1473                         Decimal.Parse ("\u00A41.5", NumberStyles.Currency, nf);
1474                 }
1475
1476                 [Test] // bug #4814
1477                 [SetCulture("")]
1478                 public void Parse_LeadingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1479                 {
1480                         NumberFormatInfo nf = new NumberFormatInfo ();
1481                         nf.PositiveSign = "";
1482                         try {
1483                                 Decimal.Parse ("+15", nf);
1484                         } catch (FormatException) {
1485                                 return;
1486                         }
1487
1488                         Assert.Fail ("Expected FormatException");
1489                 }
1490
1491                 [Test] // bug #4814
1492                 [SetCulture("")]
1493                 public void Parse_LeadingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1494                 {
1495                         NumberFormatInfo nf = new NumberFormatInfo ();
1496                         nf.NegativeSign = "";
1497                         try {
1498                                 Decimal.Parse ("-15", nf);
1499                         } catch (FormatException) {
1500                                 return;
1501                         }
1502
1503                         Assert.Fail ("Expected FormatException");
1504                 }
1505
1506                 [Test] // bug #4814
1507                 [SetCulture("")]
1508                 public void Parse_TrailingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1509                 {
1510                         NumberFormatInfo nf = new NumberFormatInfo ();
1511                         nf.PositiveSign = "";
1512                         try {
1513                                 Decimal.Parse ("15+", nf);
1514                         } catch (FormatException) {
1515                                 return;
1516                         }
1517
1518                         Assert.Fail ("Expected FormatException");
1519                 }
1520
1521                 [Test] // bug #4814
1522                 [SetCulture("")]
1523                 public void Parse_TrailingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1524                 {
1525                         NumberFormatInfo nf = new NumberFormatInfo ();
1526                         nf.NegativeSign = "";
1527                         try {
1528                                 Decimal.Parse ("15-", nf);
1529                         } catch (FormatException) {
1530                                 return;
1531                         }
1532
1533                         Assert.Fail ("Expected FormatException");
1534                 }
1535
1536                 [Test]
1537                 [SetCulture("en-US")]
1538                 public void ParseZeros ()
1539                 {
1540                         var d = Decimal.Parse ("0.000");
1541                         var bits = Decimal.GetBits (d);
1542                         Assert.AreEqual (0, bits[0], "#1");
1543                         Assert.AreEqual (0, bits[1], "#2");
1544                         Assert.AreEqual (0, bits[2], "#3");
1545                         Assert.AreEqual (196608, bits[3], "#4");
1546                         Assert.AreEqual ("0.000", d.ToString (), "#5");
1547
1548                         d = Decimal.Parse("0.000000000000000000000000000000000000000000000000000000000000000000");
1549                         Assert.AreEqual ("0.0000000000000000000000000000", d.ToString (), "#10");
1550
1551                         d = Decimal.Parse ("0.");
1552                         Assert.AreEqual ("0", d.ToString (), "#11");
1553                 }
1554         }
1555 }