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

   1 // DecimalTest.cs - NUnit Test Cases for the System.Decimal struct\r
   2 //\r
   3 // Author: Martin Weindel (martin.weindel@t-online.de)\r
   4 //\r
   5 // (C) Martin Weindel, 2001\r
   6 // \r
   7 \r
   8 using NUnit.Framework;\r
   9 using System;\r
  10 \r
  11 using System.Globalization;\r
  12 using System.Runtime.CompilerServices;\r
  13 using System.Threading;\r
  14 \r
  15 namespace MonoTests.System {\r
  16     internal struct ParseTest\r
  17     {\r
  18         public ParseTest(String str, bool exceptionFlag)\r
  19         {\r
  20             this.str = str;\r
  21             this.exceptionFlag = exceptionFlag;\r
  22             this.style = NumberStyles.Number;\r
  23             this.d = 0;\r
  24         }\r
  25 \r
  26         public ParseTest(String str, Decimal d)\r
  27         {\r
  28             this.str = str;\r
  29             this.exceptionFlag = false;\r
  30             this.style = NumberStyles.Number;\r
  31             this.d = d;\r
  32         }\r
  33 \r
  34         public ParseTest(String str, Decimal d, NumberStyles style)\r
  35         {\r
  36             this.str = str;\r
  37             this.exceptionFlag = false;\r
  38             this.style = style;\r
  39             this.d = d;\r
  40         }\r
  41 \r
  42         public String str;\r
  43         public Decimal d;\r
  44         public NumberStyles style;\r
  45         public bool exceptionFlag;\r
  46     }\r
  47 \r
  48     internal struct ToStringTest\r
  49     {\r
  50         public ToStringTest(String format, Decimal d, String str)\r
  51         {\r
  52             this.format = format;\r
  53             this.d = d;\r
  54             this.str = str;\r
  55         }\r
  56 \r
  57         public String format;\r
  58         public Decimal d;\r
  59         public String str;\r
  60     }\r
  61 \r
  62     [TestFixture]\r
  63     public class DecimalTest : Assertion\r
  64     {\r
  65         private const int negativeBitValue = unchecked ((int)0x80000000);\r
  66         private const int negativeScale4Value = unchecked ((int)0x80040000);\r
  67         private int [] parts0 = {0,0,0,0}; //Positive Zero.\r
  68         private int [] parts1 = {1,0,0,0};\r
  69         private int [] parts2 = {0,1,0,0};\r
  70         private int [] parts3 = {0,0,1,0};\r
  71         private int [] parts4 = {0,0,0,negativeBitValue}; // Negative zero.\r
  72         private int [] parts5 = {1,1,1,0};\r
  73         private int [] partsMaxValue = {-1,-1,-1,0};\r
  74         private int [] partsMinValue = {-1,-1,-1,negativeBitValue};\r
  75         private int [] parts6 = {1234, 5678, 8888, negativeScale4Value};\r
  76         private NumberFormatInfo NfiUser;\r
  77 \r
  78         private CultureInfo old_culture;\r
  79 \r
  80         [TestFixtureSetUp]\r
  81         public void FixtureSetUp ()\r
  82         {\r
  83                 old_culture = Thread.CurrentThread.CurrentCulture;\r
  84 \r
  85                 // Set culture to en-US and don't let the user override.\r
  86                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);\r
  87 \r
  88                 NfiUser = new NumberFormatInfo();\r
  89                 NfiUser.CurrencyDecimalDigits = 3;\r
  90                 NfiUser.CurrencyDecimalSeparator = ",";\r
  91                 NfiUser.CurrencyGroupSeparator = "_";\r
  92                 NfiUser.CurrencyGroupSizes = new int[] { 2,1,0 };\r
  93                 NfiUser.CurrencyNegativePattern = 10;\r
  94                 NfiUser.CurrencyPositivePattern = 3;\r
  95                 NfiUser.CurrencySymbol = "XYZ";\r
  96                 NfiUser.NumberDecimalSeparator = "##";\r
  97                 NfiUser.NumberDecimalDigits = 4;\r
  98                 NfiUser.NumberGroupSeparator = "__";\r
  99                 NfiUser.NumberGroupSizes = new int[] { 2,1 };\r
 100                 NfiUser.PercentDecimalDigits = 1;\r
 101                 NfiUser.PercentDecimalSeparator = ";";\r
 102                 NfiUser.PercentGroupSeparator = "~";\r
 103                 NfiUser.PercentGroupSizes = new int[] {1};\r
 104                 NfiUser.PercentNegativePattern = 2;\r
 105                 NfiUser.PercentPositivePattern = 2;\r
 106                 NfiUser.PercentSymbol = "%%%";\r
 107         }\r
 108 \r
 109         [TestFixtureTearDown]\r
 110         public void FixtureTearDown ()\r
 111         {\r
 112                 Thread.CurrentThread.CurrentCulture = old_culture;\r
 113         }\r
 114 \r
 115         public void TestToString()\r
 116         {\r
 117             ToStringTest[] tab = {\r
 118                 new ToStringTest("F", 12.345678m, "12.35"),\r
 119                 new ToStringTest("F3", 12.345678m, "12.346"),\r
 120                 new ToStringTest("F0", 12.345678m, "12"),\r
 121                 new ToStringTest("F7", 12.345678m, "12.3456780"),\r
 122                 new ToStringTest("g", 12.345678m, "12.345678"),\r
 123                 new ToStringTest("E", 12.345678m, "1.234568E+001"),\r
 124                 new ToStringTest("E3", 12.345678m, "1.235E+001"),\r
 125                 new ToStringTest("E0", 12.345678m, "1E+001"),\r
 126                 new ToStringTest("e8", 12.345678m, "1.23456780e+001"),\r
 127                 new ToStringTest("F", 0.0012m, "0.00"),\r
 128                 new ToStringTest("F3", 0.0012m, "0.001"),\r
 129                 new ToStringTest("F0", 0.0012m, "0"),\r
 130                 new ToStringTest("F6", 0.0012m, "0.001200"),\r
 131                 new ToStringTest("e", 0.0012m, "1.200000e-003"),\r
 132                 new ToStringTest("E3", 0.0012m, "1.200E-003"),\r
 133                 new ToStringTest("E0", 0.0012m, "1E-003"),\r
 134                 new ToStringTest("E6", 0.0012m, "1.200000E-003"),\r
 135                 new ToStringTest("F4", -0.001234m, "-0.0012"),\r
 136                 new ToStringTest("E3", -0.001234m, "-1.234E-003"),\r
 137 #if NET_1_0\r
 138                 new ToStringTest("g", -0.000012m, "-1.2e-05"),\r
 139 #else\r
 140                 new ToStringTest("g", -0.000012m, "-0.000012"),\r
 141 #endif\r
 142                 new ToStringTest("g", -0.00012m, "-0.00012"),\r
 143                 new ToStringTest("g4", -0.00012m, "-0.00012"),\r
 144                 new ToStringTest("g7", -0.00012m, "-0.00012"),\r
 145                 new ToStringTest("g", -0.0001234m, "-0.0001234"),\r
 146                 new ToStringTest("g", -0.0012m, "-0.0012"),\r
 147                 new ToStringTest("g", -0.001234m, "-0.001234"),\r
 148                 new ToStringTest("g", -0.012m, "-0.012"),\r
 149                 new ToStringTest("g4", -0.012m, "-0.012"),\r
 150                 new ToStringTest("g", -0.12m, "-0.12"),\r
 151                 new ToStringTest("g", -1.2m, "-1.2"),\r
 152                 new ToStringTest("g4", -120m, "-120"),\r
 153                 new ToStringTest("g", -12m, "-12"),\r
 154                 new ToStringTest("g", -120m, "-120"),\r
 155                 new ToStringTest("g", -1200m, "-1200"),\r
 156                 new ToStringTest("g4", -1200m, "-1200"),\r
 157                 new ToStringTest("g", -1234m, "-1234"),\r
 158                 new ToStringTest("g", -12000m, "-12000"),\r
 159                 new ToStringTest("g4", -12000m, "-1.2e+04"),\r
 160                 new ToStringTest("g5", -12000m, "-12000"),\r
 161                 new ToStringTest("g", -12345m, "-12345"),\r
 162                 new ToStringTest("g", -120000m, "-120000"),\r
 163                 new ToStringTest("g4", -120000m, "-1.2e+05"),\r
 164                 new ToStringTest("g5", -120000m, "-1.2e+05"),\r
 165                 new ToStringTest("g6", -120000m, "-120000"),\r
 166                 new ToStringTest("g", -123456.1m, "-123456.1"),\r
 167                 new ToStringTest("g5", -123456.1m, "-1.2346e+05"),\r
 168                 new ToStringTest("g6", -123456.1m, "-123456"),\r
 169                 new ToStringTest("g", -1200000m, "-1200000"),\r
 170                 new ToStringTest("g", -123456.1m, "-123456.1"),\r
 171                 new ToStringTest("g", -123456.1m, "-123456.1"),\r
 172                 new ToStringTest("g", -1234567.1m, "-1234567.1"),\r
 173                 new ToStringTest("g", -12000000m, "-12000000"),\r
 174                 new ToStringTest("g", -12345678.1m, "-12345678.1"),\r
 175                 new ToStringTest("g", -12000000000000000000m, "-12000000000000000000"),\r
 176                 new ToStringTest("F", -123, "-123.00"),\r
 177                 new ToStringTest("F3", -123, "-123.000"),\r
 178                 new ToStringTest("F0", -123, "-123"),\r
 179                 new ToStringTest("E3", -123, "-1.230E+002"),\r
 180                 new ToStringTest("E0", -123, "-1E+002"),\r
 181                 new ToStringTest("E", -123, "-1.230000E+002"),\r
 182                 new ToStringTest("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),\r
 183                 new ToStringTest("F", Decimal.MinValue, "-79228162514264337593543950335.00"),\r
 184                 new ToStringTest("F0", Decimal.MinValue, "-79228162514264337593543950335"),\r
 185                 new ToStringTest("E", Decimal.MinValue, "-7.922816E+028"),\r
 186                 new ToStringTest("E3", Decimal.MinValue, "-7.923E+028"),\r
 187                 new ToStringTest("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),\r
 188                 new ToStringTest("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),\r
 189                 new ToStringTest("E0", Decimal.MinValue, "-8E+028"),\r
 190                 new ToStringTest("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),\r
 191                 new ToStringTest("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),\r
 192                 new ToStringTest("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),\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("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),\r
 197                 new ToStringTest("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),\r
 198                 new ToStringTest("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),\r
 199                 new ToStringTest("P", 123456.7891m, "12,345,678.91 %"),\r
 200                 new ToStringTest("P", -123456.7892m, "-12,345,678.92 %"),\r
 201                 new ToStringTest("P3", 1234.56789m, "123,456.789 %"),\r
 202             };\r
 203 \r
 204             NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;\r
 205 \r
 206             for (int i = 0; i < tab.Length; i++) \r
 207             {\r
 208                 try\r
 209                 {\r
 210                     string s = tab[i].d.ToString(tab[i].format, nfi);\r
 211                     AssertEquals("A01 tab[" + i + "].format = '" + tab[i].format + "')", tab[i].str, s);\r
 212                 } \r
 213                 catch (OverflowException)\r
 214                 {\r
 215                     Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");\r
 216                 }\r
 217                 catch (NUnit.Framework.AssertionException e) {\r
 218                         throw e;\r
 219                 }\r
 220                 catch (Exception e) {\r
 221                         Fail ("Unexpected Exception when i = " + i + ". e = " + e);\r
 222                 }\r
 223             }      \r
 224         }\r
 225 \r
 226         public void TestCurrencyPattern()\r
 227         {\r
 228             NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
 229             Decimal d = -1234567.8976m;\r
 230             string[] ergCurrencyNegativePattern = new String[16] {\r
 231                 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",\r
 232                 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",\r
 233                 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",\r
 234                 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",\r
 235             };\r
 236 \r
 237             for (int i = 0; i < ergCurrencyNegativePattern.Length; i++) \r
 238             {\r
 239                 nfi2.CurrencyNegativePattern = i;\r
 240                 if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i]) \r
 241                 {\r
 242                     Fail("CurrencyNegativePattern #" + i + " failed: " +\r
 243                         d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);\r
 244                 }\r
 245             }\r
 246 \r
 247             d = 1234567.8976m;\r
 248             string[] ergCurrencyPositivePattern = new String[4] {\r
 249                 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",\r
 250             };\r
 251 \r
 252             for (int i = 0; i < ergCurrencyPositivePattern.Length; i++) \r
 253             {\r
 254                 nfi2.CurrencyPositivePattern = i;\r
 255                 if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i]) \r
 256                 {\r
 257                     Fail("CurrencyPositivePattern #" + i + " failed: " +\r
 258                         d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);\r
 259                 }\r
 260             }\r
 261         }\r
 262 \r
 263         public void TestNumberNegativePattern()\r
 264         {\r
 265             NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
 266             Decimal d = -1234.89765m;\r
 267             string[] ergNumberNegativePattern = new String[5] {\r
 268                 "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",\r
 269             };\r
 270 \r
 271             for (int i = 0; i < ergNumberNegativePattern.Length; i++) \r
 272             {\r
 273                 nfi2.NumberNegativePattern = i;\r
 274                 AssertEquals ("NumberNegativePattern #" + i, ergNumberNegativePattern[i], d.ToString("N", nfi2));\r
 275             }\r
 276         }\r
 277         \r
 278         public void TestPercentPattern()\r
 279         {\r
 280             NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
 281             Decimal d = -1234.8976m;\r
 282             string[] ergPercentNegativePattern = new String[3] {\r
 283                 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"\r
 284             };\r
 285 \r
 286             for (int i = 0; i < ergPercentNegativePattern.Length; i++) \r
 287             {\r
 288                 nfi2.PercentNegativePattern = i;\r
 289                 if (d.ToString("P", nfi2) != ergPercentNegativePattern[i]) \r
 290                 {\r
 291                     Fail("PercentNegativePattern #" + i + " failed: " +\r
 292                         d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);\r
 293                 }\r
 294             }\r
 295 \r
 296             d = 1234.8976m;\r
 297             string[] ergPercentPositivePattern = new String[3] {\r
 298                 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"\r
 299             };\r
 300 \r
 301             for (int i = 0; i < ergPercentPositivePattern.Length; i++) \r
 302             {\r
 303                 nfi2.PercentPositivePattern = i;\r
 304                 if (d.ToString("P", nfi2) != ergPercentPositivePattern[i]) \r
 305                 {\r
 306                     Fail("PercentPositivePattern #" + i + " failed: " +\r
 307                         d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);\r
 308                 }\r
 309             }\r
 310         }\r
 311 \r
 312         public void TestParse()\r
 313         {\r
 314             ParseTest[] tab = {\r
 315                 new ParseTest("1.2345", 1.2345m),\r
 316                 new ParseTest("-9876543210", -9876543210m),\r
 317                 new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol \r
 318                         + " (  79,228,162,514,264,337,593,543,950,335.000 ) ", Decimal.MinValue, NumberStyles.Currency),\r
 319                 new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),\r
 320                 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),\r
 321                 new ParseTest("  47896396.457983645462346E10  ", 478963964579836454.62346m, NumberStyles.Float),\r
 322                 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),\r
 323                 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),\r
 324                 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),\r
 325                 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),\r
 326                 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),\r
 327                 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)\r
 328             };\r
 329 \r
 330             Decimal d;\r
 331             for (int i = 0; i < tab.Length; i++) \r
 332             {\r
 333                 try\r
 334                 {\r
 335                     d = Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);\r
 336                     if (tab[i].exceptionFlag)\r
 337                     {\r
 338                         Fail(tab[i].str + ": missing exception !");\r
 339                     }\r
 340                     else if (d != tab[i].d) \r
 341                     {\r
 342                         Fail(tab[i].str + " != " + d);\r
 343                     }\r
 344                 } \r
 345                 catch (OverflowException)\r
 346                 {\r
 347                     if (!tab[i].exceptionFlag)\r
 348                     {\r
 349                         Fail(tab[i].str + ": unexpected exception !");\r
 350                     }\r
 351                 }\r
 352             }  \r
 353     \r
 354             try \r
 355             {\r
 356                 d = Decimal.Parse(null);\r
 357                 Fail("Expected ArgumentNullException");\r
 358             }\r
 359             catch (ArgumentNullException)\r
 360             {\r
 361                 //ok\r
 362             }\r
 363 \r
 364             try \r
 365             {\r
 366                 d = Decimal.Parse("123nx");\r
 367                 Fail("Expected FormatException");\r
 368             }\r
 369             catch (FormatException)\r
 370             {\r
 371                 //ok\r
 372             }\r
 373 \r
 374             try \r
 375             {\r
 376                 d = Decimal.Parse("79228162514264337593543950336");\r
 377                 Fail("Expected OverflowException" + d);\r
 378             }\r
 379             catch (OverflowException)\r
 380             {\r
 381                 //ok\r
 382             }\r
 383         }\r
 384 \r
 385         public void TestConstants()\r
 386         {\r
 387             AssertEquals ("Zero", 0m, Decimal.Zero);\r
 388             AssertEquals ("One", 1m, Decimal.One);\r
 389             AssertEquals ("MinusOne", -1m, Decimal.MinusOne);\r
 390             AssertEquals ("MaxValue", 79228162514264337593543950335m, Decimal.MaxValue);\r
 391             AssertEquals ("MinValue", -79228162514264337593543950335m, Decimal.MinValue);       \r
 392             Assert ("MinusOne 2", -1m == Decimal.MinusOne);\r
 393         }\r
 394 \r
 395         public void TestConstructInt32()\r
 396         {\r
 397             decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};\r
 398             int[] itab = {0, 1, -1, 123456, -1234567};\r
 399 \r
 400             Decimal d;\r
 401             \r
 402             for (int i = 0; i < dtab.GetLength(0); i++)\r
 403             {\r
 404                 d = new Decimal(itab[i]);\r
 405                 if ((decimal)d != dtab[i]) \r
 406                 {\r
 407                     Fail("Int32 -> Decimal: " + itab[i] + " != " + d);\r
 408                 }\r
 409                 else \r
 410                 {\r
 411                     int n = (int) d;\r
 412                     if (n != itab[i]) \r
 413                     {\r
 414                         Fail("Decimal -> Int32: " + d + " != " + itab[i]);\r
 415                     }\r
 416                 }\r
 417             }\r
 418 \r
 419             d = new Decimal(Int32.MaxValue);\r
 420             Assert((int)d == Int32.MaxValue);\r
 421 \r
 422             d = new Decimal(Int32.MinValue);\r
 423             Assert((int)d == Int32.MinValue);\r
 424         }\r
 425 \r
 426         public void TestConstructUInt32()\r
 427         {\r
 428             decimal[] dtab = {0m, 1m, 123456m, 123456789m};\r
 429             uint[] itab = {0, 1, 123456, 123456789};\r
 430 \r
 431             Decimal d;\r
 432             \r
 433             for (int i = 0; i < dtab.GetLength(0); i++)\r
 434             {\r
 435                 d = new Decimal(itab[i]);\r
 436                 if ((decimal)d != dtab[i]) \r
 437                 {\r
 438                     Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);\r
 439                 }\r
 440                 else \r
 441                 {\r
 442                     uint n = (uint) d;\r
 443                     if (n != itab[i]) \r
 444                     {\r
 445                         Fail("Decimal -> UInt32: " + d + " != " + itab[i]);\r
 446                     }\r
 447                 }\r
 448             }\r
 449 \r
 450             d = new Decimal(UInt32.MaxValue);\r
 451             Assert((uint)d == UInt32.MaxValue);\r
 452 \r
 453             d = new Decimal(UInt32.MinValue);\r
 454             Assert((uint)d == UInt32.MinValue);\r
 455         }\r
 456 \r
 457         public void TestConstructInt64()\r
 458         {\r
 459             decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};\r
 460             long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};\r
 461 \r
 462             Decimal d;\r
 463             \r
 464             for (int i = 0; i < dtab.GetLength(0); i++)\r
 465             {\r
 466                 d = new Decimal(itab[i]);\r
 467                 if ((decimal)d != dtab[i]) \r
 468                 {\r
 469                     Fail("Int64 -> Decimal: " + itab[i] + " != " + d);\r
 470                 }\r
 471                 else \r
 472                 {\r
 473                     long n = (long) d;\r
 474                     if (n != itab[i]) \r
 475                     {\r
 476                         Fail("Decimal -> Int64: " + d + " != " + itab[i]);\r
 477                     }\r
 478                 }\r
 479             }\r
 480 \r
 481             d = new Decimal(Int64.MaxValue);\r
 482             Assert((long)d == Int64.MaxValue);\r
 483 \r
 484             d = new Decimal(Int64.MinValue);\r
 485             Assert((long)d == Int64.MinValue);\r
 486         }\r
 487 \r
 488         public void TestConstructUInt64()\r
 489         {\r
 490             decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};\r
 491             ulong[] itab = {0, 1, 987654321, 123456789876543210L};\r
 492 \r
 493             Decimal d;\r
 494             \r
 495             for (int i = 0; i < dtab.GetLength(0); i++)\r
 496             {\r
 497                 d = new Decimal(itab[i]);\r
 498                 if ((decimal)d != dtab[i]) \r
 499                 {\r
 500                     Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);\r
 501                 }\r
 502                 else \r
 503                 {\r
 504                     ulong n = (ulong) d;\r
 505                     if (n != itab[i]) \r
 506                     {\r
 507                         Fail("Decimal -> UInt64: " + d + " != " + itab[i]);\r
 508                     }\r
 509                 }\r
 510             }\r
 511 \r
 512             d = new Decimal(UInt64.MaxValue);\r
 513             Assert((ulong)d == UInt64.MaxValue);\r
 514 \r
 515             d = new Decimal(UInt64.MinValue);\r
 516             Assert((ulong)d == UInt64.MinValue);\r
 517         }\r
 518 \r
 519         public void TestConstructSingle()\r
 520         {\r
 521             Decimal d;\r
 522 \r
 523             d = new Decimal(-1.2345678f);\r
 524             AssertEquals("A#01", -1.234568m, (decimal)d);\r
 525 \r
 526             d=3;\r
 527             AssertEquals("A#02", 3.0f, (float)d);\r
 528 \r
 529             d = new Decimal(0.0f);\r
 530             AssertEquals("A#03", 0m, (decimal)d);\r
 531             AssertEquals("A#04", 0.0f, (float)d);\r
 532 \r
 533             d = new Decimal(1.0f);\r
 534             AssertEquals("A#05", 1m, (decimal)d);\r
 535             AssertEquals("A#06", 1.0f, (float)d);\r
 536 \r
 537             d = new Decimal(-1.2345678f);\r
 538             AssertEquals("A#07", -1.234568m, (decimal)d);\r
 539             AssertEquals("A#08", -1.234568f, (float)d);\r
 540 \r
 541             d = new Decimal(1.2345673f);\r
 542             AssertEquals("A#09", 1.234567m, (decimal)d);\r
 543 \r
 544             d = new Decimal(1.2345673e7f);\r
 545             AssertEquals("A#10", 12345670m, (decimal)d);\r
 546 \r
 547             d = new Decimal(1.2345673e-17f);\r
 548             AssertEquals("A#11", 0.00000000000000001234567m, (decimal)d);\r
 549             AssertEquals("A#12", 1.234567e-17f, (float)d);\r
 550 \r
 551             // test exceptions\r
 552             try\r
 553             {\r
 554                 d = new Decimal(Single.MaxValue);\r
 555                 Fail();\r
 556             } \r
 557             catch (OverflowException) \r
 558             {\r
 559             }\r
 560 \r
 561             try\r
 562             {\r
 563                 d = new Decimal(Single.NaN);\r
 564                 Fail();\r
 565             } \r
 566             catch (OverflowException) \r
 567             {\r
 568             }\r
 569 \r
 570             try\r
 571             {\r
 572                 d = new Decimal(Single.PositiveInfinity);\r
 573                 Fail();\r
 574             } \r
 575             catch (OverflowException) \r
 576             {\r
 577             }\r
 578         }\r
 579 \r
 580         public void TestConstructSingleRounding()\r
 581         {\r
 582             decimal d;\r
 583 \r
 584             d = new Decimal(1765.2356f);\r
 585             Assert(d == 1765.236m);\r
 586 \r
 587             d = new Decimal(1765.23554f);\r
 588             Assert("failed banker's rule rounding test 1", d == 1765.236m);\r
 589 \r
 590             d = new Decimal(1765.2354f);\r
 591             Assert(d == 1765.235m);\r
 592 \r
 593             d = new Decimal(1765.2346f);\r
 594             Assert(d == 1765.235m);\r
 595 \r
 596             d = new Decimal(1765.23454f);\r
 597             Assert("failed banker's rule rounding test 2", d == 1765.234m);\r
 598 \r
 599             d = new Decimal(1765.2344f);\r
 600             Assert(d == 1765.234m);\r
 601 \r
 602             d = new Decimal(0.00017652356f);\r
 603             Assert(d == 0.0001765236m);\r
 604 \r
 605             d = new Decimal(0.000176523554f);\r
 606             Assert("failed banker's rule rounding test 3", d == 0.0001765236m);\r
 607 \r
 608             d = new Decimal(0.00017652354f);\r
 609             Assert(d == 0.0001765235m);\r
 610 \r
 611             d = new Decimal(0.00017652346f);\r
 612             Assert(d == 0.0001765235m);\r
 613 \r
 614             d = new Decimal(0.000176523454f);\r
 615             Assert("failed banker's rule rounding test 4", d == 0.0001765234m);\r
 616 \r
 617             d = new Decimal(0.00017652344f);\r
 618             Assert(d == 0.0001765234m);\r
 619 \r
 620             d = new Decimal(3.7652356e10f);\r
 621             Assert(d == 37652360000m);\r
 622 \r
 623             d = new Decimal(3.7652356e20f);\r
 624             Assert(d == 376523600000000000000m);\r
 625 \r
 626             d = new Decimal(3.76523554e20f);\r
 627             Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);\r
 628 \r
 629             d = new Decimal(3.7652352e20f);\r
 630             Assert(d == 376523500000000000000m);\r
 631 \r
 632             d = new Decimal(3.7652348e20f);\r
 633             Assert(d == 376523500000000000000m);\r
 634 \r
 635             d = new Decimal(3.76523454e20f);\r
 636             Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);\r
 637 \r
 638             d = new Decimal(3.7652342e20f);\r
 639             Assert(d == 376523400000000000000m);\r
 640         }\r
 641 \r
 642         public void TestConstructDouble()\r
 643         {\r
 644             Decimal d;\r
 645 \r
 646             d = new Decimal(0.0);\r
 647             Assert((decimal)d == 0m);\r
 648 \r
 649             d = new Decimal(1.0);\r
 650             Assert((decimal)d == 1m);\r
 651             Assert(1.0 == (double)d);\r
 652 \r
 653             d = new Decimal(-1.2345678901234);\r
 654             Assert((decimal)d == -1.2345678901234m);\r
 655             Assert(-1.2345678901234 == (double)d);\r
 656 \r
 657             d = new Decimal(1.2345678901234);\r
 658             Assert((decimal)d == 1.2345678901234m);\r
 659 \r
 660             d = new Decimal(1.2345678901234e8);\r
 661             Assert((decimal)d == 123456789.01234m);\r
 662             Assert(1.2345678901234e8 == (double)d);\r
 663 \r
 664             d = new Decimal(1.2345678901234e16);\r
 665             Assert((decimal)d == 12345678901234000m);\r
 666             Assert(1.2345678901234e16 == (double)d);\r
 667 \r
 668             d = new Decimal(1.2345678901234e24);\r
 669             Assert((decimal)d == 1234567890123400000000000m);\r
 670             Assert(1.2345678901234e24 == (double)d);\r
 671 \r
 672             d = new Decimal(1.2345678901234e28);\r
 673             Assert((decimal)d == 1.2345678901234e28m);\r
 674             Assert(1.2345678901234e28 == (double)d);\r
 675 \r
 676             d = new Decimal(7.2345678901234e28);\r
 677             Assert((decimal)d == 7.2345678901234e28m);\r
 678             Assert(new Decimal((double)d) == d);\r
 679 \r
 680             d = new Decimal(1.2345678901234e-8);\r
 681             Assert((decimal)d == 1.2345678901234e-8m);\r
 682 \r
 683             d = new Decimal(1.2345678901234e-14);\r
 684             Assert((decimal)d == 1.2345678901234e-14m);\r
 685             Assert(1.2345678901234e-14 == (double)d);\r
 686 \r
 687             d = new Decimal(1.2342278901234e-25);\r
 688             Assert((decimal)d == 1.234e-25m);\r
 689 \r
 690             // test exceptions\r
 691             try\r
 692             {\r
 693                 d = new Decimal(8e28);\r
 694                 Fail();\r
 695             } \r
 696             catch (OverflowException) \r
 697             {\r
 698             }\r
 699 \r
 700             try\r
 701             {\r
 702                 d = new Decimal(8e48);\r
 703                 Fail();\r
 704             } \r
 705             catch (OverflowException) \r
 706             {\r
 707             }\r
 708 \r
 709             try\r
 710             {\r
 711                 d = new Decimal(Double.NaN);\r
 712                 Fail();\r
 713             } \r
 714             catch (OverflowException) \r
 715             {\r
 716             }\r
 717 \r
 718             try\r
 719             {\r
 720                 d = new Decimal(Double.PositiveInfinity);\r
 721                 Fail();\r
 722             } \r
 723             catch (OverflowException) \r
 724             {\r
 725             }\r
 726         }\r
 727 \r
 728         public void TestConstructDoubleRound()\r
 729         {\r
 730             decimal d;\r
 731             int TestNum = 1;\r
 732             \r
 733             try {\r
 734                         d = new Decimal(1765.231234567857);\r
 735                         AssertEquals("A01", 1765.23123456786m, d);\r
 736 \r
 737                         TestNum++;\r
 738                         d = new Decimal(1765.2312345678554);\r
 739                         AssertEquals("A02, failed banker's rule rounding test 1", 1765.23123456786m, d);\r
 740                         AssertEquals("A03", 1765.23123456786, (double)d);\r
 741 \r
 742                         TestNum++;\r
 743                         d = new Decimal(1765.231234567853);\r
 744                         Assert(d == 1765.23123456785m);\r
 745 \r
 746                         TestNum++;\r
 747                         d = new Decimal(1765.231234567847);\r
 748                         Assert(d == 1765.23123456785m);\r
 749 \r
 750                         TestNum++;\r
 751                         d = new Decimal(1765.231234567843);\r
 752                         Assert(d == 1765.23123456784m);\r
 753 \r
 754                         TestNum++;\r
 755                         d = new Decimal(1.765231234567857e-9);\r
 756                         Assert(d == 1.76523123456786e-9m);\r
 757 \r
 758                         TestNum++;\r
 759                         d = new Decimal(1.7652312345678554e-9);\r
 760                         Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);\r
 761 \r
 762                         TestNum++;\r
 763                         d = new Decimal(1.765231234567853e-9);\r
 764                         Assert(d == 1.76523123456785e-9m);\r
 765 \r
 766                         TestNum++;\r
 767                         d = new Decimal(1.765231234567857e+24);\r
 768                         Assert(d == 1.76523123456786e+24m);\r
 769 \r
 770                         TestNum++;\r
 771                         d = new Decimal(1.7652312345678554e+24);\r
 772                         Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);\r
 773 \r
 774                         TestNum++;\r
 775                         d = new Decimal(1.765231234567853e+24);\r
 776                         Assert(d == 1.76523123456785e+24m);\r
 777 \r
 778                         TestNum++;\r
 779                         d = new Decimal(1765.2312345678454);\r
 780                         Assert(d == 1765.23123456785m);\r
 781                 }\r
 782                 catch (Exception e) {\r
 783                         Fail("At TestNum = " + TestNum + " unexpected exception. e = " + e);\r
 784                 }\r
 785         }\r
 786 \r
 787         public void TestNegate()\r
 788         {\r
 789             decimal d;\r
 790 \r
 791             d = new Decimal(12345678);\r
 792             Assert((decimal)Decimal.Negate(d) == -12345678m);\r
 793         }\r
 794 \r
 795         public void TestPartConstruct()\r
 796         {\r
 797             decimal d;\r
 798             \r
 799             d = new Decimal(parts0);\r
 800             Assert(d == 0);\r
 801 \r
 802             d = new Decimal(parts1);\r
 803             Assert(d == 1);\r
 804 \r
 805             d = new Decimal(parts2);\r
 806             Assert(d == 4294967296m);\r
 807 \r
 808             d = new Decimal(parts3);\r
 809             Assert(d == 18446744073709551616m);\r
 810 \r
 811             d = new Decimal(parts4);\r
 812             Assert(d == 0m);\r
 813 \r
 814             d = new Decimal(parts5);\r
 815             Assert(d == 18446744078004518913m);\r
 816             \r
 817             d = new Decimal(partsMaxValue);\r
 818             Assert(d == Decimal.MaxValue);\r
 819             \r
 820             d = new Decimal(partsMinValue);\r
 821             Assert(d == Decimal.MinValue);\r
 822 \r
 823             d = new Decimal(parts6);\r
 824             int[] erg = Decimal.GetBits(d);\r
 825             for (int i = 0; i < 4; i++) \r
 826             {\r
 827                 Assert(erg[i] == parts6[i]); \r
 828             }\r
 829         }\r
 830 \r
 831         public void TestFloorTruncate()\r
 832         {\r
 833             decimal[,] dtab = {\r
 834                 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m}, \r
 835                 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},\r
 836                 {-123456789012345.67890m, -123456789012346m, -123456789012345m},\r
 837                 {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},\r
 838                 {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},\r
 839                 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m}, \r
 840                 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}\r
 841             };\r
 842 \r
 843             decimal d;\r
 844             \r
 845             for (int i = 0; i < dtab.GetLength(0); i++)\r
 846             {\r
 847                 d = Decimal.Floor(dtab[i,0]);\r
 848                 if (d != dtab[i,1]) \r
 849                 {\r
 850                     Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);\r
 851                 }\r
 852                 d = Decimal.Truncate(dtab[i,0]);\r
 853                 if (d != dtab[i,2]) \r
 854                 {\r
 855                     Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);\r
 856                 }\r
 857             }\r
 858         }\r
 859 \r
 860         [Test]\r
 861         public void Truncate () \r
 862         {\r
 863                 decimal dd = 249.9m;\r
 864                 decimal dt = Decimal.Truncate (dd);\r
 865                 AssertEquals ("Original", 249.9m, dd);\r
 866                 AssertEquals ("Truncate", 249m, dt);\r
 867                 AssertEquals ("Cast-Byte", 249, (byte)dd);\r
 868                 AssertEquals ("Cast-Char", 249, (char)dd);\r
 869                 AssertEquals ("Cast-Int16", 249, (short)dd);\r
 870                 AssertEquals ("Cast-UInt16", 249, (ushort)dd);\r
 871                 AssertEquals ("Cast-Int32", 249, (int)dd);\r
 872                 AssertEquals ("Cast-UInt32", 249, (uint)dd);\r
 873                 AssertEquals ("Cast-Int64", 249, (long)dd);\r
 874                 AssertEquals ("Cast-UInt64", 249, (ulong)dd);\r
 875         }\r
 876 \r
 877         public void TestRound()\r
 878         {\r
 879             decimal[,] dtab = { \r
 880                 {1m, 0, 1m}, {1.234567890m, 1, 1.2m}, \r
 881                 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m}, \r
 882                 {1.2355m, 3, 1.236m}, \r
 883                 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m}, \r
 884                 {47893764694.4578563236436621m, 7, 47893764694.4578563m},\r
 885                 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},\r
 886                 {-47893764694.4578m, 5, -47893764694.4578m}\r
 887             };\r
 888 \r
 889             decimal d;\r
 890             \r
 891             for (int i = 0; i < dtab.GetLength(0); i++)\r
 892             {\r
 893                 d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);\r
 894                 if (d != dtab[i,2]) \r
 895                 {\r
 896                     Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);\r
 897                 }\r
 898             }\r
 899         }\r
 900         \r
 901         [Ignore ("Bug 37744 - Bankers rounding not implemented")]\r
 902         // When this bug is fixed, this case can be reinserted into the above test.\r
 903         public void TestRoundFailures()\r
 904         {\r
 905             decimal[,] dtab = { \r
 906                 {1.2345m, 3, 1.234m} \r
 907             };\r
 908 \r
 909             decimal d;\r
 910             \r
 911             for (int i = 0; i < dtab.GetLength(0); i++)\r
 912             {\r
 913                 d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);\r
 914                 if (d != dtab[i,2]) \r
 915                 {\r
 916                     Fail("FailRound: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);\r
 917                 }\r
 918             }\r
 919         }\r
 920 \r
 921         [Test]\r
 922         public void ParseInt64 () \r
 923         {\r
 924                 long max = Int64.MaxValue;\r
 925                 Decimal dmax = Decimal.Parse (max.ToString ());\r
 926                 AssertEquals ("Int64.MaxValue", Int64.MaxValue, Decimal.ToInt64 (dmax));\r
 927 \r
 928                 long min = Int64.MinValue;\r
 929                 Decimal dmin = Decimal.Parse (min.ToString ());\r
 930                 AssertEquals ("Int64.MinValue", Int64.MinValue, Decimal.ToInt64 (dmin));\r
 931 \r
 932                 dmax += 1.1m;\r
 933                 dmax = Decimal.Parse (dmax.ToString ());\r
 934                 AssertEquals ("Int64.MaxValue+1.1", Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m));\r
 935 \r
 936                 dmin -= 1.1m;\r
 937                 dmin = Decimal.Parse (dmin.ToString ());\r
 938                 AssertEquals ("Int64.MinValue-1.1", Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m));\r
 939         }\r
 940 \r
 941         [Test]\r
 942         public void ToByte () \r
 943         {\r
 944                 Decimal d = 254.9m;\r
 945                 AssertEquals ("Decimal.ToByte", 254, Decimal.ToByte (d));\r
 946                 AssertEquals ("Convert.ToByte", 255, Convert.ToByte (d));\r
 947                 AssertEquals ("IConvertible.ToByte", 255, (d as IConvertible).ToByte (null));\r
 948         }\r
 949 \r
 950         [Test]\r
 951         public void ToSByte () \r
 952         {\r
 953                 Decimal d = 126.9m;\r
 954                 AssertEquals ("Decimal.ToSByte", 126, Decimal.ToSByte (d));\r
 955                 AssertEquals ("Convert.ToSByte", 127, Convert.ToSByte (d));\r
 956                 AssertEquals ("IConvertible.ToSByte", 127, (d as IConvertible).ToSByte (null));\r
 957                 d = -d;\r
 958                 AssertEquals ("-Decimal.ToSByte", -126, Decimal.ToSByte (d));\r
 959                 AssertEquals ("-Convert.ToSByte", -127, Convert.ToSByte (d));\r
 960                 AssertEquals ("-IConvertible.ToSByte", -127, (d as IConvertible).ToSByte (null));\r
 961         }\r
 962 \r
 963         [Test]\r
 964         public void ToInt16 () \r
 965         {\r
 966                 Decimal d = 254.9m;\r
 967                 AssertEquals ("Decimal.ToInt16", 254, Decimal.ToInt16 (d));\r
 968                 AssertEquals ("Convert.ToInt16", 255, Convert.ToInt16 (d));\r
 969                 AssertEquals ("IConvertible.ToInt16", 255, (d as IConvertible).ToInt16 (null));\r
 970                 d = -d;\r
 971                 AssertEquals ("-Decimal.ToInt16", -254, Decimal.ToInt16 (d));\r
 972                 AssertEquals ("-Convert.ToInt16", -255, Convert.ToInt16 (d));\r
 973                 AssertEquals ("-IConvertible.ToInt16", -255, (d as IConvertible).ToInt16 (null));\r
 974         }\r
 975 \r
 976         [Test]\r
 977         public void ToUInt16 () \r
 978         {\r
 979                 Decimal d = 254.9m;\r
 980                 AssertEquals ("Decimal.ToUInt16", 254, Decimal.ToUInt16 (d));\r
 981                 AssertEquals ("Convert.ToUInt16", 255, Convert.ToUInt16 (d));\r
 982                 AssertEquals ("IConvertible.ToUInt16", 255, (d as IConvertible).ToUInt16 (null));\r
 983         }\r
 984 \r
 985         [Test]\r
 986         public void ToInt32 () \r
 987         {\r
 988                 Decimal d = 254.9m;\r
 989                 AssertEquals ("Decimal.ToInt32", 254, Decimal.ToInt32 (d));\r
 990                 AssertEquals ("Convert.ToInt32", 255, Convert.ToInt32 (d));\r
 991                 AssertEquals ("IConvertible.ToInt32", 255, (d as IConvertible).ToInt32 (null));\r
 992                 d = -d;\r
 993                 AssertEquals ("-Decimal.ToInt32", -254, Decimal.ToInt32 (d));\r
 994                 AssertEquals ("-Convert.ToInt32", -255, Convert.ToInt32 (d));\r
 995                 AssertEquals ("-IConvertible.ToInt32", -255, (d as IConvertible).ToInt32 (null));\r
 996         }\r
 997 \r
 998         [Test]\r
 999         public void ToUInt32 () \r
