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

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