1 // DecimalTest.cs - NUnit Test Cases for the System.Decimal struct
\r
3 // Author: Martin Weindel (martin.weindel@t-online.de)
\r
5 // (C) Martin Weindel, 2001
\r
8 using NUnit.Framework;
\r
11 using System.Globalization;
\r
12 using System.Runtime.CompilerServices;
\r
13 using System.Threading;
\r
15 namespace MonoTests.System {
\r
16 internal struct ParseTest
\r
18 public ParseTest(String str, bool exceptionFlag)
\r
21 this.exceptionFlag = exceptionFlag;
\r
22 this.style = NumberStyles.Number;
\r
26 public ParseTest(String str, Decimal d)
\r
29 this.exceptionFlag = false;
\r
30 this.style = NumberStyles.Number;
\r
34 public ParseTest(String str, Decimal d, NumberStyles style)
\r
37 this.exceptionFlag = false;
\r
44 public NumberStyles style;
\r
45 public bool exceptionFlag;
\r
48 internal struct ToStringTest
\r
50 public ToStringTest(String format, Decimal d, String str)
\r
52 this.format = format;
\r
57 public String format;
\r
63 /// Tests for System.Decimal
\r
65 public class DecimalTest : TestCase
\r
67 public DecimalTest() {}
\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
82 private CultureInfo old_culture;
\r
84 protected override void SetUp()
\r
86 old_culture = Thread.CurrentThread.CurrentCulture;
\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
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
112 protected override void TearDown()
\r
114 Thread.CurrentThread.CurrentCulture = old_culture;
\r
117 public void TestToString()
\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
140 new ToStringTest("g", -0.000012m, "-1.2e-05"),
\r
142 new ToStringTest("g", -0.000012m, "-0.000012"),
\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
206 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
\r
208 for (int i = 0; i < tab.Length; i++)
\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
215 catch (OverflowException)
\r
217 Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");
\r
219 catch (NUnit.Framework.AssertionException e) {
\r
222 catch (Exception e) {
\r
223 Fail ("Unexpected Exception when i = " + i + ". e = " + e);
\r
228 public void TestCurrencyPattern()
\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
239 for (int i = 0; i < ergCurrencyNegativePattern.Length; i++)
\r
241 nfi2.CurrencyNegativePattern = i;
\r
242 if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i])
\r
244 Fail("CurrencyNegativePattern #" + i + " failed: " +
\r
245 d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);
\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
254 for (int i = 0; i < ergCurrencyPositivePattern.Length; i++)
\r
256 nfi2.CurrencyPositivePattern = i;
\r
257 if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i])
\r
259 Fail("CurrencyPositivePattern #" + i + " failed: " +
\r
260 d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);
\r
265 public void TestNumberNegativePattern()
\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
273 for (int i = 0; i < ergNumberNegativePattern.Length; i++)
\r
275 nfi2.NumberNegativePattern = i;
\r
276 AssertEquals ("NumberNegativePattern #" + i, ergNumberNegativePattern[i], d.ToString("N", nfi2));
\r
280 public void TestPercentPattern()
\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
288 for (int i = 0; i < ergPercentNegativePattern.Length; i++)
\r
290 nfi2.PercentNegativePattern = i;
\r
291 if (d.ToString("P", nfi2) != ergPercentNegativePattern[i])
\r
293 Fail("PercentNegativePattern #" + i + " failed: " +
\r
294 d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);
\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
303 for (int i = 0; i < ergPercentPositivePattern.Length; i++)
\r
305 nfi2.PercentPositivePattern = i;
\r
306 if (d.ToString("P", nfi2) != ergPercentPositivePattern[i])
\r
308 Fail("PercentPositivePattern #" + i + " failed: " +
\r
309 d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);
\r
314 public void TestParse()
\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
333 for (int i = 0; i < tab.Length; i++)
\r
337 d = Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);
\r
338 if (tab[i].exceptionFlag)
\r
340 Fail(tab[i].str + ": missing exception !");
\r
342 else if (d != tab[i].d)
\r
344 Fail(tab[i].str + " != " + d);
\r
347 catch (OverflowException)
\r
349 if (!tab[i].exceptionFlag)
\r
351 Fail(tab[i].str + ": unexpected exception !");
\r
358 d = Decimal.Parse(null);
\r
359 Fail("Expected ArgumentNullException");
\r
361 catch (ArgumentNullException)
\r
368 d = Decimal.Parse("123nx");
\r
369 Fail("Expected FormatException");
\r
371 catch (FormatException)
\r
378 d = Decimal.Parse("79228162514264337593543950336");
\r
379 Fail("Expected OverflowException" + d);
\r
381 catch (OverflowException)
\r
387 public void TestConstants()
\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
397 public void TestConstructInt32()
\r
399 decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};
\r
400 int[] itab = {0, 1, -1, 123456, -1234567};
\r
404 for (int i = 0; i < dtab.GetLength(0); i++)
\r
406 d = new Decimal(itab[i]);
\r
407 if ((decimal)d != dtab[i])
\r
409 Fail("Int32 -> Decimal: " + itab[i] + " != " + d);
\r
416 Fail("Decimal -> Int32: " + d + " != " + itab[i]);
\r
421 d = new Decimal(Int32.MaxValue);
\r
422 Assert((int)d == Int32.MaxValue);
\r
424 d = new Decimal(Int32.MinValue);
\r
425 Assert((int)d == Int32.MinValue);
\r
428 public void TestConstructUInt32()
\r
430 decimal[] dtab = {0m, 1m, 123456m, 123456789m};
\r
431 uint[] itab = {0, 1, 123456, 123456789};
\r
435 for (int i = 0; i < dtab.GetLength(0); i++)
\r
437 d = new Decimal(itab[i]);
\r
438 if ((decimal)d != dtab[i])
\r
440 Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);
\r
447 Fail("Decimal -> UInt32: " + d + " != " + itab[i]);
\r
452 d = new Decimal(UInt32.MaxValue);
\r
453 Assert((uint)d == UInt32.MaxValue);
\r
455 d = new Decimal(UInt32.MinValue);
\r
456 Assert((uint)d == UInt32.MinValue);
\r
459 public void TestConstructInt64()
\r
461 decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};
\r
462 long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};
\r
466 for (int i = 0; i < dtab.GetLength(0); i++)
\r
468 d = new Decimal(itab[i]);
\r
469 if ((decimal)d != dtab[i])
\r
471 Fail("Int64 -> Decimal: " + itab[i] + " != " + d);
\r
478 Fail("Decimal -> Int64: " + d + " != " + itab[i]);
\r
483 d = new Decimal(Int64.MaxValue);
\r
484 Assert((long)d == Int64.MaxValue);
\r
486 d = new Decimal(Int64.MinValue);
\r
487 Assert((long)d == Int64.MinValue);
\r
490 public void TestConstructUInt64()
\r
492 decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};
\r
493 ulong[] itab = {0, 1, 987654321, 123456789876543210L};
\r
497 for (int i = 0; i < dtab.GetLength(0); i++)
\r
499 d = new Decimal(itab[i]);
\r
500 if ((decimal)d != dtab[i])
\r
502 Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);
\r
506 ulong n = (ulong) d;
\r
509 Fail("Decimal -> UInt64: " + d + " != " + itab[i]);
\r
514 d = new Decimal(UInt64.MaxValue);
\r
515 Assert((ulong)d == UInt64.MaxValue);
\r
517 d = new Decimal(UInt64.MinValue);
\r
518 Assert((ulong)d == UInt64.MinValue);
\r
521 public void TestConstructSingle()
\r
525 d = new Decimal(-1.2345678f);
\r
526 AssertEquals("A#01", -1.234568m, (decimal)d);
\r
529 AssertEquals("A#02", 3.0f, (float)d);
\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
535 d = new Decimal(1.0f);
\r
536 AssertEquals("A#05", 1m, (decimal)d);
\r
537 AssertEquals("A#06", 1.0f, (float)d);
\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
543 d = new Decimal(1.2345673f);
\r
544 AssertEquals("A#09", 1.234567m, (decimal)d);
\r
546 d = new Decimal(1.2345673e7f);
\r
547 AssertEquals("A#10", 12345670m, (decimal)d);
\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
556 d = new Decimal(Single.MaxValue);
\r
559 catch (OverflowException)
\r
565 d = new Decimal(Single.NaN);
\r
568 catch (OverflowException)
\r
574 d = new Decimal(Single.PositiveInfinity);
\r
577 catch (OverflowException)
\r
582 public void TestConstructSingleRounding()
\r
586 d = new Decimal(1765.2356f);
\r
587 Assert(d == 1765.236m);
\r
589 d = new Decimal(1765.23554f);
\r
590 Assert("failed banker's rule rounding test 1", d == 1765.236m);
\r
592 d = new Decimal(1765.2354f);
\r
593 Assert(d == 1765.235m);
\r
595 d = new Decimal(1765.2346f);
\r
596 Assert(d == 1765.235m);
\r
598 d = new Decimal(1765.23454f);
\r
599 Assert("failed banker's rule rounding test 2", d == 1765.234m);
\r
601 d = new Decimal(1765.2344f);
\r
602 Assert(d == 1765.234m);
\r
604 d = new Decimal(0.00017652356f);
\r
605 Assert(d == 0.0001765236m);
\r
607 d = new Decimal(0.000176523554f);
\r
608 Assert("failed banker's rule rounding test 3", d == 0.0001765236m);
\r
610 d = new Decimal(0.00017652354f);
\r
611 Assert(d == 0.0001765235m);
\r
613 d = new Decimal(0.00017652346f);
\r
614 Assert(d == 0.0001765235m);
\r
616 d = new Decimal(0.000176523454f);
\r
617 Assert("failed banker's rule rounding test 4", d == 0.0001765234m);
\r
619 d = new Decimal(0.00017652344f);
\r
620 Assert(d == 0.0001765234m);
\r
622 d = new Decimal(3.7652356e10f);
\r
623 Assert(d == 37652360000m);
\r
625 d = new Decimal(3.7652356e20f);
\r
626 Assert(d == 376523600000000000000m);
\r
628 d = new Decimal(3.76523554e20f);
\r
629 Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);
\r
631 d = new Decimal(3.7652352e20f);
\r
632 Assert(d == 376523500000000000000m);
\r
634 d = new Decimal(3.7652348e20f);
\r
635 Assert(d == 376523500000000000000m);
\r
637 d = new Decimal(3.76523454e20f);
\r
638 Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);
\r
640 d = new Decimal(3.7652342e20f);
\r
641 Assert(d == 376523400000000000000m);
\r
644 public void TestConstructDouble()
\r
648 d = new Decimal(0.0);
\r
649 Assert((decimal)d == 0m);
\r
651 d = new Decimal(1.0);
\r
652 Assert((decimal)d == 1m);
\r
653 Assert(1.0 == (double)d);
\r
655 d = new Decimal(-1.2345678901234);
\r
656 Assert((decimal)d == -1.2345678901234m);
\r
657 Assert(-1.2345678901234 == (double)d);
\r
659 d = new Decimal(1.2345678901234);
\r
660 Assert((decimal)d == 1.2345678901234m);
\r
662 d = new Decimal(1.2345678901234e8);
\r
663 Assert((decimal)d == 123456789.01234m);
\r
664 Assert(1.2345678901234e8 == (double)d);
\r
666 d = new Decimal(1.2345678901234e16);
\r
667 Assert((decimal)d == 12345678901234000m);
\r
668 Assert(1.2345678901234e16 == (double)d);
\r
670 d = new Decimal(1.2345678901234e24);
\r
671 Assert((decimal)d == 1234567890123400000000000m);
\r
672 Assert(1.2345678901234e24 == (double)d);
\r
674 d = new Decimal(1.2345678901234e28);
\r
675 Assert((decimal)d == 1.2345678901234e28m);
\r
676 Assert(1.2345678901234e28 == (double)d);
\r
678 d = new Decimal(7.2345678901234e28);
\r
679 Assert((decimal)d == 7.2345678901234e28m);
\r
680 Assert(new Decimal((double)d) == d);
\r
682 d = new Decimal(1.2345678901234e-8);
\r
683 Assert((decimal)d == 1.2345678901234e-8m);
\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
689 d = new Decimal(1.2342278901234e-25);
\r
690 Assert((decimal)d == 1.234e-25m);
\r
695 d = new Decimal(8e28);
\r
698 catch (OverflowException)
\r
704 d = new Decimal(8e48);
\r
707 catch (OverflowException)
\r
713 d = new Decimal(Double.NaN);
\r
716 catch (OverflowException)
\r
722 d = new Decimal(Double.PositiveInfinity);
\r
725 catch (OverflowException)
\r
730 public void TestConstructDoubleRound()
\r
736 d = new Decimal(1765.231234567857);
\r
737 AssertEquals("A01", 1765.23123456786m, d);
\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
745 d = new Decimal(1765.231234567853);
\r
746 Assert(d == 1765.23123456785m);
\r
749 d = new Decimal(1765.231234567847);
\r
750 Assert(d == 1765.23123456785m);
\r
753 d = new Decimal(1765.231234567843);
\r
754 Assert(d == 1765.23123456784m);
\r
757 d = new Decimal(1.765231234567857e-9);
\r
758 Assert(d == 1.76523123456786e-9m);
\r
761 d = new Decimal(1.7652312345678554e-9);
\r
762 Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);
\r
765 d = new Decimal(1.765231234567853e-9);
\r
766 Assert(d == 1.76523123456785e-9m);
\r
769 d = new Decimal(1.765231234567857e+24);
\r
770 Assert(d == 1.76523123456786e+24m);
\r
773 d = new Decimal(1.7652312345678554e+24);
\r
774 Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);
\r
777 d = new Decimal(1.765231234567853e+24);
\r
778 Assert(d == 1.76523123456785e+24m);
\r
781 d = new Decimal(1765.2312345678454);
\r
782 Assert(d == 1765.23123456785m);
\r
784 catch (Exception e) {
\r
785 Fail("At TestNum = " + TestNum + " unexpected exception. e = " + e);
\r
789 public void TestNegate()
\r
793 d = new Decimal(12345678);
\r
794 Assert((decimal)Decimal.Negate(d) == -12345678m);
\r
797 public void TestPartConstruct()
\r
801 d = new Decimal(parts0);
\r
804 d = new Decimal(parts1);
\r
807 d = new Decimal(parts2);
\r
808 Assert(d == 4294967296m);
\r
810 d = new Decimal(parts3);
\r
811 Assert(d == 18446744073709551616m);
\r
813 d = new Decimal(parts4);
\r
816 d = new Decimal(parts5);
\r
817 Assert(d == 18446744078004518913m);
\r
819 d = new Decimal(partsMaxValue);
\r
820 Assert(d == Decimal.MaxValue);
\r
822 d = new Decimal(partsMinValue);
\r
823 Assert(d == Decimal.MinValue);
\r
825 d = new Decimal(parts6);
\r
826 int[] erg = Decimal.GetBits(d);
\r
827 for (int i = 0; i < 4; i++)
\r
829 Assert(erg[i] == parts6[i]);
\r
833 public void TestFloorTruncate()
\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
847 for (int i = 0; i < dtab.GetLength(0); i++)
\r
849 d = Decimal.Floor(dtab[i,0]);
\r
850 if (d != dtab[i,1])
\r
852 Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);
\r
854 d = Decimal.Truncate(dtab[i,0]);
\r
855 if (d != dtab[i,2])
\r
857 Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);
\r
862 public void TestRound()
\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.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
876 for (int i = 0; i < dtab.GetLength(0); i++)
\r
878 d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);
\r
879 if (d != dtab[i,2])
\r
881 Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
\r
886 [Ignore ("Bug 37744 - Bankers rounding not implemented")]
\r
887 // When this bug is fixed, this case can be reinserted into the above test.
\r
888 public void TestRoundFailures()
\r
890 decimal[,] dtab = {
\r
891 {1.2345m, 3, 1.234m}
\r
896 for (int i = 0; i < dtab.GetLength(0); i++)
\r
898 d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);
\r
899 if (d != dtab[i,2])
\r
901 Fail("FailRound: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
\r
907 public void ParseInt64 ()
\r
909 long max = Int64.MaxValue;
\r
910 Decimal dmax = Decimal.Parse (max.ToString ());
\r
911 AssertEquals ("Int64.MaxValue", Int64.MaxValue, Decimal.ToInt64 (dmax));
\r
913 long min = Int64.MinValue;
\r
914 Decimal dmin = Decimal.Parse (min.ToString ());
\r
915 AssertEquals ("Int64.MinValue", Int64.MinValue, Decimal.ToInt64 (dmin));
\r
918 dmax = Decimal.Parse (dmax.ToString ());
\r
919 AssertEquals ("Int64.MaxValue+1.1", Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m));
\r
922 dmin = Decimal.Parse (dmin.ToString ());
\r
923 AssertEquals ("Int64.MinValue-1.1", Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m));
\r
927 public void ToByte ()
\r
929 Decimal d = 254.9m;
\r
930 AssertEquals ("Decimal.ToByte", 254, Decimal.ToByte (d));
\r
931 AssertEquals ("Convert.ToByte", 255, Convert.ToByte (d));
\r
932 AssertEquals ("IConvertible.ToByte", 255, (d as IConvertible).ToByte (null));
\r
936 public void ToSByte ()
\r
938 Decimal d = 126.9m;
\r
939 AssertEquals ("Decimal.ToSByte", 126, Decimal.ToSByte (d));
\r
940 AssertEquals ("Convert.ToSByte", 127, Convert.ToSByte (d));
\r
941 AssertEquals ("IConvertible.ToSByte", 127, (d as IConvertible).ToSByte (null));
\r
943 AssertEquals ("-Decimal.ToSByte", -126, Decimal.ToSByte (d));
\r
944 AssertEquals ("-Convert.ToSByte", -127, Convert.ToSByte (d));
\r
945 AssertEquals ("-IConvertible.ToSByte", -127, (d as IConvertible).ToSByte (null));
\r
949 public void ToInt16 ()
\r
951 Decimal d = 254.9m;
\r
952 AssertEquals ("Decimal.ToInt16", 254, Decimal.ToInt16 (d));
\r
953 AssertEquals ("Convert.ToInt16", 255, Convert.ToInt16 (d));
\r
954 AssertEquals ("IConvertible.ToInt16", 255, (d as IConvertible).ToInt16 (null));
\r
956 AssertEquals ("-Decimal.ToInt16", -254, Decimal.ToInt16 (d));
\r
957 AssertEquals ("-Convert.ToInt16", -255, Convert.ToInt16 (d));
\r
958 AssertEquals ("-IConvertible.ToInt16", -255, (d as IConvertible).ToInt16 (null));
\r
962 public void ToUInt16 ()
\r
964 Decimal d = 254.9m;
\r
965 AssertEquals ("Decimal.ToUInt16", 254, Decimal.ToUInt16 (d));
\r
966 AssertEquals ("Convert.ToUInt16", 255, Convert.ToUInt16 (d));
\r
967 AssertEquals ("IConvertible.ToUInt16", 255, (d as IConvertible).ToUInt16 (null));
\r
971 public void ToInt32 ()
\r
973 Decimal d = 254.9m;
\r
974 AssertEquals ("Decimal.ToInt32", 254, Decimal.ToInt32 (d));
\r
975 AssertEquals ("Convert.ToInt32", 255, Convert.ToInt32 (d));
\r
976 AssertEquals ("IConvertible.ToInt32", 255, (d as IConvertible).ToInt32 (null));
\r
978 AssertEquals ("-Decimal.ToInt32", -254, Decimal.ToInt32 (d));
\r
979 AssertEquals ("-Convert.ToInt32", -255, Convert.ToInt32 (d));
\r
980 AssertEquals ("-IConvertible.ToInt32", -255, (d as IConvertible).ToInt32 (null));
\r
984 public void ToUInt32 ()
\r
986 Decimal d = 254.9m;
\r
987 AssertEquals ("Decimal.ToUInt32", 254, Decimal.ToUInt32 (d));
\r
988 AssertEquals ("Convert.ToUInt32", 255, Convert.ToUInt32 (d));
\r
989 AssertEquals ("IConvertible.ToUInt32", 255, (d as IConvertible).ToUInt32 (null));
\r
993 public void ToInt64 ()
\r
995 Decimal d = 254.9m;
\r
996 AssertEquals ("Decimal.ToInt64", 254, Decimal.ToInt64 (d));
\r
997 AssertEquals ("Convert.ToInt64", 255, Convert.ToInt64 (d));
\r
998 AssertEquals ("IConvertible.ToInt64", 255, (d as IConvertible).ToInt64 (null));
\r
1000 AssertEquals ("-Decimal.ToInt64", -254, Decimal.ToInt64 (d));
\r
1001 AssertEquals ("-Convert.ToInt64", -255, Convert.ToInt64 (d));
\r
1002 AssertEquals ("-IConvertible.ToInt64", -255, (d as IConvertible).ToInt64 (null));
\r
1006 [ExpectedException (typeof(OverflowException))]
\r
1007 public void ToInt64_TooBig ()
\r
1009 Decimal d = (Decimal) Int64.MaxValue;
\r
1011 long value = Decimal.ToInt64 (d);
\r
1015 [ExpectedException (typeof(OverflowException))]
\r
1016 public void ToInt64_TooSmall ()
\r
1018 Decimal d = (Decimal) Int64.MinValue;
\r
1020 long value = Decimal.ToInt64 (d);
\r
1024 public void ToUInt64 ()
\r
1026 Decimal d = 254.9m;
\r
1027 AssertEquals ("Decimal.ToUInt64", 254, Decimal.ToUInt64 (d));
\r
1028 AssertEquals ("Convert.ToUInt64", 255, Convert.ToUInt64 (d));
\r
1029 AssertEquals ("IConvertible.ToUInt64", 255, (d as IConvertible).ToUInt64 (null));
\r
1033 public void ToSingle ()
\r
1035 Decimal d = 254.9m;
\r
1036 AssertEquals ("Decimal.ToSingle", 254.9f, Decimal.ToSingle (d));
\r
1037 AssertEquals ("Convert.ToSingle", 254.9f, Convert.ToSingle (d));
\r
1038 AssertEquals ("IConvertible.ToSingle", 254.9f, (d as IConvertible).ToSingle (null));
\r
1040 AssertEquals ("-Decimal.ToSingle", -254.9f, Decimal.ToSingle (d));
\r
1041 AssertEquals ("-Convert.ToSingle", -254.9f, Convert.ToSingle (d));
\r
1042 AssertEquals ("-IConvertible.ToSingle", -254.9f, (d as IConvertible).ToSingle (null));
\r
1046 public void ToDouble ()
\r
1048 Decimal d = 254.9m;
\r
1049 AssertEquals ("Decimal.ToDouble", 254.9d, Decimal.ToDouble (d));
\r
1050 AssertEquals ("Convert.ToDouble", 254.9d, Convert.ToDouble (d));
\r
1051 AssertEquals ("IConvertible.ToDouble", 254.9d, (d as IConvertible).ToDouble (null));
\r
1053 AssertEquals ("-Decimal.ToDouble", -254.9d, Decimal.ToDouble (d));
\r
1054 AssertEquals ("-Convert.ToDouble", -254.9d, Convert.ToDouble (d));
\r
1055 AssertEquals ("-IConvertible.ToDouble", -254.9d, (d as IConvertible).ToDouble (null));
\r