1000         {\r
1001                 Decimal d = 254.9m;\r
1002                 AssertEquals ("Decimal.ToUInt32", 254, Decimal.ToUInt32 (d));\r
1003                 AssertEquals ("Convert.ToUInt32", 255, Convert.ToUInt32 (d));\r
1004                 AssertEquals ("IConvertible.ToUInt32", 255, (d as IConvertible).ToUInt32 (null));\r
1005         }\r
1006 \r
1007         [Test]\r
1008         public void ToInt64 () \r
1009         {\r
1010                 Decimal d = 254.9m;\r
1011                 AssertEquals ("Decimal.ToInt64", 254, Decimal.ToInt64 (d));\r
1012                 AssertEquals ("Convert.ToInt64", 255, Convert.ToInt64 (d));\r
1013                 AssertEquals ("IConvertible.ToInt64", 255, (d as IConvertible).ToInt64 (null));\r
1014                 d = -d;\r
1015                 AssertEquals ("-Decimal.ToInt64", -254, Decimal.ToInt64 (d));\r
1016                 AssertEquals ("-Convert.ToInt64", -255, Convert.ToInt64 (d));\r
1017                 AssertEquals ("-IConvertible.ToInt64", -255, (d as IConvertible).ToInt64 (null));\r
1018         }\r
1019 \r
1020         [Test]\r
1021         [ExpectedException (typeof(OverflowException))]\r
1022         public void ToInt64_TooBig () \r
1023         {\r
1024                 Decimal d = (Decimal) Int64.MaxValue;\r
1025                 d += 1.1m;\r
1026                 long value = Decimal.ToInt64 (d);\r
1027         }\r
1028 \r
1029         [Test]\r
1030         [ExpectedException (typeof(OverflowException))]\r
1031         public void ToInt64_TooSmall () \r
1032         {\r
1033                 Decimal d = (Decimal) Int64.MinValue;\r
1034                 d -= 1.1m;\r
1035                 long value = Decimal.ToInt64 (d);\r
1036         }\r
1037 \r
1038         [Test]\r
1039         public void ToUInt64 () \r
1040         {\r
1041                 Decimal d = 254.9m;\r
1042                 AssertEquals ("Decimal.ToUInt64", 254, Decimal.ToUInt64 (d));\r
1043                 AssertEquals ("Convert.ToUInt64", 255, Convert.ToUInt64 (d));\r
1044                 AssertEquals ("IConvertible.ToUInt64", 255, (d as IConvertible).ToUInt64 (null));\r
1045         }\r
1046 \r
1047         [Test]\r
1048         public void ToSingle () \r
1049         {\r
1050                 Decimal d = 254.9m;\r
1051                 AssertEquals ("Decimal.ToSingle", 254.9f, Decimal.ToSingle (d));\r
1052                 AssertEquals ("Convert.ToSingle", 254.9f, Convert.ToSingle (d));\r
1053                 AssertEquals ("IConvertible.ToSingle", 254.9f, (d as IConvertible).ToSingle (null));\r
1054                 d = -d;\r
1055                 AssertEquals ("-Decimal.ToSingle", -254.9f, Decimal.ToSingle (d));\r
1056                 AssertEquals ("-Convert.ToSingle", -254.9f, Convert.ToSingle (d));\r
1057                 AssertEquals ("-IConvertible.ToSingle", -254.9f, (d as IConvertible).ToSingle (null));\r
1058         }\r
1059 \r
1060         [Test]\r
1061         public void ToDouble () \r
1062         {\r
1063                 Decimal d = 254.9m;\r
1064                 AssertEquals ("Decimal.ToDouble", 254.9d, Decimal.ToDouble (d));\r
1065                 AssertEquals ("Convert.ToDouble", 254.9d, Convert.ToDouble (d));\r
1066                 AssertEquals ("IConvertible.ToDouble", 254.9d, (d as IConvertible).ToDouble (null));\r
1067                 d = -d;\r
1068                 AssertEquals ("-Decimal.ToDouble", -254.9d, Decimal.ToDouble (d));\r
1069                 AssertEquals ("-Convert.ToDouble", -254.9d, Convert.ToDouble (d));\r
1070                 AssertEquals ("-IConvertible.ToDouble", -254.9d, (d as IConvertible).ToDouble (null));\r
1071         }\r
1072 \r
1073         [Test]\r
1074         public void ToString_Defaults () \r
1075         {\r
1076                 Decimal d = 254.9m;\r
1077                 // everything defaults to "G"\r
1078                 string def = d.ToString ("G");\r
1079                 AssertEquals ("ToString()", def, d.ToString ());\r
1080                 AssertEquals ("ToString((IFormatProvider)null)", def, d.ToString ((IFormatProvider)null));\r
1081                 AssertEquals ("ToString((string)null)", def, d.ToString ((string)null));\r
1082                 AssertEquals ("ToString(empty)", def, d.ToString (String.Empty));\r
1083                 AssertEquals ("ToString(null,null)", def, d.ToString (null, null));\r
1084                 AssertEquals ("ToString(empty,null)", def, d.ToString (String.Empty, null));\r
1085 \r
1086                 AssertEquals ("ToString()", "254.9", def);\r
1087         }\r
1088 \r
1089         [Test]\r
1090         public void CastTruncRounding ()\r
1091         {\r
1092                 // casting truncs decimal value (not normal nor banker's rounding)\r
1093                 AssertEquals ("254.9==254", 254, (long)(254.9m));\r
1094                 AssertEquals ("-254.9=-254", -254, (long)(-254.9m));\r
1095                 AssertEquals ("255.9==256", 255, (long)(255.9m));\r
1096                 AssertEquals ("-255.9=-256", -255, (long)(-255.9m));\r
1097         }\r
1098 \r
1099         [Test]\r
1100         public void ParseFractions ()\r
1101         {\r
1102                 Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);\r
1103                 Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);\r
1104         }\r
1105 \r
1106         [Test]\r
1107         [ExpectedException (typeof (OverflowException))]\r
1108         public void ParseFractions_TooSmall ()\r
1109         {\r
1110                 Decimal.Parse ("0.0000000000000000000000000000001", CultureInfo.InvariantCulture);\r
1111         }\r
1112     }\r
1113 }\r