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
10 using S = System; // for implementation switching only
\r
12 using System.Globalization;
\r
13 using System.Runtime.CompilerServices;
\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, S.Decimal d)
\r
29 this.exceptionFlag = false;
\r
30 this.style = NumberStyles.Number;
\r
34 public ParseTest(String str, S.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, S.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() : base ("MonoTests.System.DecimalTest testcase") {}
\r
68 public DecimalTest(string name) : base(name) {}
\r
70 public static ITest Suite
\r
72 get { return new TestSuite(typeof(DecimalTest)); }
\r
75 private const int negativeBitValue = unchecked ((int)0x80000000);
\r
76 private const int negativeScale4Value = unchecked ((int)0x80040000);
\r
77 private int [] parts0 = {0,0,0,0}; //Positive Zero.
\r
78 private int [] parts1 = {1,0,0,0};
\r
79 private int [] parts2 = {0,1,0,0};
\r
80 private int [] parts3 = {0,0,1,0};
\r
81 private int [] parts4 = {0,0,0,negativeBitValue}; // Negative zero.
\r
82 private int [] parts5 = {1,1,1,0};
\r
83 private int [] partsMaxValue = {-1,-1,-1,0};
\r
84 private int [] partsMinValue = {-1,-1,-1,negativeBitValue};
\r
85 private int [] parts6 = {1234, 5678, 8888, negativeScale4Value};
\r
86 private NumberFormatInfo NfiUser;
\r
88 protected override void SetUp()
\r
90 NfiUser = new NumberFormatInfo();
\r
91 NfiUser.CurrencyDecimalDigits = 3;
\r
92 NfiUser.CurrencyDecimalSeparator = ",";
\r
93 NfiUser.CurrencyGroupSeparator = "_";
\r
94 NfiUser.CurrencyGroupSizes = new int[] { 2,1,0 };
\r
95 NfiUser.CurrencyNegativePattern = 10;
\r
96 NfiUser.CurrencyPositivePattern = 3;
\r
97 NfiUser.CurrencySymbol = "XYZ";
\r
98 NfiUser.NumberDecimalSeparator = "##";
\r
99 NfiUser.NumberDecimalDigits = 4;
\r
100 NfiUser.NumberGroupSeparator = "__";
\r
101 NfiUser.NumberGroupSizes = new int[] { 2,1 };
\r
102 NfiUser.PercentDecimalDigits = 1;
\r
103 NfiUser.PercentDecimalSeparator = ";";
\r
104 NfiUser.PercentGroupSeparator = "~";
\r
105 NfiUser.PercentGroupSizes = new int[] {1};
\r
106 NfiUser.PercentNegativePattern = 2;
\r
107 NfiUser.PercentPositivePattern = 2;
\r
108 NfiUser.PercentSymbol = "%%%";
\r
111 public void TestToString()
\r
113 ToStringTest[] tab = {
\r
114 new ToStringTest("F", 12.345678m, "12.35"),
\r
115 new ToStringTest("F3", 12.345678m, "12.346"),
\r
116 new ToStringTest("F0", 12.345678m, "12"),
\r
117 new ToStringTest("F7", 12.345678m, "12.3456780"),
\r
118 new ToStringTest("g", 12.345678m, "12.345678"),
\r
119 new ToStringTest("E", 12.345678m, "1.234568E+001"),
\r
120 new ToStringTest("E3", 12.345678m, "1.235E+001"),
\r
121 new ToStringTest("E0", 12.345678m, "1E+001"),
\r
122 new ToStringTest("e8", 12.345678m, "1.23456780e+001"),
\r
123 new ToStringTest("F", 0.0012m, "0.00"),
\r
124 new ToStringTest("F3", 0.0012m, "0.001"),
\r
125 new ToStringTest("F0", 0.0012m, "0"),
\r
126 new ToStringTest("F6", 0.0012m, "0.001200"),
\r
127 new ToStringTest("e", 0.0012m, "1.200000e-003"),
\r
128 new ToStringTest("E3", 0.0012m, "1.200E-003"),
\r
129 new ToStringTest("E0", 0.0012m, "1E-003"),
\r
130 new ToStringTest("E6", 0.0012m, "1.200000E-003"),
\r
131 new ToStringTest("F4", -0.001234m, "-0.0012"),
\r
132 new ToStringTest("E3", -0.001234m, "-1.234E-003"),
\r
133 new ToStringTest("g", -0.000012m, "-1.2e-05"),
\r
134 new ToStringTest("g", -0.00012m, "-0.00012"),
\r
135 new ToStringTest("g4", -0.00012m, "-0.00012"),
\r
136 new ToStringTest("g7", -0.00012m, "-0.00012"),
\r
137 new ToStringTest("g", -0.0001234m, "-0.0001234"),
\r
138 new ToStringTest("g", -0.0012m, "-0.0012"),
\r
139 new ToStringTest("g", -0.001234m, "-0.001234"),
\r
140 new ToStringTest("g", -0.012m, "-0.012"),
\r
141 new ToStringTest("g4", -0.012m, "-0.012"),
\r
142 new ToStringTest("g", -0.12m, "-0.12"),
\r
143 new ToStringTest("g", -1.2m, "-1.2"),
\r
144 new ToStringTest("g4", -120m, "-120"),
\r
145 new ToStringTest("g", -12m, "-12"),
\r
146 new ToStringTest("g", -120m, "-120"),
\r
147 new ToStringTest("g", -1200m, "-1200"),
\r
148 new ToStringTest("g4", -1200m, "-1200"),
\r
149 new ToStringTest("g", -1234m, "-1234"),
\r
150 new ToStringTest("g", -12000m, "-12000"),
\r
151 new ToStringTest("g4", -12000m, "-1.2e+04"),
\r
152 new ToStringTest("g5", -12000m, "-12000"),
\r
153 new ToStringTest("g", -12345m, "-12345"),
\r
154 new ToStringTest("g", -120000m, "-120000"),
\r
155 new ToStringTest("g4", -120000m, "-1.2e+05"),
\r
156 new ToStringTest("g5", -120000m, "-1.2e+05"),
\r
157 new ToStringTest("g6", -120000m, "-120000"),
\r
158 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
159 new ToStringTest("g5", -123456.1m, "-1.2346e+05"),
\r
160 new ToStringTest("g6", -123456.1m, "-123456"),
\r
161 new ToStringTest("g", -1200000m, "-1200000"),
\r
162 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
163 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
164 new ToStringTest("g", -1234567.1m, "-1234567.1"),
\r
165 new ToStringTest("g", -12000000m, "-12000000"),
\r
166 new ToStringTest("g", -12345678.1m, "-12345678.1"),
\r
167 new ToStringTest("g", -12000000000000000000m, "-12000000000000000000"),
\r
168 new ToStringTest("F", -123, "-123.00"),
\r
169 new ToStringTest("F3", -123, "-123.000"),
\r
170 new ToStringTest("F0", -123, "-123"),
\r
171 new ToStringTest("E3", -123, "-1.230E+002"),
\r
172 new ToStringTest("E0", -123, "-1E+002"),
\r
173 new ToStringTest("E", -123, "-1.230000E+002"),
\r
174 new ToStringTest("F3", S.Decimal.MinValue, "-79228162514264337593543950335.000"),
\r
175 new ToStringTest("F", S.Decimal.MinValue, "-79228162514264337593543950335.00"),
\r
176 new ToStringTest("F0", S.Decimal.MinValue, "-79228162514264337593543950335"),
\r
177 new ToStringTest("E", S.Decimal.MinValue, "-7.922816E+028"),
\r
178 new ToStringTest("E3", S.Decimal.MinValue, "-7.923E+028"),
\r
179 new ToStringTest("E28", S.Decimal.MinValue, "-7.9228162514264337593543950335E+028"),
\r
180 new ToStringTest("E30", S.Decimal.MinValue, "-7.922816251426433759354395033500E+028"),
\r
181 new ToStringTest("E0", S.Decimal.MinValue, "-8E+028"),
\r
182 new ToStringTest("N3", S.Decimal.MinValue, "(79,228,162,514,264,337,593,543,950,335.000)"),
\r
183 new ToStringTest("N0", S.Decimal.MinValue, "(79,228,162,514,264,337,593,543,950,335)"),
\r
184 new ToStringTest("N", S.Decimal.MinValue, "(79,228,162,514,264,337,593,543,950,335.00)"),
\r
185 new ToStringTest("C", 123456.7890m, "$123,456.79"),
\r
186 new ToStringTest("C", -123456.7890m, "($123,456.79)"),
\r
187 new ToStringTest("C3", 1123456.7890m, "$1,123,456.789"),
\r
188 new ToStringTest("P", 123456.7891m, "12,345,678.91 %"),
\r
189 new ToStringTest("P", -123456.7892m, "-12,345,678.92 %"),
\r
190 new ToStringTest("P3", 1234.56789m, "123,456.789 %"),
\r
193 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
\r
195 for (int i = 0; i < tab.Length; i++)
\r
199 string s = tab[i].d.ToString(tab[i].format, nfi);
\r
200 int expectedLength = tab[i].str.Length;
\r
201 AssertEquals("A01 tab[" + i + "].format = '" + tab[i].format + "')", tab[i].str, s.Substring(0,expectedLength));
\r
203 catch (OverflowException)
\r
205 Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");
\r
210 public void TestCurrencyPattern()
\r
212 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
213 S.Decimal d = -1234567.8976m;
\r
214 string[] ergCurrencyNegativePattern = new String[16] {
\r
215 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
\r
216 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
\r
217 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
\r
218 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
\r
221 for (int i = 0; i < ergCurrencyNegativePattern.Length; i++)
\r
223 nfi2.CurrencyNegativePattern = i;
\r
224 if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i])
\r
226 Fail("CurrencyNegativePattern #" + i + " failed: " +
\r
227 d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);
\r
232 string[] ergCurrencyPositivePattern = new String[4] {
\r
233 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
\r
236 for (int i = 0; i < ergCurrencyPositivePattern.Length; i++)
\r
238 nfi2.CurrencyPositivePattern = i;
\r
239 if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i])
\r
241 Fail("CurrencyPositivePattern #" + i + " failed: " +
\r
242 d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);
\r
247 public void TestNumberNegativePattern()
\r
249 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
250 S.Decimal d = -1234.89765m;
\r
251 string[] ergNumberNegativePattern = new String[5] {
\r
252 "(1__2__34##8976)", "-1__2__34##8976", "- 1__2__34##8976", "1__2__34##8976-", "1__2__34##8976 -",
\r
255 for (int i = 0; i < ergNumberNegativePattern.Length; i++)
\r
257 nfi2.NumberNegativePattern = i;
\r
258 if (d.ToString("N", nfi2) != ergNumberNegativePattern[i])
\r
260 Fail("NumberNegativePattern #" + i + " failed: " +
\r
261 d.ToString("N", nfi2) + " != " + ergNumberNegativePattern[i]);
\r
266 public void TestPercentPattern()
\r
268 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
269 S.Decimal d = -1234.8976m;
\r
270 string[] ergPercentNegativePattern = new String[3] {
\r
271 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
\r
274 for (int i = 0; i < ergPercentNegativePattern.Length; i++)
\r
276 nfi2.PercentNegativePattern = i;
\r
277 if (d.ToString("P", nfi2) != ergPercentNegativePattern[i])
\r
279 Fail("PercentNegativePattern #" + i + " failed: " +
\r
280 d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);
\r
285 string[] ergPercentPositivePattern = new String[3] {
\r
286 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
\r
289 for (int i = 0; i < ergPercentPositivePattern.Length; i++)
\r
291 nfi2.PercentPositivePattern = i;
\r
292 if (d.ToString("P", nfi2) != ergPercentPositivePattern[i])
\r
294 Fail("PercentPositivePattern #" + i + " failed: " +
\r
295 d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);
\r
300 public void TestParse()
\r
302 ParseTest[] tab = {
\r
303 new ParseTest("1.2345", 1.2345m),
\r
304 new ParseTest("-9876543210", -9876543210m),
\r
305 new ParseTest("$ ( 79,228,162,514,264,337,593,543,950,335.000 ) ", S.Decimal.MinValue, NumberStyles.Currency),
\r
306 new ParseTest("1.234567890e-10", (S.Decimal)1.234567890e-10, NumberStyles.Float),
\r
307 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
\r
308 new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),
\r
309 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
\r
310 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
\r
311 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
\r
312 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
\r
313 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
\r
314 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
\r
318 for (int i = 0; i < tab.Length; i++)
\r
322 d = S.Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);
\r
323 if (tab[i].exceptionFlag)
\r
325 Fail(tab[i].str + ": missing exception !");
\r
327 else if (d != tab[i].d)
\r
329 Fail(tab[i].str + " != " + d);
\r
332 catch (OverflowException)
\r
334 if (!tab[i].exceptionFlag)
\r
336 Fail(tab[i].str + ": unexpected exception !");
\r
343 d = S.Decimal.Parse(null);
\r
344 Fail("Expected ArgumentNullException");
\r
346 catch (ArgumentNullException)
\r
353 d = S.Decimal.Parse("123nx");
\r
354 Fail("Expected FormatException");
\r
356 catch (FormatException)
\r
363 d = S.Decimal.Parse("79228162514264337593543950336");
\r
364 Fail("Expected OverflowException" + d);
\r
366 catch (OverflowException)
\r
372 public void TestConstants()
\r
374 Assert(0m == (decimal)S.Decimal.Zero);
\r
375 Assert(1m == (decimal)S.Decimal.One);
\r
376 Assert(-1m == (decimal)S.Decimal.MinusOne);
\r
377 Assert(0m == (decimal)S.Decimal.Zero);
\r
378 Assert(79228162514264337593543950335m == (decimal)S.Decimal.MaxValue);
\r
379 Assert(-79228162514264337593543950335m == (decimal)S.Decimal.MinValue);
\r
382 public void TestConstructInt32()
\r
384 decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};
\r
385 int[] itab = {0, 1, -1, 123456, -1234567};
\r
389 for (int i = 0; i < dtab.GetLength(0); i++)
\r
391 d = new S.Decimal(itab[i]);
\r
392 if ((decimal)d != dtab[i])
\r
394 Fail("Int32 -> Decimal: " + itab[i] + " != " + d);
\r
401 Fail("Decimal -> Int32: " + d + " != " + itab[i]);
\r
406 d = new S.Decimal(Int32.MaxValue);
\r
407 Assert((int)d == Int32.MaxValue);
\r
409 d = new S.Decimal(Int32.MinValue);
\r
410 Assert((int)d == Int32.MinValue);
\r
413 public void TestConstructUInt32()
\r
415 decimal[] dtab = {0m, 1m, 123456m, 123456789m};
\r
416 uint[] itab = {0, 1, 123456, 123456789};
\r
420 for (int i = 0; i < dtab.GetLength(0); i++)
\r
422 d = new S.Decimal(itab[i]);
\r
423 if ((decimal)d != dtab[i])
\r
425 Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);
\r
432 Fail("Decimal -> UInt32: " + d + " != " + itab[i]);
\r
437 d = new S.Decimal(UInt32.MaxValue);
\r
438 Assert((uint)d == UInt32.MaxValue);
\r
440 d = new Decimal(UInt32.MinValue);
\r
441 Assert((uint)d == UInt32.MinValue);
\r
444 public void TestConstructInt64()
\r
446 decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};
\r
447 long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};
\r
451 for (int i = 0; i < dtab.GetLength(0); i++)
\r
453 d = new S.Decimal(itab[i]);
\r
454 if ((decimal)d != dtab[i])
\r
456 Fail("Int64 -> Decimal: " + itab[i] + " != " + d);
\r
463 Fail("Decimal -> Int64: " + d + " != " + itab[i]);
\r
468 d = new S.Decimal(Int64.MaxValue);
\r
469 Assert((long)d == Int64.MaxValue);
\r
471 d = new Decimal(Int64.MinValue);
\r
472 Assert((long)d == Int64.MinValue);
\r
475 public void TestConstructUInt64()
\r
477 decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};
\r
478 ulong[] itab = {0, 1, 987654321, 123456789876543210L};
\r
482 for (int i = 0; i < dtab.GetLength(0); i++)
\r
484 d = new S.Decimal(itab[i]);
\r
485 if ((decimal)d != dtab[i])
\r
487 Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);
\r
491 ulong n = (ulong) d;
\r
494 Fail("Decimal -> UInt64: " + d + " != " + itab[i]);
\r
499 d = new S.Decimal(UInt64.MaxValue);
\r
500 Assert((ulong)d == UInt64.MaxValue);
\r
502 d = new Decimal(UInt64.MinValue);
\r
503 Assert((ulong)d == UInt64.MinValue);
\r
506 public void TestConstructSingle()
\r
510 d = new S.Decimal(-1.2345678f);
\r
511 Assert((decimal)d == -1.234568m);
\r
514 Assert(3.0f == (float)d);
\r
516 d = new S.Decimal(0.0f);
\r
517 Assert((decimal)d == 0m);
\r
518 Assert(0.0f == (float)d);
\r
520 d = new S.Decimal(1.0f);
\r
521 Assert((decimal)d == 1m);
\r
522 Assert(1.0f == (float)d);
\r
524 d = new S.Decimal(-1.2345678f);
\r
525 Assert((decimal)d == -1.234568m);
\r
526 Assert(-1.234568f == (float)d);
\r
528 d = new S.Decimal(1.2345673f);
\r
529 Assert((decimal)d == 1.234567m);
\r
531 d = new S.Decimal(1.2345673e7f);
\r
532 Assert((decimal)d == 12345670m);
\r
534 d = new S.Decimal(1.2345673e-17f);
\r
535 Assert((decimal)d == 0.00000000000000001234567m);
\r
536 Assert(1.234567e-17f == (float)d);
\r
541 d = new S.Decimal(Single.MaxValue);
\r
544 catch (OverflowException)
\r
550 d = new S.Decimal(Single.NaN);
\r
553 catch (OverflowException)
\r
559 d = new S.Decimal(Single.PositiveInfinity);
\r
562 catch (OverflowException)
\r
567 public void TestConstructSingleRounding()
\r
571 d = new S.Decimal(1765.2356f);
\r
572 Assert(d == 1765.236m);
\r
574 d = new S.Decimal(1765.23554f);
\r
575 Assert("failed banker's rule rounding test 1", d == 1765.236m);
\r
577 d = new S.Decimal(1765.2354f);
\r
578 Assert(d == 1765.235m);
\r
580 d = new S.Decimal(1765.2346f);
\r
581 Assert(d == 1765.235m);
\r
583 d = new S.Decimal(1765.23454f);
\r
584 Assert("failed banker's rule rounding test 2", d == 1765.234m);
\r
586 d = new S.Decimal(1765.2344f);
\r
587 Assert(d == 1765.234m);
\r
589 d = new S.Decimal(0.00017652356f);
\r
590 Assert(d == 0.0001765236m);
\r
592 d = new S.Decimal(0.000176523554f);
\r
593 Assert("failed banker's rule rounding test 3", d == 0.0001765236m);
\r
595 d = new S.Decimal(0.00017652354f);
\r
596 Assert(d == 0.0001765235m);
\r
598 d = new S.Decimal(0.00017652346f);
\r
599 Assert(d == 0.0001765235m);
\r
601 d = new S.Decimal(0.000176523454f);
\r
602 Assert("failed banker's rule rounding test 4", d == 0.0001765234m);
\r
604 d = new S.Decimal(0.00017652344f);
\r
605 Assert(d == 0.0001765234m);
\r
607 d = new S.Decimal(3.7652356e10f);
\r
608 Assert(d == 37652360000m);
\r
610 d = new S.Decimal(3.7652356e20f);
\r
611 Assert(d == 376523600000000000000m);
\r
613 d = new S.Decimal(3.76523554e20f);
\r
614 Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);
\r
616 d = new S.Decimal(3.7652352e20f);
\r
617 Assert(d == 376523500000000000000m);
\r
619 d = new S.Decimal(3.7652348e20f);
\r
620 Assert(d == 376523500000000000000m);
\r
622 d = new S.Decimal(3.76523454e20f);
\r
623 Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);
\r
625 d = new S.Decimal(3.7652342e20f);
\r
626 Assert(d == 376523400000000000000m);
\r
629 public void TestConstructDouble()
\r
633 d = new S.Decimal(0.0);
\r
634 Assert((decimal)d == 0m);
\r
636 d = new S.Decimal(1.0);
\r
637 Assert((decimal)d == 1m);
\r
638 Assert(1.0 == (double)d);
\r
640 d = new S.Decimal(-1.2345678901234);
\r
641 Assert((decimal)d == -1.2345678901234m);
\r
642 Assert(-1.2345678901234 == (double)d);
\r
644 d = new S.Decimal(1.2345678901234);
\r
645 Assert((decimal)d == 1.2345678901234m);
\r
647 d = new S.Decimal(1.2345678901234e8);
\r
648 Assert((decimal)d == 123456789.01234m);
\r
649 Assert(1.2345678901234e8 == (double)d);
\r
651 d = new S.Decimal(1.2345678901234e16);
\r
652 Assert((decimal)d == 12345678901234000m);
\r
653 Assert(1.2345678901234e16 == (double)d);
\r
655 d = new S.Decimal(1.2345678901234e24);
\r
656 Assert((decimal)d == 1234567890123400000000000m);
\r
657 Assert(1.2345678901234e24 == (double)d);
\r
659 d = new S.Decimal(1.2345678901234e28);
\r
660 Assert((decimal)d == 1.2345678901234e28m);
\r
661 Assert(1.2345678901234e28 == (double)d);
\r
663 d = new S.Decimal(7.2345678901234e28);
\r
664 Assert((decimal)d == 7.2345678901234e28m);
\r
665 Assert(new S.Decimal((double)d) == d);
\r
667 d = new S.Decimal(1.2345678901234e-8);
\r
668 Assert((decimal)d == 1.2345678901234e-8m);
\r
670 d = new S.Decimal(1.2345678901234e-14);
\r
671 Assert((decimal)d == 1.2345678901234e-14m);
\r
672 Assert(1.2345678901234e-14 == (double)d);
\r
674 d = new S.Decimal(1.2342278901234e-25);
\r
675 Assert((decimal)d == 1.234e-25m);
\r
680 d = new S.Decimal(8e28);
\r
683 catch (OverflowException)
\r
689 d = new S.Decimal(8e48);
\r
692 catch (OverflowException)
\r
698 d = new S.Decimal(Double.NaN);
\r
701 catch (OverflowException)
\r
707 d = new S.Decimal(Double.PositiveInfinity);
\r
710 catch (OverflowException)
\r
715 public void TestConstructDoubleRound()
\r
719 d = new S.Decimal(1765.231234567857);
\r
720 Assert(d == 1765.23123456786m);
\r
722 d = new S.Decimal(1765.2312345678554);
\r
723 Assert("failed banker's rule rounding test 1", d == 1765.23123456786m);
\r
724 Assert(1765.23123456786 == (double)d);
\r
726 d = new S.Decimal(1765.231234567853);
\r
727 Assert(d == 1765.23123456785m);
\r
729 d = new S.Decimal(1765.231234567847);
\r
730 Assert(d == 1765.23123456785m);
\r
732 d = new S.Decimal(1765.231234567843);
\r
733 Assert(d == 1765.23123456784m);
\r
735 d = new S.Decimal(1.765231234567857e-9);
\r
736 Assert(d == 1.76523123456786e-9m);
\r
738 d = new S.Decimal(1.7652312345678554e-9);
\r
739 Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);
\r
741 d = new S.Decimal(1.765231234567853e-9);
\r
742 Assert(d == 1.76523123456785e-9m);
\r
744 d = new S.Decimal(1.765231234567857e+24);
\r
745 Assert(d == 1.76523123456786e+24m);
\r
747 d = new S.Decimal(1.7652312345678554e+24);
\r
748 Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);
\r
750 d = new S.Decimal(1.765231234567853e+24);
\r
751 Assert(d == 1.76523123456785e+24m);
\r
753 d = new S.Decimal(1765.2312345678454);
\r
754 Assert(d == 1765.23123456785m);
\r
757 public void TestNegate()
\r
761 d = new S.Decimal(12345678);
\r
762 Assert((decimal)S.Decimal.Negate(d) == -12345678m);
\r
765 public void TestPartConstruct()
\r
769 d = new Decimal(parts0);
\r
772 d = new Decimal(parts1);
\r
775 d = new Decimal(parts2);
\r
776 Assert(d == 4294967296m);
\r
778 d = new Decimal(parts3);
\r
779 Assert(d == 18446744073709551616m);
\r
781 d = new Decimal(parts4);
\r
784 d = new Decimal(parts5);
\r
785 Assert(d == 18446744078004518913m);
\r
787 d = new Decimal(partsMaxValue);
\r
788 Assert(d == Decimal.MaxValue);
\r
790 d = new Decimal(partsMinValue);
\r
791 Assert(d == Decimal.MinValue);
\r
793 d = new Decimal(parts6);
\r
794 int[] erg = Decimal.GetBits(d);
\r
795 for (int i = 0; i < 4; i++)
\r
797 Assert(erg[i] == parts6[i]);
\r
801 public void TestFloorTruncate()
\r
803 decimal[,] dtab = {
\r
804 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
\r
805 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
\r
806 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
\r
807 {S.Decimal.MaxValue, S.Decimal.MaxValue, S.Decimal.MaxValue},
\r
808 {S.Decimal.MinValue, S.Decimal.MinValue, S.Decimal.MinValue},
\r
809 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
\r
810 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
\r
815 for (int i = 0; i < dtab.GetLength(0); i++)
\r
817 d = S.Decimal.Floor(dtab[i,0]);
\r
818 if (d != dtab[i,1])
\r
820 Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);
\r
822 d = S.Decimal.Truncate(dtab[i,0]);
\r
823 if (d != dtab[i,2])
\r
825 Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);
\r
830 public void TestRound()
\r
832 decimal[,] dtab = {
\r
833 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
\r
834 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
\r
835 {1.2345m, 3, 1.234m}, {1.2355m, 3, 1.236m},
\r
836 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
\r
837 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
\r
838 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
\r
839 {-47893764694.4578m, 5, -47893764694.4578m}
\r
844 for (int i = 0; i < dtab.GetLength(0); i++)
\r
846 d = S.Decimal.Round(dtab[i,0], (int)dtab[i,1]);
\r
847 if (d != dtab[i,2])
\r
849 Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
\r