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