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 using S = System; // for implementation switching only\r
  11 \r
  12 using System.Globalization;\r
  13 using System.Runtime.CompilerServices;\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, S.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, S.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 S.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, S.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 S.Decimal d;\r
  59         public String str;\r
  60     }\r
  61 \r
  62     /// <summary>\r
  63     /// Tests for System.Decimal\r
  64     /// </summary>\r
  65     public class DecimalTest : TestCase\r
  66     {\r
  67         public DecimalTest(string name) : base(name) {}\r
  68 \r
  69         public static ITest Suite \r
  70         {\r
  71             get { return new TestSuite(typeof(DecimalTest)); }\r
  72         }\r
  73 \r
  74         private const int negativeBitValue = unchecked ((int)0x80000000);\r
  75         private const int negativeScale4Value = unchecked ((int)0x80040000);\r
  76         private int [] parts0 = {0,0,0,0}; //Positive Zero.\r
  77         private int [] parts1 = {1,0,0,0};\r
  78         private int [] parts2 = {0,1,0,0};\r
  79         private int [] parts3 = {0,0,1,0};\r
  80         private int [] parts4 = {0,0,0,negativeBitValue}; // Negative zero.\r
  81         private int [] parts5 = {1,1,1,0};\r
  82         private int [] partsMaxValue = {-1,-1,-1,0};\r
  83         private int [] partsMinValue = {-1,-1,-1,negativeBitValue};\r
  84         private int [] parts6 = {1234, 5678, 8888, negativeScale4Value};\r
  85         private NumberFormatInfo NfiUser;\r
  86 \r
  87         protected override void SetUp() \r
  88         {\r
  89             NfiUser = new NumberFormatInfo();\r
  90             NfiUser.CurrencyDecimalDigits = 3;\r
  91             NfiUser.CurrencyDecimalSeparator = ",";\r
  92             NfiUser.CurrencyGroupSeparator = "_";\r
  93             NfiUser.CurrencyGroupSizes = new int[] { 2,1,0 };\r
  94             NfiUser.CurrencyNegativePattern = 10;\r
  95             NfiUser.CurrencyPositivePattern = 3;\r
  96             NfiUser.CurrencySymbol = "XYZ";\r
  97             NfiUser.NumberDecimalSeparator = "##";\r
  98             NfiUser.NumberDecimalDigits = 4;\r
  99             NfiUser.NumberGroupSeparator = "__";\r
 100             NfiUser.NumberGroupSizes = new int[] { 2,1 };\r
 101             NfiUser.PercentDecimalDigits = 1;\r
 102             NfiUser.PercentDecimalSeparator = ";";\r
 103             NfiUser.PercentGroupSeparator = "~";\r
 104             NfiUser.PercentGroupSizes = new int[] {1};\r
 105             NfiUser.PercentNegativePattern = 2;\r
 106             NfiUser.PercentPositivePattern = 2;\r
 107             NfiUser.PercentSymbol = "%%%";\r
 108         }\r
 109 \r
 110         public void TestToString()\r
 111         {\r
 112             ToStringTest[] tab = {\r
 113                 new ToStringTest("F", 12.345678m, "12.35"),\r
 114                 new ToStringTest("F3", 12.345678m, "12.346"),\r
 115                 new ToStringTest("F0", 12.345678m, "12"),\r
 116                 new ToStringTest("F7", 12.345678m, "12.3456780"),\r
 117                 new ToStringTest("g", 12.345678m, "12.345678"),\r
 118                 new ToStringTest("E", 12.345678m, "1.234568E+001"),\r
 119                 new ToStringTest("E3", 12.345678m, "1.235E+001"),\r
 120                 new ToStringTest("E0", 12.345678m, "1E+001"),\r
 121                 new ToStringTest("e8", 12.345678m, "1.23456780e+001"),\r
 122                 new ToStringTest("F", 0.0012m, "0.00"),\r
 123                 new ToStringTest("F3", 0.0012m, "0.001"),\r
 124                 new ToStringTest("F0", 0.0012m, "0"),\r
 125                 new ToStringTest("F6", 0.0012m, "0.001200"),\r
 126                 new ToStringTest("e", 0.0012m, "1.200000e-003"),\r
 127                 new ToStringTest("E3", 0.0012m, "1.200E-003"),\r
 128                 new ToStringTest("E0", 0.0012m, "1E-003"),\r
 129                 new ToStringTest("E6", 0.0012m, "1.200000E-003"),\r
 130                 new ToStringTest("F4", -0.001234m, "-0.0012"),\r
 131                 new ToStringTest("E3", -0.001234m, "-1.234E-003"),\r
 132                 new ToStringTest("g", -0.000012m, "-1.2e-05"),\r
 133                 new ToStringTest("g", -0.00012m, "-0.00012"),\r
 134                 new ToStringTest("g4", -0.00012m, "-0.00012"),\r
 135                 new ToStringTest("g7", -0.00012m, "-0.00012"),\r
 136                 new ToStringTest("g", -0.0001234m, "-0.0001234"),\r
 137                 new ToStringTest("g", -0.0012m, "-0.0012"),\r
 138                 new ToStringTest("g", -0.001234m, "-0.001234"),\r
 139                 new ToStringTest("g", -0.012m, "-0.012"),\r
 140                 new ToStringTest("g4", -0.012m, "-0.012"),\r
 141                 new ToStringTest("g", -0.12m, "-0.12"),\r
 142                 new ToStringTest("g", -1.2m, "-1.2"),\r
 143                 new ToStringTest("g4", -120m, "-120"),\r
 144                 new ToStringTest("g", -12m, "-12"),\r
 145                 new ToStringTest("g", -120m, "-120"),\r
 146                 new ToStringTest("g", -1200m, "-1200"),\r
 147                 new ToStringTest("g4", -1200m, "-1200"),\r
 148                 new ToStringTest("g", -1234m, "-1234"),\r
 149                 new ToStringTest("g", -12000m, "-12000"),\r
 150                 new ToStringTest("g4", -12000m, "-1.2e+04"),\r
 151                 new ToStringTest("g5", -12000m, "-12000"),\r
 152                 new ToStringTest("g", -12345m, "-12345"),\r
 153                 new ToStringTest("g", -120000m, "-120000"),\r
 154                 new ToStringTest("g4", -120000m, "-1.2e+05"),\r
 155                 new ToStringTest("g5", -120000m, "-1.2e+05"),\r
 156                 new ToStringTest("g6", -120000m, "-120000"),\r
 157                 new ToStringTest("g", -123456.1m, "-123456.1"),\r
 158                 new ToStringTest("g5", -123456.1m, "-1.2346e+05"),\r
 159                 new ToStringTest("g6", -123456.1m, "-123456"),\r
 160                 new ToStringTest("g", -1200000m, "-1200000"),\r
 161                 new ToStringTest("g", -123456.1m, "-123456.1"),\r
 162                 new ToStringTest("g", -123456.1m, "-123456.1"),\r
 163                 new ToStringTest("g", -1234567.1m, "-1234567.1"),\r
 164                 new ToStringTest("g", -12000000m, "-12000000"),\r
 165                 new ToStringTest("g", -12345678.1m, "-12345678.1"),\r
 166                 new ToStringTest("g", -12000000000000000000m, "-12000000000000000000"),\r
 167                 new ToStringTest("F", -123, "-123.00"),\r
 168                 new ToStringTest("F3", -123, "-123.000"),\r
 169                 new ToStringTest("F0", -123, "-123"),\r
 170                 new ToStringTest("E3", -123, "-1.230E+002"),\r
 171                 new ToStringTest("E0", -123, "-1E+002"),\r
 172                 new ToStringTest("E", -123, "-1.230000E+002"),\r
 173                 new ToStringTest("F3", S.Decimal.MinValue, "-79228162514264337593543950335.000"),\r
 174                 new ToStringTest("F", S.Decimal.MinValue, "-79228162514264337593543950335.00"),\r
 175                 new ToStringTest("F0", S.Decimal.MinValue, "-79228162514264337593543950335"),\r
 176                 new ToStringTest("E", S.Decimal.MinValue, "-7.922816E+028"),\r
 177                 new ToStringTest("E3", S.Decimal.MinValue, "-7.923E+028"),\r
 178                 new ToStringTest("E28", S.Decimal.MinValue, "-7.9228162514264337593543950335E+028"),\r
 179                 new ToStringTest("E30", S.Decimal.MinValue, "-7.922816251426433759354395033500E+028"),\r
 180                 new ToStringTest("E0", S.Decimal.MinValue, "-8E+028"),\r
 181                 new ToStringTest("N3", S.Decimal.MinValue, "(79,228,162,514,264,337,593,543,950,335.000)"),\r
 182                 new ToStringTest("N0", S.Decimal.MinValue, "(79,228,162,514,264,337,593,543,950,335)"),\r
 183                 new ToStringTest("N", S.Decimal.MinValue, "(79,228,162,514,264,337,593,543,950,335.00)"),\r
 184                 new ToStringTest("C", 123456.7890m, "$123,456.79"),\r
 185                 new ToStringTest("C", -123456.7890m, "($123,456.79)"),\r
 186                 new ToStringTest("C3", 1123456.7890m, "$1,123,456.789"),\r
 187                 new ToStringTest("P", 123456.7891m, "12,345,678.91 %"),\r
 188                 new ToStringTest("P", -123456.7892m, "-12,345,678.92 %"),\r
 189                 new ToStringTest("P3", 1234.56789m, "123,456.789 %"),\r
 190             };\r
 191 \r
 192             NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;\r
 193 \r
 194             for (int i = 0; i < tab.Length; i++) \r
 195             {\r
 196                 try\r
 197                 {\r
 198                     string s = tab[i].d.ToString(tab[i].format, nfi);\r
 199                     if (s != tab[i].str)\r
 200                     {\r
 201                         Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "') != " + tab[i].str);\r
 202                     }\r
 203                 } \r
 204                 catch (OverflowException)\r
 205                 {\r
 206                     Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");\r
 207                 }\r
 208             }      \r
 209         }\r
 210 \r
 211         public void TestCurrencyPattern()\r
 212         {\r
 213             NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
 214             S.Decimal d = -1234567.8976m;\r
 215             string[] ergCurrencyNegativePattern = new String[16] {\r
 216                 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",\r
 217                 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",\r
 218                 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",\r
 219                 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",\r
 220             };\r
 221 \r
 222             for (int i = 0; i < ergCurrencyNegativePattern.Length; i++) \r
 223             {\r
 224                 nfi2.CurrencyNegativePattern = i;\r
 225                 if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i]) \r
 226                 {\r
 227                     Fail("CurrencyNegativePattern #" + i + " failed: " +\r
 228                         d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);\r
 229                 }\r
 230             }\r
 231 \r
 232             d = 1234567.8976m;\r
 233             string[] ergCurrencyPositivePattern = new String[4] {\r
 234                 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",\r
 235             };\r
 236 \r
 237             for (int i = 0; i < ergCurrencyPositivePattern.Length; i++) \r
 238             {\r
 239                 nfi2.CurrencyPositivePattern = i;\r
 240                 if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i]) \r
 241                 {\r
 242                     Fail("CurrencyPositivePattern #" + i + " failed: " +\r
 243                         d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);\r
 244                 }\r
 245             }\r
 246         }\r
 247 \r
 248         public void TestNumberNegativePattern()\r
 249         {\r
 250             NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
 251             S.Decimal d = -1234.89765m;\r
 252             string[] ergNumberNegativePattern = new String[5] {\r
 253                 "(1__2__34##8976)", "-1__2__34##8976", "- 1__2__34##8976", "1__2__34##8976-", "1__2__34##8976 -",\r
 254             };\r
 255 \r
 256             for (int i = 0; i < ergNumberNegativePattern.Length; i++) \r
 257             {\r
 258                 nfi2.NumberNegativePattern = i;\r
 259                 if (d.ToString("N", nfi2) != ergNumberNegativePattern[i]) \r
 260                 {\r
 261                     Fail("NumberNegativePattern #" + i + " failed: " +\r
 262                         d.ToString("N", nfi2) + " != " + ergNumberNegativePattern[i]);\r
 263                 }\r
 264             }\r
 265         }\r
 266         \r
 267         public void TestPercentPattern()\r
 268         {\r
 269             NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
 270             S.Decimal d = -1234.8976m;\r
 271             string[] ergPercentNegativePattern = new String[3] {\r
 272                 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"\r
 273             };\r
 274 \r
 275             for (int i = 0; i < ergPercentNegativePattern.Length; i++) \r
 276             {\r
 277                 nfi2.PercentNegativePattern = i;\r
 278                 if (d.ToString("P", nfi2) != ergPercentNegativePattern[i]) \r
 279                 {\r
 280                     Fail("PercentNegativePattern #" + i + " failed: " +\r
 281                         d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);\r
 282                 }\r
 283             }\r
 284 \r
 285             d = 1234.8976m;\r
 286             string[] ergPercentPositivePattern = new String[3] {\r
 287                 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"\r
 288             };\r
 289 \r
 290             for (int i = 0; i < ergPercentPositivePattern.Length; i++) \r
 291             {\r
 292                 nfi2.PercentPositivePattern = i;\r
 293                 if (d.ToString("P", nfi2) != ergPercentPositivePattern[i]) \r
 294                 {\r
 295                     Fail("PercentPositivePattern #" + i + " failed: " +\r
 296                         d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);\r
 297                 }\r
 298             }\r
 299         }\r
 300 \r
 301         public void TestParse()\r
 302         {\r
 303             ParseTest[] tab = {\r
 304                 new ParseTest("1.2345", 1.2345m),\r
 305                 new ParseTest("-9876543210", -9876543210m),\r
 306                 new ParseTest("$ (  79,228,162,514,264,337,593,543,950,335.000 ) ", S.Decimal.MinValue, NumberStyles.Currency),\r
 307                 new ParseTest("1.234567890e-10", (S.Decimal)1.234567890e-10, NumberStyles.Float),\r
 308                 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),\r
 309                 new ParseTest("  47896396.457983645462346E10  ", 478963964579836454.62346m, NumberStyles.Float),\r
 310                 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),\r
 311                 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),\r
 312                 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),\r
 313                 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),\r
 314                 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),\r
 315                 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)\r
 316             };\r
 317 \r
 318             S.Decimal d;\r
 319             for (int i = 0; i < tab.Length; i++) \r
 320             {\r
 321                 try\r
 322                 {\r
 323                     d = S.Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);\r
 324                     if (tab[i].exceptionFlag)\r
 325                     {\r
 326                         Fail(tab[i].str + ": missing exception !");\r
 327                     }\r
 328                     else if (d != tab[i].d) \r
 329                     {\r
 330                         Fail(tab[i].str + " != " + d);\r
 331                     }\r
 332                 } \r
 333                 catch (OverflowException)\r
 334                 {\r
 335                     if (!tab[i].exceptionFlag)\r
 336                     {\r
 337                         Fail(tab[i].str + ": unexpected exception !");\r
 338                     }\r
 339                 }\r
 340             }  \r
 341     \r
 342             try \r
 343             {\r
 344                 d = S.Decimal.Parse(null);\r
 345                 Fail("Expected ArgumentNullException");\r
 346             }\r
 347             catch (ArgumentNullException)\r
 348             {\r
 349                 //ok\r
 350             }\r
 351 \r
 352             try \r
 353             {\r
 354                 d = S.Decimal.Parse("123nx");\r
 355                 Fail("Expected FormatException");\r
 356             }\r
 357             catch (FormatException)\r
 358             {\r
 359                 //ok\r
 360             }\r
 361 \r
 362             try \r
 363             {\r
 364                 d = S.Decimal.Parse("79228162514264337593543950336");\r
 365                 Fail("Expected OverflowException" + d);\r
 366             }\r
 367             catch (OverflowException)\r
 368             {\r
 369                 //ok\r
 370             }\r
 371         }\r
 372 \r
 373         public void TestConstants()\r
 374         {\r
 375             Assert(0m == (decimal)S.Decimal.Zero);\r
 376             Assert(1m == (decimal)S.Decimal.One);\r
 377             Assert(-1m == (decimal)S.Decimal.MinusOne);\r
 378             Assert(0m == (decimal)S.Decimal.Zero);\r
 379             Assert(79228162514264337593543950335m == (decimal)S.Decimal.MaxValue);\r
 380             Assert(-79228162514264337593543950335m == (decimal)S.Decimal.MinValue);       \r
 381         }\r
 382 \r
 383         public void TestConstructInt32()\r
 384         {\r
 385             decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};\r
 386             int[] itab = {0, 1, -1, 123456, -1234567};\r
 387 \r
 388             S.Decimal d;\r
 389             \r
 390             for (int i = 0; i < dtab.GetLength(0); i++)\r
 391             {\r
 392                 d = new S.Decimal(itab[i]);\r
 393                 if ((decimal)d != dtab[i]) \r
 394                 {\r
 395                     Fail("Int32 -> Decimal: " + itab[i] + " != " + d);\r
 396                 }\r
 397                 else \r
 398                 {\r
 399                     int n = (int) d;\r
 400                     if (n != itab[i]) \r
 401                     {\r
 402                         Fail("Decimal -> Int32: " + d + " != " + itab[i]);\r
 403                     }\r
 404                 }\r
 405             }\r
 406 \r
 407             d = new S.Decimal(Int32.MaxValue);\r
 408             Assert((int)d == Int32.MaxValue);\r
 409 \r
 410             d = new S.Decimal(Int32.MinValue);\r
 411             Assert((int)d == Int32.MinValue);\r
 412         }\r
 413 \r
 414         public void TestConstructUInt32()\r
 415         {\r
 416             decimal[] dtab = {0m, 1m, 123456m, 123456789m};\r
 417             uint[] itab = {0, 1, 123456, 123456789};\r
 418 \r
 419             S.Decimal d;\r
 420             \r
 421             for (int i = 0; i < dtab.GetLength(0); i++)\r
 422             {\r
 423                 d = new S.Decimal(itab[i]);\r
 424                 if ((decimal)d != dtab[i]) \r
 425                 {\r
 426                     Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);\r
 427                 }\r
 428                 else \r
 429                 {\r
 430                     uint n = (uint) d;\r
 431                     if (n != itab[i]) \r
 432                     {\r
 433                         Fail("Decimal -> UInt32: " + d + " != " + itab[i]);\r
 434                     }\r
 435                 }\r
 436             }\r
 437 \r
 438             d = new S.Decimal(UInt32.MaxValue);\r
 439             Assert((uint)d == UInt32.MaxValue);\r
 440 \r
 441             d = new Decimal(UInt32.MinValue);\r
 442             Assert((uint)d == UInt32.MinValue);\r
 443         }\r
 444 \r
 445         public void TestConstructInt64()\r
 446         {\r
 447             decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};\r
 448             long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};\r
 449 \r
 450             S.Decimal d;\r
 451             \r
 452             for (int i = 0; i < dtab.GetLength(0); i++)\r
 453             {\r
 454                 d = new S.Decimal(itab[i]);\r
 455                 if ((decimal)d != dtab[i]) \r
 456                 {\r
 457                     Fail("Int64 -> Decimal: " + itab[i] + " != " + d);\r
 458                 }\r
 459                 else \r
 460                 {\r
 461                     long n = (long) d;\r
 462                     if (n != itab[i]) \r
 463                     {\r
 464                         Fail("Decimal -> Int64: " + d + " != " + itab[i]);\r
 465                     }\r
 466                 }\r
 467             }\r
 468 \r
 469             d = new S.Decimal(Int64.MaxValue);\r
 470             Assert((long)d == Int64.MaxValue);\r
 471 \r
 472             d = new Decimal(Int64.MinValue);\r
 473             Assert((long)d == Int64.MinValue);\r
 474         }\r
 475 \r
 476         public void TestConstructUInt64()\r
 477         {\r
 478             decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};\r
 479             ulong[] itab = {0, 1, 987654321, 123456789876543210L};\r
 480 \r
 481             S.Decimal d;\r
 482             \r
 483             for (int i = 0; i < dtab.GetLength(0); i++)\r
 484             {\r
 485                 d = new S.Decimal(itab[i]);\r
 486                 if ((decimal)d != dtab[i]) \r
 487                 {\r
 488                     Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);\r
 489                 }\r
 490                 else \r
 491                 {\r
 492                     ulong n = (ulong) d;\r
 493                     if (n != itab[i]) \r
 494                     {\r
 495                         Fail("Decimal -> UInt64: " + d + " != " + itab[i]);\r
 496                     }\r
 497                 }\r
 498             }\r
 499 \r
 500             d = new S.Decimal(UInt64.MaxValue);\r
 501             Assert((ulong)d == UInt64.MaxValue);\r
 502 \r
 503             d = new Decimal(UInt64.MinValue);\r
 504             Assert((ulong)d == UInt64.MinValue);\r
 505         }\r
 506 \r
 507         public void TestConstructSingle()\r
 508         {\r
 509             S.Decimal d;\r
 510 \r
 511             d = new S.Decimal(-1.2345678f);\r
 512             Assert((decimal)d == -1.234568m);\r
 513 \r
 514             d=3;\r
 515             Assert(3.0f == (float)d);\r
 516 \r
 517             d = new S.Decimal(0.0f);\r
 518             Assert((decimal)d == 0m);\r
 519             Assert(0.0f == (float)d);\r
 520 \r
 521             d = new S.Decimal(1.0f);\r
 522             Assert((decimal)d == 1m);\r
 523             Assert(1.0f == (float)d);\r
 524 \r
 525             d = new S.Decimal(-1.2345678f);\r
 526             Assert((decimal)d == -1.234568m);\r
 527             Assert(-1.234568f == (float)d);\r
 528 \r
 529             d = new S.Decimal(1.2345673f);\r
 530             Assert((decimal)d == 1.234567m);\r
 531 \r
 532             d = new S.Decimal(1.2345673e7f);\r
 533             Assert((decimal)d == 12345670m);\r
 534 \r
 535             d = new S.Decimal(1.2345673e-17f);\r
 536             Assert((decimal)d == 0.00000000000000001234567m);\r
 537             Assert(1.234567e-17f == (float)d);\r
 538 \r
 539             // test exceptions\r
 540             try\r
 541             {\r
 542                 d = new S.Decimal(Single.MaxValue);\r
 543                 Fail();\r
 544             } \r
 545             catch (OverflowException) \r
 546             {\r
 547             }\r
 548 \r
 549             try\r
 550             {\r
 551                 d = new S.Decimal(Single.NaN);\r
 552                 Fail();\r
 553             } \r
 554             catch (OverflowException) \r
 555             {\r
 556             }\r
 557 \r
 558             try\r
 559             {\r
 560                 d = new S.Decimal(Single.PositiveInfinity);\r
 561                 Fail();\r
 562             } \r
 563             catch (OverflowException) \r
 564             {\r
 565             }\r
 566         }\r
 567 \r
 568         public void TestConstructSingleRounding()\r
 569         {\r
 570             decimal d;\r
 571 \r
 572             d = new S.Decimal(1765.2356f);\r
 573             Assert(d == 1765.236m);\r
 574 \r
 575             d = new S.Decimal(1765.23554f);\r
 576             Assert("failed banker's rule rounding test 1", d == 1765.236m);\r
 577 \r
 578             d = new S.Decimal(1765.2354f);\r
 579             Assert(d == 1765.235m);\r
 580 \r
 581             d = new S.Decimal(1765.2346f);\r
 582             Assert(d == 1765.235m);\r
 583 \r
 584             d = new S.Decimal(1765.23454f);\r
 585             Assert("failed banker's rule rounding test 2", d == 1765.234m);\r
 586 \r
 587             d = new S.Decimal(1765.2344f);\r
 588             Assert(d == 1765.234m);\r
 589 \r
 590             d = new S.Decimal(0.00017652356f);\r
 591             Assert(d == 0.0001765236m);\r
 592 \r
 593             d = new S.Decimal(0.000176523554f);\r
 594             Assert("failed banker's rule rounding test 3", d == 0.0001765236m);\r
 595 \r
 596             d = new S.Decimal(0.00017652354f);\r
 597             Assert(d == 0.0001765235m);\r
 598 \r
 599             d = new S.Decimal(0.00017652346f);\r
 600             Assert(d == 0.0001765235m);\r
 601 \r
 602             d = new S.Decimal(0.000176523454f);\r
 603             Assert("failed banker's rule rounding test 4", d == 0.0001765234m);\r
 604 \r
 605             d = new S.Decimal(0.00017652344f);\r
 606             Assert(d == 0.0001765234m);\r
 607 \r
 608             d = new S.Decimal(3.7652356e10f);\r
 609             Assert(d == 37652360000m);\r
 610 \r
 611             d = new S.Decimal(3.7652356e20f);\r
 612             Assert(d == 376523600000000000000m);\r
 613 \r
 614             d = new S.Decimal(3.76523554e20f);\r
 615             Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);\r
 616 \r
 617             d = new S.Decimal(3.7652352e20f);\r
 618             Assert(d == 376523500000000000000m);\r
 619 \r
 620             d = new S.Decimal(3.7652348e20f);\r
 621             Assert(d == 376523500000000000000m);\r
 622 \r
 623             d = new S.Decimal(3.76523454e20f);\r
 624             Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);\r
 625 \r
 626             d = new S.Decimal(3.7652342e20f);\r
 627             Assert(d == 376523400000000000000m);\r
 628         }\r
 629 \r
 630         public void TestConstructDouble()\r
 631         {\r
 632             S.Decimal d;\r
 633 \r
 634             d = new S.Decimal(0.0);\r
 635             Assert((decimal)d == 0m);\r
 636 \r
 637             d = new S.Decimal(1.0);\r
 638             Assert((decimal)d == 1m);\r
 639             Assert(1.0 == (double)d);\r
 640 \r
 641             d = new S.Decimal(-1.2345678901234);\r
 642             Assert((decimal)d == -1.2345678901234m);\r
 643             Assert(-1.2345678901234 == (double)d);\r
 644 \r
 645             d = new S.Decimal(1.2345678901234);\r
 646             Assert((decimal)d == 1.2345678901234m);\r
 647 \r
 648             d = new S.Decimal(1.2345678901234e8);\r
 649             Assert((decimal)d == 123456789.01234m);\r
 650             Assert(1.2345678901234e8 == (double)d);\r
 651 \r
 652             d = new S.Decimal(1.2345678901234e16);\r
 653             Assert((decimal)d == 12345678901234000m);\r
 654             Assert(1.2345678901234e16 == (double)d);\r
 655 \r
 656             d = new S.Decimal(1.2345678901234e24);\r
 657             Assert((decimal)d == 1234567890123400000000000m);\r
 658             Assert(1.2345678901234e24 == (double)d);\r
 659 \r
 660             d = new S.Decimal(1.2345678901234e28);\r
 661             Assert((decimal)d == 1.2345678901234e28m);\r
 662             Assert(1.2345678901234e28 == (double)d);\r
 663 \r
 664             d = new S.Decimal(7.2345678901234e28);\r
 665             Assert((decimal)d == 7.2345678901234e28m);\r
 666             Assert(new S.Decimal((double)d) == d);\r
 667 \r
 668             d = new S.Decimal(1.2345678901234e-8);\r
 669             Assert((decimal)d == 1.2345678901234e-8m);\r
 670 \r
 671             d = new S.Decimal(1.2345678901234e-14);\r
 672             Assert((decimal)d == 1.2345678901234e-14m);\r
 673             Assert(1.2345678901234e-14 == (double)d);\r
 674 \r
 675             d = new S.Decimal(1.2342278901234e-25);\r
 676             Assert((decimal)d == 1.234e-25m);\r
 677 \r
 678             // test exceptions\r
 679             try\r
 680             {\r
 681                 d = new S.Decimal(8e28);\r
 682                 Fail();\r
 683             } \r
 684             catch (OverflowException) \r
 685             {\r
 686             }\r
 687 \r
 688             try\r
 689             {\r
 690                 d = new S.Decimal(8e48);\r
 691                 Fail();\r
 692             } \r
 693             catch (OverflowException) \r
 694             {\r
 695             }\r
 696 \r
 697             try\r
 698             {\r
 699                 d = new S.Decimal(Double.NaN);\r
 700                 Fail();\r
 701             } \r
 702             catch (OverflowException) \r
 703             {\r
 704             }\r
 705 \r
 706             try\r
 707             {\r
 708                 d = new S.Decimal(Double.PositiveInfinity);\r
 709                 Fail();\r
 710             } \r
 711             catch (OverflowException) \r
 712             {\r
 713             }\r
 714         }\r
 715 \r
 716         public void TestConstructDoubleRound()\r
 717         {\r
 718             decimal d;\r
 719             \r
 720             d = new S.Decimal(1765.231234567857);\r
 721             Assert(d == 1765.23123456786m);\r
 722 \r
 723             d = new S.Decimal(1765.2312345678554);\r
 724             Assert("failed banker's rule rounding test 1", d == 1765.23123456786m);\r
 725             Assert(1765.23123456786 == (double)d);\r
 726 \r
 727             d = new S.Decimal(1765.231234567853);\r
 728             Assert(d == 1765.23123456785m);\r
 729 \r
 730             d = new S.Decimal(1765.231234567847);\r
 731             Assert(d == 1765.23123456785m);\r
 732 \r
 733             d = new S.Decimal(1765.231234567843);\r
 734             Assert(d == 1765.23123456784m);\r
 735 \r
 736             d = new S.Decimal(1.765231234567857e-9);\r
 737             Assert(d == 1.76523123456786e-9m);\r
 738 \r
 739             d = new S.Decimal(1.7652312345678554e-9);\r
 740             Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);\r
 741 \r
 742             d = new S.Decimal(1.765231234567853e-9);\r
 743             Assert(d == 1.76523123456785e-9m);\r
 744 \r
 745             d = new S.Decimal(1.765231234567857e+24);\r
 746             Assert(d == 1.76523123456786e+24m);\r
 747 \r
 748             d = new S.Decimal(1.7652312345678554e+24);\r
 749             Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);\r
 750 \r
 751             d = new S.Decimal(1.765231234567853e+24);\r
 752             Assert(d == 1.76523123456785e+24m);\r
 753 \r
 754             d = new S.Decimal(1765.2312345678454);\r
 755             Assert(d == 1765.23123456785m);\r
 756         }\r
 757 \r
 758         public void TestNegate()\r
 759         {\r
 760             decimal d;\r
 761 \r
 762             d = new S.Decimal(12345678);\r
 763             Assert((decimal)S.Decimal.Negate(d) == -12345678m);\r
 764         }\r
 765 \r
 766         public void TestPartConstruct()\r
 767         {\r
 768             decimal d;\r
 769             \r
 770             d = new Decimal(parts0);\r
 771             Assert(d == 0);\r
 772 \r
 773             d = new Decimal(parts1);\r
 774             Assert(d == 1);\r
 775 \r
 776             d = new Decimal(parts2);\r
 777             Assert(d == 4294967296m);\r
 778 \r
 779             d = new Decimal(parts3);\r
 780             Assert(d == 18446744073709551616m);\r
 781 \r
 782             d = new Decimal(parts4);\r
 783             Assert(d == 0m);\r
 784 \r
 785             d = new Decimal(parts5);\r
 786             Assert(d == 18446744078004518913m);\r
 787             \r
 788             d = new Decimal(partsMaxValue);\r
 789             Assert(d == Decimal.MaxValue);\r
 790             \r
 791             d = new Decimal(partsMinValue);\r
 792             Assert(d == Decimal.MinValue);\r
 793 \r
 794             d = new Decimal(parts6);\r
 795             int[] erg = Decimal.GetBits(d);\r
 796             for (int i = 0; i < 4; i++) \r
 797             {\r
 798                 Assert(erg[i] == parts6[i]); \r
 799             }\r
 800         }\r
 801 \r
 802         public void TestFloorTruncate()\r
 803         {\r
 804             decimal[,] dtab = {\r
 805                 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m}, \r
 806                 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},\r
 807                 {-123456789012345.67890m, -123456789012346m, -123456789012345m},\r
 808                 {S.Decimal.MaxValue, S.Decimal.MaxValue, S.Decimal.MaxValue},\r
 809                 {S.Decimal.MinValue, S.Decimal.MinValue, S.Decimal.MinValue},\r
 810                 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m}, \r
 811                 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}\r
 812             };\r
 813 \r
 814             decimal d;\r
 815             \r
 816             for (int i = 0; i < dtab.GetLength(0); i++)\r
 817             {\r
 818                 d = S.Decimal.Floor(dtab[i,0]);\r
 819                 if (d != dtab[i,1]) \r
 820                 {\r
 821                     Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);\r
 822                 }\r
 823                 d = S.Decimal.Truncate(dtab[i,0]);\r
 824                 if (d != dtab[i,2]) \r
 825                 {\r
 826                     Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);\r
 827                 }\r
 828             }\r
 829         }\r
 830 \r
 831         public void TestRound()\r
 832         {\r
 833             decimal[,] dtab = { \r
 834                 {1m, 0, 1m}, {1.234567890m, 1, 1.2m}, \r
 835                 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m}, \r
 836                 {1.2345m, 3, 1.234m}, {1.2355m, 3, 1.236m}, \r
 837                 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m}, \r
 838                 {47893764694.4578563236436621m, 7, 47893764694.4578563m},\r
 839                 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},\r
 840                 {-47893764694.4578m, 5, -47893764694.4578m}\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 = S.Decimal.Round(dtab[i,0], (int)dtab[i,1]);\r
 848                 if (d != dtab[i,2]) \r
 849                 {\r
 850                     Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);\r
 851                 }\r
 852             }\r
 853         }\r
 854     }\r
 855 \r
 856 }