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() : 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 private CultureInfo old_culture;
\r
90 protected override void SetUp()
\r
92 old_culture = Thread.CurrentThread.CurrentCulture;
\r
94 // Set culture to en-US and don't let the user override.
\r
95 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
\r
97 NfiUser = new NumberFormatInfo();
\r
98 NfiUser.CurrencyDecimalDigits = 3;
\r
99 NfiUser.CurrencyDecimalSeparator = ",";
\r
100 NfiUser.CurrencyGroupSeparator = "_";
\r
101 NfiUser.CurrencyGroupSizes = new int[] { 2,1,0 };
\r
102 NfiUser.CurrencyNegativePattern = 10;
\r
103 NfiUser.CurrencyPositivePattern = 3;
\r
104 NfiUser.CurrencySymbol = "XYZ";
\r
105 NfiUser.NumberDecimalSeparator = "##";
\r
106 NfiUser.NumberDecimalDigits = 4;
\r
107 NfiUser.NumberGroupSeparator = "__";
\r
108 NfiUser.NumberGroupSizes = new int[] { 2,1 };
\r
109 NfiUser.PercentDecimalDigits = 1;
\r
110 NfiUser.PercentDecimalSeparator = ";";
\r
111 NfiUser.PercentGroupSeparator = "~";
\r
112 NfiUser.PercentGroupSizes = new int[] {1};
\r
113 NfiUser.PercentNegativePattern = 2;
\r
114 NfiUser.PercentPositivePattern = 2;
\r
115 NfiUser.PercentSymbol = "%%%";
\r
118 protected override void TearDown()
\r
120 Thread.CurrentThread.CurrentCulture = old_culture;
\r
123 public void TestToString()
\r
125 ToStringTest[] tab = {
\r
126 new ToStringTest("F", 12.345678m, "12.35"),
\r
127 new ToStringTest("F3", 12.345678m, "12.346"),
\r
128 new ToStringTest("F0", 12.345678m, "12"),
\r
129 new ToStringTest("F7", 12.345678m, "12.3456780"),
\r
130 new ToStringTest("g", 12.345678m, "12.345678"),
\r
131 new ToStringTest("E", 12.345678m, "1.234568E+001"),
\r
132 new ToStringTest("E3", 12.345678m, "1.235E+001"),
\r
133 new ToStringTest("E0", 12.345678m, "1E+001"),
\r
134 new ToStringTest("e8", 12.345678m, "1.23456780e+001"),
\r
135 new ToStringTest("F", 0.0012m, "0.00"),
\r
136 new ToStringTest("F3", 0.0012m, "0.001"),
\r
137 new ToStringTest("F0", 0.0012m, "0"),
\r
138 new ToStringTest("F6", 0.0012m, "0.001200"),
\r
139 new ToStringTest("e", 0.0012m, "1.200000e-003"),
\r
140 new ToStringTest("E3", 0.0012m, "1.200E-003"),
\r
141 new ToStringTest("E0", 0.0012m, "1E-003"),
\r
142 new ToStringTest("E6", 0.0012m, "1.200000E-003"),
\r
143 new ToStringTest("F4", -0.001234m, "-0.0012"),
\r
144 new ToStringTest("E3", -0.001234m, "-1.234E-003"),
\r
145 new ToStringTest("g", -0.000012m, "-1.2e-05"),
\r
146 new ToStringTest("g", -0.00012m, "-0.00012"),
\r
147 new ToStringTest("g4", -0.00012m, "-0.00012"),
\r
148 new ToStringTest("g7", -0.00012m, "-0.00012"),
\r
149 new ToStringTest("g", -0.0001234m, "-0.0001234"),
\r
150 new ToStringTest("g", -0.0012m, "-0.0012"),
\r
151 new ToStringTest("g", -0.001234m, "-0.001234"),
\r
152 new ToStringTest("g", -0.012m, "-0.012"),
\r
153 new ToStringTest("g4", -0.012m, "-0.012"),
\r
154 new ToStringTest("g", -0.12m, "-0.12"),
\r
155 new ToStringTest("g", -1.2m, "-1.2"),
\r
156 new ToStringTest("g4", -120m, "-120"),
\r
157 new ToStringTest("g", -12m, "-12"),
\r
158 new ToStringTest("g", -120m, "-120"),
\r
159 new ToStringTest("g", -1200m, "-1200"),
\r
160 new ToStringTest("g4", -1200m, "-1200"),
\r
161 new ToStringTest("g", -1234m, "-1234"),
\r
162 new ToStringTest("g", -12000m, "-12000"),
\r
163 new ToStringTest("g4", -12000m, "-1.2e+04"),
\r
164 new ToStringTest("g5", -12000m, "-12000"),
\r
165 new ToStringTest("g", -12345m, "-12345"),
\r
166 new ToStringTest("g", -120000m, "-120000"),
\r
167 new ToStringTest("g4", -120000m, "-1.2e+05"),
\r
168 new ToStringTest("g5", -120000m, "-1.2e+05"),
\r
169 new ToStringTest("g6", -120000m, "-120000"),
\r
170 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
171 new ToStringTest("g5", -123456.1m, "-1.2346e+05"),
\r
172 new ToStringTest("g6", -123456.1m, "-123456"),
\r
173 new ToStringTest("g", -1200000m, "-1200000"),
\r
174 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
175 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
176 new ToStringTest("g", -1234567.1m, "-1234567.1"),
\r
177 new ToStringTest("g", -12000000m, "-12000000"),
\r
178 new ToStringTest("g", -12345678.1m, "-12345678.1"),
\r
179 new ToStringTest("g", -12000000000000000000m, "-12000000000000000000"),
\r
180 new ToStringTest("F", -123, "-123.00"),
\r
181 new ToStringTest("F3", -123, "-123.000"),
\r
182 new ToStringTest("F0", -123, "-123"),
\r
183 new ToStringTest("E3", -123, "-1.230E+002"),
\r
184 new ToStringTest("E0", -123, "-1E+002"),
\r
185 new ToStringTest("E", -123, "-1.230000E+002"),
\r
186 new ToStringTest("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),
\r
187 new ToStringTest("F", Decimal.MinValue, "-79228162514264337593543950335.00"),
\r
188 new ToStringTest("F0", Decimal.MinValue, "-79228162514264337593543950335"),
\r
189 new ToStringTest("E", Decimal.MinValue, "-7.922816E+028"),
\r
190 new ToStringTest("E3", Decimal.MinValue, "-7.923E+028"),
\r
191 new ToStringTest("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),
\r
192 new ToStringTest("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),
\r
193 new ToStringTest("E0", Decimal.MinValue, "-8E+028"),
\r
194 new ToStringTest("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
\r
195 new ToStringTest("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
\r
196 new ToStringTest("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
\r
197 new ToStringTest("n3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
\r
198 new ToStringTest("n0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
\r
199 new ToStringTest("n", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
\r
200 new ToStringTest("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),
\r
201 new ToStringTest("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),
\r
202 new ToStringTest("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),
\r
203 new ToStringTest("P", 123456.7891m, "12,345,678.91 %"),
\r
204 new ToStringTest("P", -123456.7892m, "-12,345,678.92 %"),
\r
205 new ToStringTest("P3", 1234.56789m, "123,456.789 %"),
\r
208 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
\r
210 for (int i = 0; i < tab.Length; i++)
\r
214 string s = tab[i].d.ToString(tab[i].format, nfi);
\r
215 AssertEquals("A01 tab[" + i + "].format = '" + tab[i].format + "')", tab[i].str, s);
\r
217 catch (OverflowException)
\r
219 Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");
\r
221 catch (NUnit.Framework.AssertionFailedError e) {
\r
224 catch (Exception e) {
\r
225 Fail ("Unexpected Exception when i = " + i + ". e = " + e);
\r
230 public void TestCurrencyPattern()
\r
232 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
233 Decimal d = -1234567.8976m;
\r
234 string[] ergCurrencyNegativePattern = new String[16] {
\r
235 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
\r
236 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
\r
237 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
\r
238 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
\r
241 for (int i = 0; i < ergCurrencyNegativePattern.Length; i++)
\r
243 nfi2.CurrencyNegativePattern = i;
\r
244 if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i])
\r
246 Fail("CurrencyNegativePattern #" + i + " failed: " +
\r
247 d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);
\r
252 string[] ergCurrencyPositivePattern = new String[4] {
\r
253 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
\r
256 for (int i = 0; i < ergCurrencyPositivePattern.Length; i++)
\r
258 nfi2.CurrencyPositivePattern = i;
\r
259 if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i])
\r
261 Fail("CurrencyPositivePattern #" + i + " failed: " +
\r
262 d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);
\r
267 public void TestNumberNegativePattern()
\r
269 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
270 Decimal d = -1234.89765m;
\r
271 string[] ergNumberNegativePattern = new String[5] {
\r
272 "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",
\r
275 for (int i = 0; i < ergNumberNegativePattern.Length; i++)
\r
277 nfi2.NumberNegativePattern = i;
\r
278 AssertEquals ("NumberNegativePattern #" + i, ergNumberNegativePattern[i], d.ToString("N", nfi2));
\r
282 public void TestPercentPattern()
\r
284 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
285 Decimal d = -1234.8976m;
\r
286 string[] ergPercentNegativePattern = new String[3] {
\r
287 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
\r
290 for (int i = 0; i < ergPercentNegativePattern.Length; i++)
\r
292 nfi2.PercentNegativePattern = i;
\r
293 if (d.ToString("P", nfi2) != ergPercentNegativePattern[i])
\r
295 Fail("PercentNegativePattern #" + i + " failed: " +
\r
296 d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);
\r
301 string[] ergPercentPositivePattern = new String[3] {
\r
302 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
\r
305 for (int i = 0; i < ergPercentPositivePattern.Length; i++)
\r
307 nfi2.PercentPositivePattern = i;
\r
308 if (d.ToString("P", nfi2) != ergPercentPositivePattern[i])
\r
310 Fail("PercentPositivePattern #" + i + " failed: " +
\r
311 d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);
\r
316 public void TestParse()
\r
318 ParseTest[] tab = {
\r
319 new ParseTest("1.2345", 1.2345m),
\r
320 new ParseTest("-9876543210", -9876543210m),
\r
321 new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol
\r
322 + " ( 79,228,162,514,264,337,593,543,950,335.000 ) ", Decimal.MinValue, NumberStyles.Currency),
\r
323 new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),
\r
324 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
\r
325 new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),
\r
326 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
\r
327 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
\r
328 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
\r
329 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
\r
330 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
\r
331 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
\r
335 for (int i = 0; i < tab.Length; i++)
\r
339 d = Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);
\r
340 if (tab[i].exceptionFlag)
\r
342 Fail(tab[i].str + ": missing exception !");
\r
344 else if (d != tab[i].d)
\r
346 Fail(tab[i].str + " != " + d);
\r
349 catch (OverflowException)
\r
351 if (!tab[i].exceptionFlag)
\r
353 Fail(tab[i].str + ": unexpected exception !");
\r
360 d = Decimal.Parse(null);
\r
361 Fail("Expected ArgumentNullException");
\r
363 catch (ArgumentNullException)
\r
370 d = Decimal.Parse("123nx");
\r
371 Fail("Expected FormatException");
\r
373 catch (FormatException)
\r
380 d = Decimal.Parse("79228162514264337593543950336");
\r
381 Fail("Expected OverflowException" + d);
\r
383 catch (OverflowException)
\r
389 public void TestConstants()
\r
391 Assert(0m == (decimal)Decimal.Zero);
\r
392 Assert(1m == (decimal)Decimal.One);
\r
393 Assert(-1m == (decimal)Decimal.MinusOne);
\r
394 Assert(0m == (decimal)Decimal.Zero);
\r
395 Assert(79228162514264337593543950335m == (decimal)Decimal.MaxValue);
\r
396 Assert(-79228162514264337593543950335m == (decimal)Decimal.MinValue);
\r
399 public void TestConstructInt32()
\r
401 decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};
\r
402 int[] itab = {0, 1, -1, 123456, -1234567};
\r
406 for (int i = 0; i < dtab.GetLength(0); i++)
\r
408 d = new Decimal(itab[i]);
\r
409 if ((decimal)d != dtab[i])
\r
411 Fail("Int32 -> Decimal: " + itab[i] + " != " + d);
\r
418 Fail("Decimal -> Int32: " + d + " != " + itab[i]);
\r
423 d = new Decimal(Int32.MaxValue);
\r
424 Assert((int)d == Int32.MaxValue);
\r
426 d = new Decimal(Int32.MinValue);
\r
427 Assert((int)d == Int32.MinValue);
\r
430 public void TestConstructUInt32()
\r
432 decimal[] dtab = {0m, 1m, 123456m, 123456789m};
\r
433 uint[] itab = {0, 1, 123456, 123456789};
\r
437 for (int i = 0; i < dtab.GetLength(0); i++)
\r
439 d = new Decimal(itab[i]);
\r
440 if ((decimal)d != dtab[i])
\r
442 Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);
\r
449 Fail("Decimal -> UInt32: " + d + " != " + itab[i]);
\r
454 d = new Decimal(UInt32.MaxValue);
\r
455 Assert((uint)d == UInt32.MaxValue);
\r
457 d = new Decimal(UInt32.MinValue);
\r
458 Assert((uint)d == UInt32.MinValue);
\r
461 public void TestConstructInt64()
\r
463 decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};
\r
464 long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};
\r
468 for (int i = 0; i < dtab.GetLength(0); i++)
\r
470 d = new Decimal(itab[i]);
\r
471 if ((decimal)d != dtab[i])
\r
473 Fail("Int64 -> Decimal: " + itab[i] + " != " + d);
\r
480 Fail("Decimal -> Int64: " + d + " != " + itab[i]);
\r
485 d = new Decimal(Int64.MaxValue);
\r
486 Assert((long)d == Int64.MaxValue);
\r
488 d = new Decimal(Int64.MinValue);
\r
489 Assert((long)d == Int64.MinValue);
\r
492 public void TestConstructUInt64()
\r
494 decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};
\r
495 ulong[] itab = {0, 1, 987654321, 123456789876543210L};
\r
499 for (int i = 0; i < dtab.GetLength(0); i++)
\r
501 d = new Decimal(itab[i]);
\r
502 if ((decimal)d != dtab[i])
\r
504 Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);
\r
508 ulong n = (ulong) d;
\r
511 Fail("Decimal -> UInt64: " + d + " != " + itab[i]);
\r
516 d = new Decimal(UInt64.MaxValue);
\r
517 Assert((ulong)d == UInt64.MaxValue);
\r
519 d = new Decimal(UInt64.MinValue);
\r
520 Assert((ulong)d == UInt64.MinValue);
\r
523 public void TestConstructSingle()
\r
527 d = new Decimal(-1.2345678f);
\r
528 AssertEquals("A#01", -1.234568m, (decimal)d);
\r
531 AssertEquals("A#02", 3.0f, (float)d);
\r
533 d = new Decimal(0.0f);
\r
534 AssertEquals("A#03", 0m, (decimal)d);
\r
535 AssertEquals("A#04", 0.0f, (float)d);
\r
537 d = new Decimal(1.0f);
\r
538 AssertEquals("A#05", 1m, (decimal)d);
\r
539 AssertEquals("A#06", 1.0f, (float)d);
\r
541 d = new Decimal(-1.2345678f);
\r
542 AssertEquals("A#07", -1.234568m, (decimal)d);
\r
543 AssertEquals("A#08", -1.234568f, (float)d);
\r
545 d = new Decimal(1.2345673f);
\r
546 AssertEquals("A#09", 1.234567m, (decimal)d);
\r
548 d = new Decimal(1.2345673e7f);
\r
549 AssertEquals("A#10", 12345670m, (decimal)d);
\r
551 d = new Decimal(1.2345673e-17f);
\r
552 AssertEquals("A#11", 0.00000000000000001234567m, (decimal)d);
\r
553 AssertEquals("A#12", 1.234567e-17f, (float)d);
\r
558 d = new Decimal(Single.MaxValue);
\r
561 catch (OverflowException)
\r
567 d = new Decimal(Single.NaN);
\r
570 catch (OverflowException)
\r
576 d = new Decimal(Single.PositiveInfinity);
\r
579 catch (OverflowException)
\r
584 public void TestConstructSingleRounding()
\r
588 d = new Decimal(1765.2356f);
\r
589 Assert(d == 1765.236m);
\r
591 d = new Decimal(1765.23554f);
\r
592 Assert("failed banker's rule rounding test 1", d == 1765.236m);
\r
594 d = new Decimal(1765.2354f);
\r
595 Assert(d == 1765.235m);
\r
597 d = new Decimal(1765.2346f);
\r
598 Assert(d == 1765.235m);
\r
600 d = new Decimal(1765.23454f);
\r
601 Assert("failed banker's rule rounding test 2", d == 1765.234m);
\r
603 d = new Decimal(1765.2344f);
\r
604 Assert(d == 1765.234m);
\r
606 d = new Decimal(0.00017652356f);
\r
607 Assert(d == 0.0001765236m);
\r
609 d = new Decimal(0.000176523554f);
\r
610 Assert("failed banker's rule rounding test 3", d == 0.0001765236m);
\r
612 d = new Decimal(0.00017652354f);
\r
613 Assert(d == 0.0001765235m);
\r
615 d = new Decimal(0.00017652346f);
\r
616 Assert(d == 0.0001765235m);
\r
618 d = new Decimal(0.000176523454f);
\r
619 Assert("failed banker's rule rounding test 4", d == 0.0001765234m);
\r
621 d = new Decimal(0.00017652344f);
\r
622 Assert(d == 0.0001765234m);
\r
624 d = new Decimal(3.7652356e10f);
\r
625 Assert(d == 37652360000m);
\r
627 d = new Decimal(3.7652356e20f);
\r
628 Assert(d == 376523600000000000000m);
\r
630 d = new Decimal(3.76523554e20f);
\r
631 Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);
\r
633 d = new Decimal(3.7652352e20f);
\r
634 Assert(d == 376523500000000000000m);
\r
636 d = new Decimal(3.7652348e20f);
\r
637 Assert(d == 376523500000000000000m);
\r
639 d = new Decimal(3.76523454e20f);
\r
640 Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);
\r
642 d = new Decimal(3.7652342e20f);
\r
643 Assert(d == 376523400000000000000m);
\r
646 public void TestConstructDouble()
\r
650 d = new Decimal(0.0);
\r
651 Assert((decimal)d == 0m);
\r
653 d = new Decimal(1.0);
\r
654 Assert((decimal)d == 1m);
\r
655 Assert(1.0 == (double)d);
\r
657 d = new Decimal(-1.2345678901234);
\r
658 Assert((decimal)d == -1.2345678901234m);
\r
659 Assert(-1.2345678901234 == (double)d);
\r
661 d = new Decimal(1.2345678901234);
\r
662 Assert((decimal)d == 1.2345678901234m);
\r
664 d = new Decimal(1.2345678901234e8);
\r
665 Assert((decimal)d == 123456789.01234m);
\r
666 Assert(1.2345678901234e8 == (double)d);
\r
668 d = new Decimal(1.2345678901234e16);
\r
669 Assert((decimal)d == 12345678901234000m);
\r
670 Assert(1.2345678901234e16 == (double)d);
\r
672 d = new Decimal(1.2345678901234e24);
\r
673 Assert((decimal)d == 1234567890123400000000000m);
\r
674 Assert(1.2345678901234e24 == (double)d);
\r
676 d = new Decimal(1.2345678901234e28);
\r
677 Assert((decimal)d == 1.2345678901234e28m);
\r
678 Assert(1.2345678901234e28 == (double)d);
\r
680 d = new Decimal(7.2345678901234e28);
\r
681 Assert((decimal)d == 7.2345678901234e28m);
\r
682 Assert(new Decimal((double)d) == d);
\r
684 d = new Decimal(1.2345678901234e-8);
\r
685 Assert((decimal)d == 1.2345678901234e-8m);
\r
687 d = new Decimal(1.2345678901234e-14);
\r
688 Assert((decimal)d == 1.2345678901234e-14m);
\r
689 Assert(1.2345678901234e-14 == (double)d);
\r
691 d = new Decimal(1.2342278901234e-25);
\r
692 Assert((decimal)d == 1.234e-25m);
\r
697 d = new Decimal(8e28);
\r
700 catch (OverflowException)
\r
706 d = new Decimal(8e48);
\r
709 catch (OverflowException)
\r
715 d = new Decimal(Double.NaN);
\r
718 catch (OverflowException)
\r
724 d = new Decimal(Double.PositiveInfinity);
\r
727 catch (OverflowException)
\r
732 public void TestConstructDoubleRound()
\r
736 d = new Decimal(1765.231234567857);
\r
737 Assert(d == 1765.23123456786m);
\r
739 d = new Decimal(1765.2312345678554);
\r
740 Assert("failed banker's rule rounding test 1", d == 1765.23123456786m);
\r
741 Assert(1765.23123456786 == (double)d);
\r
743 d = new Decimal(1765.231234567853);
\r
744 Assert(d == 1765.23123456785m);
\r
746 d = new Decimal(1765.231234567847);
\r
747 Assert(d == 1765.23123456785m);
\r
749 d = new Decimal(1765.231234567843);
\r
750 Assert(d == 1765.23123456784m);
\r
752 d = new Decimal(1.765231234567857e-9);
\r
753 Assert(d == 1.76523123456786e-9m);
\r
755 d = new Decimal(1.7652312345678554e-9);
\r
756 Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);
\r
758 d = new Decimal(1.765231234567853e-9);
\r
759 Assert(d == 1.76523123456785e-9m);
\r
761 d = new Decimal(1.765231234567857e+24);
\r
762 Assert(d == 1.76523123456786e+24m);
\r
764 d = new Decimal(1.7652312345678554e+24);
\r
765 Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);
\r
767 d = new Decimal(1.765231234567853e+24);
\r
768 Assert(d == 1.76523123456785e+24m);
\r
770 d = new Decimal(1765.2312345678454);
\r
771 Assert(d == 1765.23123456785m);
\r
774 public void TestNegate()
\r
778 d = new Decimal(12345678);
\r
779 Assert((decimal)Decimal.Negate(d) == -12345678m);
\r
782 public void TestPartConstruct()
\r
786 d = new Decimal(parts0);
\r
789 d = new Decimal(parts1);
\r
792 d = new Decimal(parts2);
\r
793 Assert(d == 4294967296m);
\r
795 d = new Decimal(parts3);
\r
796 Assert(d == 18446744073709551616m);
\r
798 d = new Decimal(parts4);
\r
801 d = new Decimal(parts5);
\r
802 Assert(d == 18446744078004518913m);
\r
804 d = new Decimal(partsMaxValue);
\r
805 Assert(d == Decimal.MaxValue);
\r
807 d = new Decimal(partsMinValue);
\r
808 Assert(d == Decimal.MinValue);
\r
810 d = new Decimal(parts6);
\r
811 int[] erg = Decimal.GetBits(d);
\r
812 for (int i = 0; i < 4; i++)
\r
814 Assert(erg[i] == parts6[i]);
\r
818 public void TestFloorTruncate()
\r
820 decimal[,] dtab = {
\r
821 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
\r
822 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
\r
823 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
\r
824 {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},
\r
825 {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},
\r
826 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
\r
827 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
\r
832 for (int i = 0; i < dtab.GetLength(0); i++)
\r
834 d = Decimal.Floor(dtab[i,0]);
\r
835 if (d != dtab[i,1])
\r
837 Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);
\r
839 d = Decimal.Truncate(dtab[i,0]);
\r
840 if (d != dtab[i,2])
\r
842 Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);
\r
847 public void TestRound()
\r
849 decimal[,] dtab = {
\r
850 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
\r
851 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
\r
852 {1.2345m, 3, 1.234m}, {1.2355m, 3, 1.236m},
\r
853 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
\r
854 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
\r
855 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
\r
856 {-47893764694.4578m, 5, -47893764694.4578m}
\r
861 for (int i = 0; i < dtab.GetLength(0); i++)
\r
863 d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);
\r
864 if (d != dtab[i,2])
\r
866 Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
\r