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 AssertEquals("A01 tab[" + i + "].format = '" + tab[i].format + "')", tab[i].str, s);
\r
202 catch (OverflowException)
\r
204 Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");
\r
206 catch (Exception e) {
\r
207 Fail ("Unexpected Exception when i = " + i + ". e = " + e);
\r
212 public void TestCurrencyPattern()
\r
214 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
215 S.Decimal d = -1234567.8976m;
\r
216 string[] ergCurrencyNegativePattern = new String[16] {
\r
217 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
\r
218 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
\r
219 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
\r
220 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
\r
223 for (int i = 0; i < ergCurrencyNegativePattern.Length; i++)
\r
225 nfi2.CurrencyNegativePattern = i;
\r
226 if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i])
\r
228 Fail("CurrencyNegativePattern #" + i + " failed: " +
\r
229 d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);
\r
234 string[] ergCurrencyPositivePattern = new String[4] {
\r
235 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
\r
238 for (int i = 0; i < ergCurrencyPositivePattern.Length; i++)
\r
240 nfi2.CurrencyPositivePattern = i;
\r
241 if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i])
\r
243 Fail("CurrencyPositivePattern #" + i + " failed: " +
\r
244 d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);
\r
249 public void TestNumberNegativePattern()
\r
251 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
252 S.Decimal d = -1234.89765m;
\r
253 string[] ergNumberNegativePattern = new String[5] {
\r
254 "(1__2__34##8976)", "-1__2__34##8976", "- 1__2__34##8976", "1__2__34##8976-", "1__2__34##8976 -",
\r
257 for (int i = 0; i < ergNumberNegativePattern.Length; i++)
\r
259 nfi2.NumberNegativePattern = i;
\r
260 if (d.ToString("N", nfi2) != ergNumberNegativePattern[i])
\r
262 Fail("NumberNegativePattern #" + i + " failed: " +
\r
263 d.ToString("N", nfi2) + " != " + ergNumberNegativePattern[i]);
\r
268 public void TestPercentPattern()
\r
270 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
271 S.Decimal d = -1234.8976m;
\r
272 string[] ergPercentNegativePattern = new String[3] {
\r
273 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
\r
276 for (int i = 0; i < ergPercentNegativePattern.Length; i++)
\r
278 nfi2.PercentNegativePattern = i;
\r
279 if (d.ToString("P", nfi2) != ergPercentNegativePattern[i])
\r
281 Fail("PercentNegativePattern #" + i + " failed: " +
\r
282 d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);
\r
287 string[] ergPercentPositivePattern = new String[3] {
\r
288 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
\r
291 for (int i = 0; i < ergPercentPositivePattern.Length; i++)
\r
293 nfi2.PercentPositivePattern = i;
\r
294 if (d.ToString("P", nfi2) != ergPercentPositivePattern[i])
\r
296 Fail("PercentPositivePattern #" + i + " failed: " +
\r
297 d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);
\r
302 public void TestParse()
\r
304 ParseTest[] tab = {
\r
305 new ParseTest("1.2345", 1.2345m),
\r
306 new ParseTest("-9876543210", -9876543210m),
\r
307 new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol
\r
308 + " ( 79,228,162,514,264,337,593,543,950,335.000 ) ", S.Decimal.MinValue, NumberStyles.Currency),
\r
309 new ParseTest("1.234567890e-10", (S.Decimal)1.234567890e-10, NumberStyles.Float),
\r
310 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
\r
311 new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),
\r
312 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
\r
313 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
\r
314 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
\r
315 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
\r
316 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
\r
317 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
\r
321 for (int i = 0; i < tab.Length; i++)
\r
325 d = S.Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);
\r
326 if (tab[i].exceptionFlag)
\r
328 Fail(tab[i].str + ": missing exception !");
\r
330 else if (d != tab[i].d)
\r
332 Fail(tab[i].str + " != " + d);
\r
335 catch (OverflowException)
\r
337 if (!tab[i].exceptionFlag)
\r
339 Fail(tab[i].str + ": unexpected exception !");
\r
346 d = S.Decimal.Parse(null);
\r
347 Fail("Expected ArgumentNullException");
\r
349 catch (ArgumentNullException)
\r
356 d = S.Decimal.Parse("123nx");
\r
357 Fail("Expected FormatException");
\r
359 catch (FormatException)
\r
366 d = S.Decimal.Parse("79228162514264337593543950336");
\r
367 Fail("Expected OverflowException" + d);
\r
369 catch (OverflowException)
\r
375 public void TestConstants()
\r
377 Assert(0m == (decimal)S.Decimal.Zero);
\r
378 Assert(1m == (decimal)S.Decimal.One);
\r
379 Assert(-1m == (decimal)S.Decimal.MinusOne);
\r
380 Assert(0m == (decimal)S.Decimal.Zero);
\r
381 Assert(79228162514264337593543950335m == (decimal)S.Decimal.MaxValue);
\r
382 Assert(-79228162514264337593543950335m == (decimal)S.Decimal.MinValue);
\r
385 public void TestConstructInt32()
\r
387 decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};
\r
388 int[] itab = {0, 1, -1, 123456, -1234567};
\r
392 for (int i = 0; i < dtab.GetLength(0); i++)
\r
394 d = new S.Decimal(itab[i]);
\r
395 if ((decimal)d != dtab[i])
\r
397 Fail("Int32 -> Decimal: " + itab[i] + " != " + d);
\r
404 Fail("Decimal -> Int32: " + d + " != " + itab[i]);
\r
409 d = new S.Decimal(Int32.MaxValue);
\r
410 Assert((int)d == Int32.MaxValue);
\r
412 d = new S.Decimal(Int32.MinValue);
\r
413 Assert((int)d == Int32.MinValue);
\r
416 public void TestConstructUInt32()
\r
418 decimal[] dtab = {0m, 1m, 123456m, 123456789m};
\r
419 uint[] itab = {0, 1, 123456, 123456789};
\r
423 for (int i = 0; i < dtab.GetLength(0); i++)
\r
425 d = new S.Decimal(itab[i]);
\r
426 if ((decimal)d != dtab[i])
\r
428 Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);
\r
435 Fail("Decimal -> UInt32: " + d + " != " + itab[i]);
\r
440 d = new S.Decimal(UInt32.MaxValue);
\r
441 Assert((uint)d == UInt32.MaxValue);
\r
443 d = new Decimal(UInt32.MinValue);
\r
444 Assert((uint)d == UInt32.MinValue);
\r
447 public void TestConstructInt64()
\r
449 decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};
\r
450 long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};
\r
454 for (int i = 0; i < dtab.GetLength(0); i++)
\r
456 d = new S.Decimal(itab[i]);
\r
457 if ((decimal)d != dtab[i])
\r
459 Fail("Int64 -> Decimal: " + itab[i] + " != " + d);
\r
466 Fail("Decimal -> Int64: " + d + " != " + itab[i]);
\r
471 d = new S.Decimal(Int64.MaxValue);
\r
472 Assert((long)d == Int64.MaxValue);
\r
474 d = new Decimal(Int64.MinValue);
\r
475 Assert((long)d == Int64.MinValue);
\r
478 public void TestConstructUInt64()
\r
480 decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};
\r
481 ulong[] itab = {0, 1, 987654321, 123456789876543210L};
\r
485 for (int i = 0; i < dtab.GetLength(0); i++)
\r
487 d = new S.Decimal(itab[i]);
\r
488 if ((decimal)d != dtab[i])
\r
490 Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);
\r
494 ulong n = (ulong) d;
\r
497 Fail("Decimal -> UInt64: " + d + " != " + itab[i]);
\r
502 d = new S.Decimal(UInt64.MaxValue);
\r
503 Assert((ulong)d == UInt64.MaxValue);
\r
505 d = new Decimal(UInt64.MinValue);
\r
506 Assert((ulong)d == UInt64.MinValue);
\r
509 public void TestConstructSingle()
\r
513 d = new S.Decimal(-1.2345678f);
\r
514 AssertEquals("A#01", -1.234568m, (decimal)d);
\r
517 AssertEquals("A#02", 3.0f, (float)d);
\r
519 d = new S.Decimal(0.0f);
\r
520 AssertEquals("A#03", 0m, (decimal)d);
\r
521 AssertEquals("A#04", 0.0f, (float)d);
\r
523 d = new S.Decimal(1.0f);
\r
524 AssertEquals("A#05", 1m, (decimal)d);
\r
525 AssertEquals("A#06", 1.0f, (float)d);
\r
527 d = new S.Decimal(-1.2345678f);
\r
528 AssertEquals("A#07", -1.234568m, (decimal)d);
\r
529 AssertEquals("A#08", -1.234568f, (float)d);
\r
531 d = new S.Decimal(1.2345673f);
\r
532 AssertEquals("A#09", 1.234567m, (decimal)d);
\r
534 d = new S.Decimal(1.2345673e7f);
\r
535 AssertEquals("A#10", 12345670m, (decimal)d);
\r
537 d = new S.Decimal(1.2345673e-17f);
\r
538 AssertEquals("A#11", 0.00000000000000001234567m, (decimal)d);
\r
539 AssertEquals("A#12", 1.234567e-17f, (float)d);
\r
544 d = new S.Decimal(Single.MaxValue);
\r
547 catch (OverflowException)
\r
553 d = new S.Decimal(Single.NaN);
\r
556 catch (OverflowException)
\r
562 d = new S.Decimal(Single.PositiveInfinity);
\r
565 catch (OverflowException)
\r
570 public void TestConstructSingleRounding()
\r
574 d = new S.Decimal(1765.2356f);
\r
575 Assert(d == 1765.236m);
\r
577 d = new S.Decimal(1765.23554f);
\r
578 Assert("failed banker's rule rounding test 1", d == 1765.236m);
\r
580 d = new S.Decimal(1765.2354f);
\r
581 Assert(d == 1765.235m);
\r
583 d = new S.Decimal(1765.2346f);
\r
584 Assert(d == 1765.235m);
\r
586 d = new S.Decimal(1765.23454f);
\r
587 Assert("failed banker's rule rounding test 2", d == 1765.234m);
\r
589 d = new S.Decimal(1765.2344f);
\r
590 Assert(d == 1765.234m);
\r
592 d = new S.Decimal(0.00017652356f);
\r
593 Assert(d == 0.0001765236m);
\r
595 d = new S.Decimal(0.000176523554f);
\r
596 Assert("failed banker's rule rounding test 3", d == 0.0001765236m);
\r
598 d = new S.Decimal(0.00017652354f);
\r
599 Assert(d == 0.0001765235m);
\r
601 d = new S.Decimal(0.00017652346f);
\r
602 Assert(d == 0.0001765235m);
\r
604 d = new S.Decimal(0.000176523454f);
\r
605 Assert("failed banker's rule rounding test 4", d == 0.0001765234m);
\r
607 d = new S.Decimal(0.00017652344f);
\r
608 Assert(d == 0.0001765234m);
\r
610 d = new S.Decimal(3.7652356e10f);
\r
611 Assert(d == 37652360000m);
\r
613 d = new S.Decimal(3.7652356e20f);
\r
614 Assert(d == 376523600000000000000m);
\r
616 d = new S.Decimal(3.76523554e20f);
\r
617 Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);
\r
619 d = new S.Decimal(3.7652352e20f);
\r
620 Assert(d == 376523500000000000000m);
\r
622 d = new S.Decimal(3.7652348e20f);
\r
623 Assert(d == 376523500000000000000m);
\r
625 d = new S.Decimal(3.76523454e20f);
\r
626 Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);
\r
628 d = new S.Decimal(3.7652342e20f);
\r
629 Assert(d == 376523400000000000000m);
\r
632 public void TestConstructDouble()
\r
636 d = new S.Decimal(0.0);
\r
637 Assert((decimal)d == 0m);
\r
639 d = new S.Decimal(1.0);
\r
640 Assert((decimal)d == 1m);
\r
641 Assert(1.0 == (double)d);
\r
643 d = new S.Decimal(-1.2345678901234);
\r
644 Assert((decimal)d == -1.2345678901234m);
\r
645 Assert(-1.2345678901234 == (double)d);
\r
647 d = new S.Decimal(1.2345678901234);
\r
648 Assert((decimal)d == 1.2345678901234m);
\r
650 d = new S.Decimal(1.2345678901234e8);
\r
651 Assert((decimal)d == 123456789.01234m);
\r
652 Assert(1.2345678901234e8 == (double)d);
\r
654 d = new S.Decimal(1.2345678901234e16);
\r
655 Assert((decimal)d == 12345678901234000m);
\r
656 Assert(1.2345678901234e16 == (double)d);
\r
658 d = new S.Decimal(1.2345678901234e24);
\r
659 Assert((decimal)d == 1234567890123400000000000m);
\r
660 Assert(1.2345678901234e24 == (double)d);
\r
662 d = new S.Decimal(1.2345678901234e28);
\r
663 Assert((decimal)d == 1.2345678901234e28m);
\r
664 Assert(1.2345678901234e28 == (double)d);
\r
666 d = new S.Decimal(7.2345678901234e28);
\r
667 Assert((decimal)d == 7.2345678901234e28m);
\r
668 Assert(new S.Decimal((double)d) == d);
\r
670 d = new S.Decimal(1.2345678901234e-8);
\r
671 Assert((decimal)d == 1.2345678901234e-8m);
\r
673 d = new S.Decimal(1.2345678901234e-14);
\r
674 Assert((decimal)d == 1.2345678901234e-14m);
\r
675 Assert(1.2345678901234e-14 == (double)d);
\r
677 d = new S.Decimal(1.2342278901234e-25);
\r
678 Assert((decimal)d == 1.234e-25m);
\r
683 d = new S.Decimal(8e28);
\r
686 catch (OverflowException)
\r
692 d = new S.Decimal(8e48);
\r
695 catch (OverflowException)
\r
701 d = new S.Decimal(Double.NaN);
\r
704 catch (OverflowException)
\r
710 d = new S.Decimal(Double.PositiveInfinity);
\r
713 catch (OverflowException)
\r
718 public void TestConstructDoubleRound()
\r
722 d = new S.Decimal(1765.231234567857);
\r
723 Assert(d == 1765.23123456786m);
\r
725 d = new S.Decimal(1765.2312345678554);
\r
726 Assert("failed banker's rule rounding test 1", d == 1765.23123456786m);
\r
727 Assert(1765.23123456786 == (double)d);
\r
729 d = new S.Decimal(1765.231234567853);
\r
730 Assert(d == 1765.23123456785m);
\r
732 d = new S.Decimal(1765.231234567847);
\r
733 Assert(d == 1765.23123456785m);
\r
735 d = new S.Decimal(1765.231234567843);
\r
736 Assert(d == 1765.23123456784m);
\r
738 d = new S.Decimal(1.765231234567857e-9);
\r
739 Assert(d == 1.76523123456786e-9m);
\r
741 d = new S.Decimal(1.7652312345678554e-9);
\r
742 Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);
\r
744 d = new S.Decimal(1.765231234567853e-9);
\r
745 Assert(d == 1.76523123456785e-9m);
\r
747 d = new S.Decimal(1.765231234567857e+24);
\r
748 Assert(d == 1.76523123456786e+24m);
\r
750 d = new S.Decimal(1.7652312345678554e+24);
\r
751 Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);
\r
753 d = new S.Decimal(1.765231234567853e+24);
\r
754 Assert(d == 1.76523123456785e+24m);
\r
756 d = new S.Decimal(1765.2312345678454);
\r
757 Assert(d == 1765.23123456785m);
\r
760 public void TestNegate()
\r
764 d = new S.Decimal(12345678);
\r
765 Assert((decimal)S.Decimal.Negate(d) == -12345678m);
\r
768 public void TestPartConstruct()
\r
772 d = new Decimal(parts0);
\r
775 d = new Decimal(parts1);
\r
778 d = new Decimal(parts2);
\r
779 Assert(d == 4294967296m);
\r
781 d = new Decimal(parts3);
\r
782 Assert(d == 18446744073709551616m);
\r
784 d = new Decimal(parts4);
\r
787 d = new Decimal(parts5);
\r
788 Assert(d == 18446744078004518913m);
\r
790 d = new Decimal(partsMaxValue);
\r
791 Assert(d == Decimal.MaxValue);
\r
793 d = new Decimal(partsMinValue);
\r
794 Assert(d == Decimal.MinValue);
\r
796 d = new Decimal(parts6);
\r
797 int[] erg = Decimal.GetBits(d);
\r
798 for (int i = 0; i < 4; i++)
\r
800 Assert(erg[i] == parts6[i]);
\r
804 public void TestFloorTruncate()
\r
806 decimal[,] dtab = {
\r
807 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
\r
808 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
\r
809 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
\r
810 {S.Decimal.MaxValue, S.Decimal.MaxValue, S.Decimal.MaxValue},
\r
811 {S.Decimal.MinValue, S.Decimal.MinValue, S.Decimal.MinValue},
\r
812 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
\r
813 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
\r
818 for (int i = 0; i < dtab.GetLength(0); i++)
\r
820 d = S.Decimal.Floor(dtab[i,0]);
\r
821 if (d != dtab[i,1])
\r
823 Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);
\r
825 d = S.Decimal.Truncate(dtab[i,0]);
\r
826 if (d != dtab[i,2])
\r
828 Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);
\r
833 public void TestRound()
\r
835 decimal[,] dtab = {
\r
836 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
\r
837 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
\r
838 {1.2345m, 3, 1.234m}, {1.2355m, 3, 1.236m},
\r
839 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
\r
840 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
\r
841 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
\r
842 {-47893764694.4578m, 5, -47893764694.4578m}
\r
847 for (int i = 0; i < dtab.GetLength(0); i++)
\r
849 d = S.Decimal.Round(dtab[i,0], (int)dtab[i,1]);
\r
850 if (d != dtab[i,2])
\r
852 Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
\r