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