1 // DecimalTest.cs - NUnit Test Cases for the System.Decimal struct
4 // Martin Weindel (martin.weindel@t-online.de)
5 // Sebastien Pouliot <sebastien@ximian.com>
7 // (C) Martin Weindel, 2001
8 // Copyright (C) 2004 Novell (http://www.novell.com)
11 using NUnit.Framework;
14 using System.Globalization;
15 using System.Runtime.CompilerServices;
16 using System.Threading;
18 namespace MonoTests.System
20 internal struct ParseTest
22 public ParseTest (String str, bool exceptionFlag)
25 this.exceptionFlag = exceptionFlag;
26 this.style = NumberStyles.Number;
30 public ParseTest (String str, Decimal d)
33 this.exceptionFlag = false;
34 this.style = NumberStyles.Number;
38 public ParseTest (String str, Decimal d, NumberStyles style)
41 this.exceptionFlag = false;
48 public NumberStyles style;
49 public bool exceptionFlag;
52 internal struct ToStringTest
54 public ToStringTest (String format, Decimal d, String str)
67 public class DecimalTest : Assertion
69 private const int negativeBitValue = unchecked ((int) 0x80000000);
70 private const int negativeScale4Value = unchecked ((int) 0x80040000);
71 private int [] parts0 = { 0, 0, 0, 0 }; //Positive Zero.
72 private int [] parts1 = { 1, 0, 0, 0 };
73 private int [] parts2 = { 0, 1, 0, 0 };
74 private int [] parts3 = { 0, 0, 1, 0 };
75 private int [] parts4 = { 0, 0, 0, negativeBitValue }; // Negative zero.
76 private int [] parts5 = { 1, 1, 1, 0 };
77 private int [] partsMaxValue = { -1, -1, -1, 0 };
78 private int [] partsMinValue = { -1, -1, -1, negativeBitValue };
79 private int [] parts6 = { 1234, 5678, 8888, negativeScale4Value };
80 private NumberFormatInfo NfiUser;
82 private CultureInfo old_culture;
85 public void FixtureSetUp ()
87 old_culture = Thread.CurrentThread.CurrentCulture;
89 // Set culture to en-US and don't let the user override.
90 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
92 NfiUser = new NumberFormatInfo ();
93 NfiUser.CurrencyDecimalDigits = 3;
94 NfiUser.CurrencyDecimalSeparator = ",";
95 NfiUser.CurrencyGroupSeparator = "_";
96 NfiUser.CurrencyGroupSizes = new int [] { 2, 1, 0 };
97 NfiUser.CurrencyNegativePattern = 10;
98 NfiUser.CurrencyPositivePattern = 3;
99 NfiUser.CurrencySymbol = "XYZ";
100 NfiUser.NumberDecimalSeparator = "##";
101 NfiUser.NumberDecimalDigits = 4;
102 NfiUser.NumberGroupSeparator = "__";
103 NfiUser.NumberGroupSizes = new int [] { 2, 1 };
104 NfiUser.PercentDecimalDigits = 1;
105 NfiUser.PercentDecimalSeparator = ";";
106 NfiUser.PercentGroupSeparator = "~";
107 NfiUser.PercentGroupSizes = new int [] { 1 };
108 NfiUser.PercentNegativePattern = 2;
109 NfiUser.PercentPositivePattern = 2;
110 NfiUser.PercentSymbol = "%%%";
113 [TestFixtureTearDown]
114 public void FixtureTearDown ()
116 Thread.CurrentThread.CurrentCulture = old_culture;
120 public void TestToString ()
122 ToStringTest [] tab = {
123 new ToStringTest ("F", 12.345678m, "12.35"),
124 new ToStringTest ("F3", 12.345678m, "12.346"),
125 new ToStringTest ("F0", 12.345678m, "12"),
126 new ToStringTest ("F7", 12.345678m, "12.3456780"),
127 new ToStringTest ("g", 12.345678m, "12.345678"),
128 new ToStringTest ("E", 12.345678m, "1.234568E+001"),
129 new ToStringTest ("E3", 12.345678m, "1.235E+001"),
130 new ToStringTest ("E0", 12.345678m, "1E+001"),
131 new ToStringTest ("e8", 12.345678m, "1.23456780e+001"),
132 new ToStringTest ("F", 0.0012m, "0.00"),
133 new ToStringTest ("F3", 0.0012m, "0.001"),
134 new ToStringTest ("F0", 0.0012m, "0"),
135 new ToStringTest ("F6", 0.0012m, "0.001200"),
136 new ToStringTest ("e", 0.0012m, "1.200000e-003"),
137 new ToStringTest ("E3", 0.0012m, "1.200E-003"),
138 new ToStringTest ("E0", 0.0012m, "1E-003"),
139 new ToStringTest ("E6", 0.0012m, "1.200000E-003"),
140 new ToStringTest ("F4", -0.001234m, "-0.0012"),
141 new ToStringTest ("E3", -0.001234m, "-1.234E-003"),
143 new ToStringTest ("g", -0.000012m, "-1.2e-05"),
145 new ToStringTest ("g", -0.000012m, "-0.000012"),
147 new ToStringTest ("g", -0.00012m, "-0.00012"),
148 new ToStringTest ("g4", -0.00012m, "-0.00012"),
149 new ToStringTest ("g7", -0.00012m, "-0.00012"),
150 new ToStringTest ("g", -0.0001234m, "-0.0001234"),
151 new ToStringTest ("g", -0.0012m, "-0.0012"),
152 new ToStringTest ("g", -0.001234m, "-0.001234"),
153 new ToStringTest ("g", -0.012m, "-0.012"),
154 new ToStringTest ("g4", -0.012m, "-0.012"),
155 new ToStringTest ("g", -0.12m, "-0.12"),
156 new ToStringTest ("g", -1.2m, "-1.2"),
157 new ToStringTest ("g4", -120m, "-120"),
158 new ToStringTest ("g", -12m, "-12"),
159 new ToStringTest ("g", -120m, "-120"),
160 new ToStringTest ("g", -1200m, "-1200"),
161 new ToStringTest ("g4", -1200m, "-1200"),
162 new ToStringTest ("g", -1234m, "-1234"),
163 new ToStringTest ("g", -12000m, "-12000"),
164 new ToStringTest ("g4", -12000m, "-1.2e+04"),
165 new ToStringTest ("g5", -12000m, "-12000"),
166 new ToStringTest ("g", -12345m, "-12345"),
167 new ToStringTest ("g", -120000m, "-120000"),
168 new ToStringTest ("g4", -120000m, "-1.2e+05"),
169 new ToStringTest ("g5", -120000m, "-1.2e+05"),
170 new ToStringTest ("g6", -120000m, "-120000"),
171 new ToStringTest ("g", -123456.1m, "-123456.1"),
172 new ToStringTest ("g5", -123456.1m, "-1.2346e+05"),
173 new ToStringTest ("g6", -123456.1m, "-123456"),
174 new ToStringTest ("g", -1200000m, "-1200000"),
175 new ToStringTest ("g", -123456.1m, "-123456.1"),
176 new ToStringTest ("g", -123456.1m, "-123456.1"),
177 new ToStringTest ("g", -1234567.1m, "-1234567.1"),
178 new ToStringTest ("g", -12000000m, "-12000000"),
179 new ToStringTest ("g", -12345678.1m, "-12345678.1"),
180 new ToStringTest ("g", -12000000000000000000m, "-12000000000000000000"),
181 new ToStringTest ("F", -123, "-123.00"),
182 new ToStringTest ("F3", -123, "-123.000"),
183 new ToStringTest ("F0", -123, "-123"),
184 new ToStringTest ("E3", -123, "-1.230E+002"),
185 new ToStringTest ("E0", -123, "-1E+002"),
186 new ToStringTest ("E", -123, "-1.230000E+002"),
187 new ToStringTest ("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),
188 new ToStringTest ("F", Decimal.MinValue, "-79228162514264337593543950335.00"),
189 new ToStringTest ("F0", Decimal.MinValue, "-79228162514264337593543950335"),
190 new ToStringTest ("E", Decimal.MinValue, "-7.922816E+028"),
191 new ToStringTest ("E3", Decimal.MinValue, "-7.923E+028"),
192 new ToStringTest ("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),
193 #if !TARGET_JVM // TargetJvmNotWorking
194 new ToStringTest ("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),
196 new ToStringTest ("E0", Decimal.MinValue, "-8E+028"),
197 new ToStringTest ("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
198 new ToStringTest ("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
199 new ToStringTest ("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
200 new ToStringTest ("n3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
201 new ToStringTest ("n0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
202 new ToStringTest ("n", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
203 new ToStringTest ("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),
204 new ToStringTest ("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),
205 new ToStringTest ("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),
206 new ToStringTest ("P", 123456.7891m, "12,345,678.91 %"),
207 new ToStringTest ("P", -123456.7892m, "-12,345,678.92 %"),
208 new ToStringTest ("P3", 1234.56789m, "123,456.789 %"),
211 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
213 for (int i = 0; i < tab.Length; i++) {
215 string s = tab [i].d.ToString (tab [i].format, nfi);
216 AssertEquals ("A01 tab[" + i + "].format = '" + tab [i].format + "')", tab [i].str, s);
217 } catch (OverflowException) {
218 Fail (tab [i].d.ToString (tab [i].format, nfi) + " (format = '" + tab [i].format + "'): unexpected exception !");
219 } catch (NUnit.Framework.AssertionException e) {
221 } catch (Exception e) {
222 Fail ("Unexpected Exception when i = " + i + ". e = " + e);
228 public void TestCurrencyPattern ()
230 NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
231 Decimal d = -1234567.8976m;
232 string [] ergCurrencyNegativePattern = new String [16] {
233 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
234 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
235 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
236 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
239 for (int i = 0; i < ergCurrencyNegativePattern.Length; i++) {
240 nfi2.CurrencyNegativePattern = i;
241 if (d.ToString ("C", nfi2) != ergCurrencyNegativePattern [i]) {
242 Fail ("CurrencyNegativePattern #" + i + " failed: " +
243 d.ToString ("C", nfi2) + " != " + ergCurrencyNegativePattern [i]);
248 string [] ergCurrencyPositivePattern = new String [4] {
249 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
252 for (int i = 0; i < ergCurrencyPositivePattern.Length; i++) {
253 nfi2.CurrencyPositivePattern = i;
254 if (d.ToString ("C", nfi2) != ergCurrencyPositivePattern [i]) {
255 Fail ("CurrencyPositivePattern #" + i + " failed: " +
256 d.ToString ("C", nfi2) + " != " + ergCurrencyPositivePattern [i]);
262 public void TestNumberNegativePattern ()
264 NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
265 Decimal d = -1234.89765m;
266 string [] ergNumberNegativePattern = new String [5] {
267 "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",
270 for (int i = 0; i < ergNumberNegativePattern.Length; i++) {
271 nfi2.NumberNegativePattern = i;
272 AssertEquals ("NumberNegativePattern #" + i, ergNumberNegativePattern [i], d.ToString ("N", nfi2));
277 [Category ("TargetJvmNotWorking")]
278 public void TestPercentPattern ()
280 NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
281 Decimal d = -1234.8976m;
282 string [] ergPercentNegativePattern = new String [3] {
283 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
286 for (int i = 0; i < ergPercentNegativePattern.Length; i++) {
287 nfi2.PercentNegativePattern = i;
288 if (d.ToString ("P", nfi2) != ergPercentNegativePattern [i]) {
289 Fail ("PercentNegativePattern #" + i + " failed: " +
290 d.ToString ("P", nfi2) + " != " + ergPercentNegativePattern [i]);
295 string [] ergPercentPositivePattern = new String [3] {
296 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
299 for (int i = 0; i < ergPercentPositivePattern.Length; i++) {
300 nfi2.PercentPositivePattern = i;
301 if (d.ToString ("P", nfi2) != ergPercentPositivePattern [i]) {
302 Fail ("PercentPositivePattern #" + i + " failed: " +
303 d.ToString ("P", nfi2) + " != " + ergPercentPositivePattern [i]);
309 new ParseTest("1.2345", 1.2345m),
310 new ParseTest("-9876543210", -9876543210m),
311 new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol
312 + " ( 79,228,162,514,264,337,593,543,950,335.000 ) ",
313 Decimal.MinValue, NumberStyles.Currency),
314 new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),
315 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
316 new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),
317 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
318 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
319 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
320 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
321 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
322 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
326 [Category ("TargetJvmNotWorking")]
327 public void TestParse ()
331 for (int i = 0; i < tab.Length; i++) {
333 d = Decimal.Parse (tab [i].str, tab [i].style, NumberFormatInfo.InvariantInfo);
334 if (tab [i].exceptionFlag) {
335 Fail (tab [i].str + ": missing exception !");
336 } else if (d != tab [i].d) {
337 Fail (tab [i].str + " != " + d);
339 } catch (OverflowException) {
340 if (!tab [i].exceptionFlag) {
341 Fail (tab [i].str + ": unexpected exception !");
347 d = Decimal.Parse (null);
348 Fail ("Expected ArgumentNullException");
349 } catch (ArgumentNullException) {
354 d = Decimal.Parse ("123nx");
355 Fail ("Expected FormatException");
356 } catch (FormatException) {
361 d = Decimal.Parse ("79228162514264337593543950336");
362 Fail ("Expected OverflowException" + d);
363 } catch (OverflowException) {
369 public void TestConstants ()
371 AssertEquals ("Zero", 0m, Decimal.Zero);
372 AssertEquals ("One", 1m, Decimal.One);
373 AssertEquals ("MinusOne", -1m, Decimal.MinusOne);
374 AssertEquals ("MaxValue", 79228162514264337593543950335m, Decimal.MaxValue);
375 AssertEquals ("MinValue", -79228162514264337593543950335m, Decimal.MinValue);
376 Assert ("MinusOne 2", -1m == Decimal.MinusOne);
380 public void TestConstructInt32 ()
382 decimal [] dtab = { 0m, 1m, -1m, 123456m, -1234567m };
383 int [] itab = { 0, 1, -1, 123456, -1234567 };
387 for (int i = 0; i < dtab.GetLength (0); i++) {
388 d = new Decimal (itab [i]);
389 if ((decimal) d != dtab [i]) {
390 Fail ("Int32 -> Decimal: " + itab [i] + " != " + d);
394 Fail ("Decimal -> Int32: " + d + " != " + itab [i]);
399 d = new Decimal (Int32.MaxValue);
400 Assert ((int) d == Int32.MaxValue);
402 d = new Decimal (Int32.MinValue);
403 Assert ((int) d == Int32.MinValue);
407 public void TestConstructUInt32 ()
409 decimal [] dtab = { 0m, 1m, 123456m, 123456789m };
410 uint [] itab = { 0, 1, 123456, 123456789 };
414 for (int i = 0; i < dtab.GetLength (0); i++) {
415 d = new Decimal (itab [i]);
416 if ((decimal) d != dtab [i]) {
417 Fail ("UInt32 -> Decimal: " + itab [i] + " != " + d);
421 Fail ("Decimal -> UInt32: " + d + " != " + itab [i]);
426 d = new Decimal (UInt32.MaxValue);
427 Assert ((uint) d == UInt32.MaxValue);
429 d = new Decimal (UInt32.MinValue);
430 Assert ((uint) d == UInt32.MinValue);
434 public void TestConstructInt64 ()
436 decimal [] dtab = { 0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m };
437 long [] itab = { 0, 1, -1, 9876543, -9876543210L, 12345678987654321L };
441 for (int i = 0; i < dtab.GetLength (0); i++) {
442 d = new Decimal (itab [i]);
443 if ((decimal) d != dtab [i]) {
444 Fail ("Int64 -> Decimal: " + itab [i] + " != " + d);
448 Fail ("Decimal -> Int64: " + d + " != " + itab [i]);
453 d = new Decimal (Int64.MaxValue);
454 Assert ((long) d == Int64.MaxValue);
456 d = new Decimal (Int64.MinValue);
457 Assert ((long) d == Int64.MinValue);
461 public void TestConstructUInt64 ()
463 decimal [] dtab = { 0m, 1m, 987654321m, 123456789876543210m };
464 ulong [] itab = { 0, 1, 987654321, 123456789876543210L };
468 for (int i = 0; i < dtab.GetLength (0); i++) {
469 d = new Decimal (itab [i]);
470 if ((decimal) d != dtab [i]) {
471 Fail ("UInt64 -> Decimal: " + itab [i] + " != " + d);
475 Fail ("Decimal -> UInt64: " + d + " != " + itab [i]);
480 d = new Decimal (UInt64.MaxValue);
481 Assert ((ulong) d == UInt64.MaxValue);
483 d = new Decimal (UInt64.MinValue);
484 Assert ((ulong) d == UInt64.MinValue);
488 public void TestConstructSingle ()
492 d = new Decimal (-1.2345678f);
493 AssertEquals ("A#01", -1.234568m, (decimal) d);
496 AssertEquals ("A#02", 3.0f, (float) d);
498 d = new Decimal (0.0f);
499 AssertEquals ("A#03", 0m, (decimal) d);
500 AssertEquals ("A#04", 0.0f, (float) d);
502 d = new Decimal (1.0f);
503 AssertEquals ("A#05", 1m, (decimal) d);
504 AssertEquals ("A#06", 1.0f, (float) d);
506 d = new Decimal (-1.2345678f);
507 AssertEquals ("A#07", -1.234568m, (decimal) d);
508 AssertEquals ("A#08", -1.234568f, (float) d);
510 d = new Decimal (1.2345673f);
511 AssertEquals ("A#09", 1.234567m, (decimal) d);
513 d = new Decimal (1.2345673e7f);
514 AssertEquals ("A#10", 12345670m, (decimal) d);
516 d = new Decimal (1.2345673e-17f);
517 AssertEquals ("A#11", 0.00000000000000001234567m, (decimal) d);
518 AssertEquals ("A#12", 1.234567e-17f, (float) d);
522 d = new Decimal (Single.MaxValue);
524 } catch (OverflowException) {
528 d = new Decimal (Single.NaN);
530 } catch (OverflowException) {
534 d = new Decimal (Single.PositiveInfinity);
536 } catch (OverflowException) {
541 public void TestConstructSingleRounding_NowWorking ()
545 d = new Decimal (1765.23454f);
546 AssertEquals ("failed banker's rule rounding test 2", 1765.234m, d);
548 d = new Decimal (0.00017652356f);
549 AssertEquals ("06", 0.0001765236m, d);
551 d = new Decimal (0.000176523554f);
552 AssertEquals ("failed banker's rule rounding test 3", 0.0001765236m, d);
554 d = new Decimal (0.00017652354f);
555 AssertEquals ("08", 0.0001765235m, d);
557 d = new Decimal (0.00017652346f);
558 AssertEquals ("09", 0.0001765235m, d);
560 d = new Decimal (0.000176523454f);
561 AssertEquals ("failed banker's rule rounding test 4", 0.0001765234m, d);
563 d = new Decimal (0.00017652344f);
564 AssertEquals ("11", 0.0001765234m, d);
567 public void TestConstructSingleRounding ()
571 d = new Decimal (1765.2356f);
572 Assert ("01", d == 1765.236m);
574 d = new Decimal (1765.23554f);
575 Assert ("failed banker's rule rounding test 1", d == 1765.236m);
577 d = new Decimal (1765.2354f);
578 Assert ("03", d == 1765.235m);
580 d = new Decimal (1765.2346f);
581 Assert ("04", d == 1765.235m);
583 d = new Decimal (1765.2344f);
584 Assert ("05", d == 1765.234m);
586 d = new Decimal (3.7652356e10f);
587 Assert ("12", d == 37652360000m);
589 d = new Decimal (3.7652356e20f);
590 Assert ("13", d == 376523600000000000000m);
592 d = new Decimal (3.76523554e20f);
593 Assert ("failed banker's rule rounding test 5", d == 376523600000000000000m);
595 d = new Decimal (3.7652352e20f);
596 Assert ("15", d == 376523500000000000000m);
598 d = new Decimal (3.7652348e20f);
599 Assert ("16", d == 376523500000000000000m);
601 d = new Decimal (3.76523454e20f);
602 Assert ("failed banker's rule rounding test 6", d == 376523400000000000000m);
604 d = new Decimal (3.7652342e20f);
605 Assert ("18", d == 376523400000000000000m);
609 public void TestConstructDouble ()
613 d = new Decimal (0.0);
614 Assert ((decimal) d == 0m);
616 d = new Decimal (1.0);
617 Assert ((decimal) d == 1m);
618 Assert (1.0 == (double) d);
620 d = new Decimal (-1.2345678901234);
621 Assert ((decimal) d == -1.2345678901234m);
622 Assert (-1.2345678901234 == (double) d);
624 d = new Decimal (1.2345678901234);
625 Assert ((decimal) d == 1.2345678901234m);
627 d = new Decimal (1.2345678901234e8);
628 Assert ((decimal) d == 123456789.01234m);
629 Assert (1.2345678901234e8 == (double) d);
631 d = new Decimal (1.2345678901234e16);
632 Assert ((decimal) d == 12345678901234000m);
633 Assert (1.2345678901234e16 == (double) d);
635 d = new Decimal (1.2345678901234e24);
636 Assert ((decimal) d == 1234567890123400000000000m);
637 Assert (1.2345678901234e24 == (double) d);
639 d = new Decimal (1.2345678901234e28);
640 Assert ((decimal) d == 1.2345678901234e28m);
641 Assert (1.2345678901234e28 == (double) d);
643 d = new Decimal (7.2345678901234e28);
644 Assert ((decimal) d == 7.2345678901234e28m);
645 Assert (new Decimal ((double) d) == d);
647 d = new Decimal (1.2345678901234e-8);
648 Assert ((decimal) d == 1.2345678901234e-8m);
650 d = new Decimal (1.2345678901234e-14);
651 Assert ((decimal) d == 1.2345678901234e-14m);
652 Assert (1.2345678901234e-14 == (double) d);
654 d = new Decimal (1.2342278901234e-25);
655 AssertEquals ("A10", d, 1.234e-25m);
659 d = new Decimal (8e28);
661 } catch (OverflowException) {
665 d = new Decimal (8e48);
667 } catch (OverflowException) {
671 d = new Decimal (Double.NaN);
673 } catch (OverflowException) {
677 d = new Decimal (Double.PositiveInfinity);
679 } catch (OverflowException) {
684 public void TestConstructDoubleRound ()
690 d = new Decimal (1765.231234567857);
691 AssertEquals ("A01", 1765.23123456786m, d);
694 d = new Decimal (1765.2312345678554);
695 AssertEquals ("A02, failed banker's rule rounding test 1", 1765.23123456786m, d);
696 AssertEquals ("A03", 1765.23123456786, (double) d);
699 d = new Decimal (1765.231234567853);
700 Assert (d == 1765.23123456785m);
703 d = new Decimal (1765.231234567847);
704 Assert (d == 1765.23123456785m);
707 d = new Decimal (1765.231234567843);
708 Assert (d == 1765.23123456784m);
711 d = new Decimal (1.765231234567857e-9);
712 Assert (d == 1.76523123456786e-9m);
715 d = new Decimal (1.7652312345678554e-9);
716 Assert ("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);
719 d = new Decimal (1.765231234567853e-9);
720 Assert (d == 1.76523123456785e-9m);
723 d = new Decimal (1.765231234567857e+24);
724 Assert (d == 1.76523123456786e+24m);
727 d = new Decimal (1.7652312345678554e+24);
728 Assert ("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);
731 d = new Decimal (1.765231234567853e+24);
732 Assert (d == 1.76523123456785e+24m);
735 d = new Decimal (1765.2312345678454);
736 Assert (d == 1765.23123456785m);
737 } catch (Exception e) {
738 Fail ("At TestNum = " + TestNum + " unexpected exception. e = " + e);
743 public void TestNegate ()
747 d = new Decimal (12345678);
748 Assert ((decimal) Decimal.Negate (d) == -12345678m);
752 public void TestPartConstruct ()
756 d = new Decimal (parts0);
759 d = new Decimal (parts1);
762 d = new Decimal (parts2);
763 Assert (d == 4294967296m);
765 d = new Decimal (parts3);
766 Assert (d == 18446744073709551616m);
768 d = new Decimal (parts4);
771 d = new Decimal (parts5);
772 Assert (d == 18446744078004518913m);
774 d = new Decimal (partsMaxValue);
775 Assert (d == Decimal.MaxValue);
777 d = new Decimal (partsMinValue);
778 Assert (d == Decimal.MinValue);
780 d = new Decimal (parts6);
781 int [] erg = Decimal.GetBits (d);
782 for (int i = 0; i < 4; i++) {
783 Assert (erg [i] == parts6 [i]);
788 public void TestFloorTruncate ()
791 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
792 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
793 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
794 {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},
795 {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},
796 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
797 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
802 for (int i = 0; i < dtab.GetLength (0); i++) {
803 d = Decimal.Floor (dtab [i, 0]);
804 if (d != dtab [i, 1]) {
805 Fail ("Floor: Floor(" + dtab [i, 0] + ") != " + d);
807 d = Decimal.Truncate (dtab [i, 0]);
808 if (d != dtab [i, 2]) {
809 Fail ("Truncate: Truncate(" + dtab [i, 0] + ") != " + d);
815 public void Truncate ()
818 decimal dt = Decimal.Truncate (dd);
819 AssertEquals ("Original", 249.9m, dd);
820 AssertEquals ("Truncate", 249m, dt);
821 AssertEquals ("Cast-Byte", 249, (byte) dd);
822 AssertEquals ("Cast-Char", 249, (char) dd);
823 AssertEquals ("Cast-Int16", 249, (short) dd);
824 AssertEquals ("Cast-UInt16", 249, (ushort) dd);
825 AssertEquals ("Cast-Int32", 249, (int) dd);
826 AssertEquals ("Cast-UInt32", 249, (uint) dd);
827 AssertEquals ("Cast-Int64", 249, (long) dd);
828 AssertEquals ("Cast-UInt64", 249, (ulong) dd);
832 public void TestRound ()
835 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
836 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
837 {1.2355m, 3, 1.236m},
838 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
839 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
840 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
841 {-47893764694.4578m, 5, -47893764694.4578m}
846 for (int i = 0; i < dtab.GetLength (0); i++) {
847 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
848 if (d != dtab [i, 2]) {
849 Fail ("Round: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
855 public void TestRoundFailures ()
863 for (int i = 0; i < dtab.GetLength (0); i++) {
864 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
865 if (d != dtab [i, 2]) {
866 Fail ("FailRound: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
872 public void ParseInt64 ()
874 long max = Int64.MaxValue;
875 Decimal dmax = Decimal.Parse (max.ToString ());
876 AssertEquals ("Int64.MaxValue", Int64.MaxValue, Decimal.ToInt64 (dmax));
878 long min = Int64.MinValue;
879 Decimal dmin = Decimal.Parse (min.ToString ());
880 AssertEquals ("Int64.MinValue", Int64.MinValue, Decimal.ToInt64 (dmin));
883 dmax = Decimal.Parse (dmax.ToString ());
884 AssertEquals ("Int64.MaxValue+1.1", Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m));
887 dmin = Decimal.Parse (dmin.ToString ());
888 AssertEquals ("Int64.MinValue-1.1", Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m));
892 public void ToByte ()
895 AssertEquals ("Decimal.ToByte", 254, Decimal.ToByte (d));
896 AssertEquals ("Convert.ToByte", 255, Convert.ToByte (d));
897 AssertEquals ("IConvertible.ToByte", 255, (d as IConvertible).ToByte (null));
901 public void ToSByte ()
904 AssertEquals ("Decimal.ToSByte", 126, Decimal.ToSByte (d));
905 AssertEquals ("Convert.ToSByte", 127, Convert.ToSByte (d));
906 AssertEquals ("IConvertible.ToSByte", 127, (d as IConvertible).ToSByte (null));
908 AssertEquals ("-Decimal.ToSByte", -126, Decimal.ToSByte (d));
909 AssertEquals ("-Convert.ToSByte", -127, Convert.ToSByte (d));
910 AssertEquals ("-IConvertible.ToSByte", -127, (d as IConvertible).ToSByte (null));
914 public void ToInt16 ()
917 AssertEquals ("Decimal.ToInt16", 254, Decimal.ToInt16 (d));
918 AssertEquals ("Convert.ToInt16", 255, Convert.ToInt16 (d));
919 AssertEquals ("IConvertible.ToInt16", 255, (d as IConvertible).ToInt16 (null));
921 AssertEquals ("-Decimal.ToInt16", -254, Decimal.ToInt16 (d));
922 AssertEquals ("-Convert.ToInt16", -255, Convert.ToInt16 (d));
923 AssertEquals ("-IConvertible.ToInt16", -255, (d as IConvertible).ToInt16 (null));
927 public void ToUInt16 ()
930 AssertEquals ("Decimal.ToUInt16", 254, Decimal.ToUInt16 (d));
931 AssertEquals ("Convert.ToUInt16", 255, Convert.ToUInt16 (d));
932 AssertEquals ("IConvertible.ToUInt16", 255, (d as IConvertible).ToUInt16 (null));
936 public void ToInt32 ()
939 AssertEquals ("Decimal.ToInt32", 254, Decimal.ToInt32 (d));
940 AssertEquals ("Convert.ToInt32", 255, Convert.ToInt32 (d));
941 AssertEquals ("IConvertible.ToInt32", 255, (d as IConvertible).ToInt32 (null));
943 AssertEquals ("-Decimal.ToInt32", -254, Decimal.ToInt32 (d));
944 AssertEquals ("-Convert.ToInt32", -255, Convert.ToInt32 (d));
945 AssertEquals ("-IConvertible.ToInt32", -255, (d as IConvertible).ToInt32 (null));
949 public void ToUInt32 ()
952 AssertEquals ("Decimal.ToUInt32", 254, Decimal.ToUInt32 (d));
953 AssertEquals ("Convert.ToUInt32", 255, Convert.ToUInt32 (d));
954 AssertEquals ("IConvertible.ToUInt32", 255, (d as IConvertible).ToUInt32 (null));
958 public void ToInt64 ()
961 AssertEquals ("Decimal.ToInt64", 254, Decimal.ToInt64 (d));
962 AssertEquals ("Convert.ToInt64", 255, Convert.ToInt64 (d));
963 AssertEquals ("IConvertible.ToInt64", 255, (d as IConvertible).ToInt64 (null));
965 AssertEquals ("-Decimal.ToInt64", -254, Decimal.ToInt64 (d));
966 AssertEquals ("-Convert.ToInt64", -255, Convert.ToInt64 (d));
967 AssertEquals ("-IConvertible.ToInt64", -255, (d as IConvertible).ToInt64 (null));
971 [ExpectedException (typeof (OverflowException))]
972 public void ToInt64_TooBig ()
974 Decimal d = (Decimal) Int64.MaxValue;
976 long value = Decimal.ToInt64 (d);
980 [ExpectedException (typeof (OverflowException))]
981 public void ToInt64_TooSmall ()
983 Decimal d = (Decimal) Int64.MinValue;
985 long value = Decimal.ToInt64 (d);
989 public void ToUInt64 ()
992 AssertEquals ("Decimal.ToUInt64", 254, Decimal.ToUInt64 (d));
993 AssertEquals ("Convert.ToUInt64", 255, Convert.ToUInt64 (d));
994 AssertEquals ("IConvertible.ToUInt64", 255, (d as IConvertible).ToUInt64 (null));
998 public void ToSingle ()
1001 AssertEquals ("Decimal.ToSingle", 254.9f, Decimal.ToSingle (d));
1002 AssertEquals ("Convert.ToSingle", 254.9f, Convert.ToSingle (d));
1003 AssertEquals ("IConvertible.ToSingle", 254.9f, (d as IConvertible).ToSingle (null));
1005 AssertEquals ("-Decimal.ToSingle", -254.9f, Decimal.ToSingle (d));
1006 AssertEquals ("-Convert.ToSingle", -254.9f, Convert.ToSingle (d));
1007 AssertEquals ("-IConvertible.ToSingle", -254.9f, (d as IConvertible).ToSingle (null));
1011 public void ToDouble ()
1014 AssertEquals ("Decimal.ToDouble", 254.9d, Decimal.ToDouble (d));
1015 AssertEquals ("Convert.ToDouble", 254.9d, Convert.ToDouble (d));
1016 AssertEquals ("IConvertible.ToDouble", 254.9d, (d as IConvertible).ToDouble (null));
1018 AssertEquals ("-Decimal.ToDouble", -254.9d, Decimal.ToDouble (d));
1019 AssertEquals ("-Convert.ToDouble", -254.9d, Convert.ToDouble (d));
1020 AssertEquals ("-IConvertible.ToDouble", -254.9d, (d as IConvertible).ToDouble (null));
1024 public void ToString_Defaults ()
1027 // everything defaults to "G"
1028 string def = d.ToString ("G");
1029 AssertEquals ("ToString()", def, d.ToString ());
1030 AssertEquals ("ToString((IFormatProvider)null)", def, d.ToString ((IFormatProvider) null));
1031 AssertEquals ("ToString((string)null)", def, d.ToString ((string) null));
1032 AssertEquals ("ToString(empty)", def, d.ToString (String.Empty));
1033 AssertEquals ("ToString(null,null)", def, d.ToString (null, null));
1034 AssertEquals ("ToString(empty,null)", def, d.ToString (String.Empty, null));
1036 AssertEquals ("ToString()", "254.9", def);
1040 public void CastTruncRounding ()
1042 // casting truncs decimal value (not normal nor banker's rounding)
1043 AssertEquals ("254.9==254", 254, (long) (254.9m));
1044 AssertEquals ("-254.9=-254", -254, (long) (-254.9m));
1045 AssertEquals ("255.9==256", 255, (long) (255.9m));
1046 AssertEquals ("-255.9=-256", -255, (long) (-255.9m));
1050 public void ParseFractions ()
1052 decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);
1053 AssertEquals ("f1", 0.5234567890123454678901234568m, d1);
1054 decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);
1055 AssertEquals ("f2", 0.4921420654348652943463423146m, d2);
1059 [ExpectedException (typeof (OverflowException))]
1060 public void Parse_Int64_Overflow ()
1062 // Int64.MaxValue + 1 + small fraction to allow 30 digits
1063 // 123456789012345678901234567890
1064 decimal d = Decimal.Parse ("9223372036854775808.0000000009", CultureInfo.InvariantCulture);
1070 [Category ("TargetJvmNotWorking")]
1071 public void TryParse ()
1075 // These should return false
1076 AssertEquals (false, Decimal.TryParse ("79228162514264337593543950336", out r));
1077 AssertEquals (false, Decimal.TryParse ("123nx", NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1078 AssertEquals (false, Decimal.TryParse (null, NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1080 // These should pass
1081 for (int i = 0; i < tab.Length; i++) {
1082 AssertEquals (!tab [i].exceptionFlag,
1083 Decimal.TryParse (tab [i].str, tab [i].style,
1084 NumberFormatInfo.InvariantInfo, out r));
1090 [ExpectedException (typeof (DivideByZeroException))]
1091 public void Remainder_ByZero ()
1093 Decimal.Remainder (254.9m, 0m);
1097 public void Remainder ()
1099 decimal p1 = 254.9m;
1101 decimal n1 = -254.9m;
1102 decimal n2 = -12.1m;
1104 AssertEquals ("254.9 % 12.1", 0.8m, Decimal.Remainder (p1, p2));
1105 AssertEquals ("-254.9 % 12.1", -0.8m, Decimal.Remainder (n1, p2));
1106 AssertEquals ("254.9 % -12.1", 0.8m, Decimal.Remainder (p1, n2));
1107 AssertEquals ("-254.9 % -12.1", -0.8m, Decimal.Remainder (n1, n2));
1109 AssertEquals ("12.1 % 254.9", 12.1m, Decimal.Remainder (p2, p1));
1110 AssertEquals ("-12.1 % 254.9", -12.1m, Decimal.Remainder (n2, p1));
1111 AssertEquals ("12.1 % -254.9", 12.1m, Decimal.Remainder (p2, n1));
1112 AssertEquals ("-12.1 % -254.9", -12.1m, Decimal.Remainder (n2, n1));
1114 AssertEquals ("12.1 % 12.1", 0.0m, Decimal.Remainder (p1, p1));
1115 AssertEquals ("-12.1 % 12.1", 0.0m, Decimal.Remainder (n1, p1));
1116 AssertEquals ("12.1 % -12.1", 0.0m, Decimal.Remainder (p1, n1));
1117 AssertEquals ("-12.1 % -12.1", 0.0m, Decimal.Remainder (n1, n1));
1119 AssertEquals ("12.1 % 12.1", 0, Decimal.Remainder (p1, p1));
1120 AssertEquals ("-12.1 % 12.1", 0, Decimal.Remainder (n1, p1));
1121 AssertEquals ("12.1 % -12.1", 0, Decimal.Remainder (p1, n1));
1122 AssertEquals ("-12.1 % -12.1", 0, Decimal.Remainder (n1, n1));
1127 [ExpectedException (typeof (DivideByZeroException))]
1128 public void Divide_ByZero ()
1130 Decimal.Divide (254.9m, 0m);
1134 public void Divide ()
1136 decimal p1 = 254.9m;
1138 decimal n1 = -254.9m;
1139 decimal n2 = -12.1m;
1141 decimal c1 = 21.066115702479338842975206612m;
1142 decimal c2 = 0.0474695959199686151431934092m;
1144 AssertEquals ("254.9 / 12.1", c1, Decimal.Divide (p1, p2));
1145 AssertEquals ("-254.9 / 12.1", -c1, Decimal.Divide (n1, p2));
1146 AssertEquals ("254.9 / -12.1", -c1, Decimal.Divide (p1, n2));
1147 AssertEquals ("-254.9 / -12.1", c1, Decimal.Divide (n1, n2));
1149 AssertEquals ("12.1 / 254.9", c2, Decimal.Divide (p2, p1));
1150 AssertEquals ("-12.1 / 254.9", -c2, Decimal.Divide (n2, p1));
1151 AssertEquals ("12.1 / -254.9", -c2, Decimal.Divide (p2, n1));
1152 AssertEquals ("-12.1 / -254.9", c2, Decimal.Divide (n2, n1));
1154 AssertEquals ("12.1 / 12.1", 1, Decimal.Divide (p1, p1));
1155 AssertEquals ("-12.1 / 12.1", -1, Decimal.Divide (n1, p1));
1156 AssertEquals ("12.1 / -12.1", -1, Decimal.Divide (p1, n1));
1157 AssertEquals ("-12.1 / -12.1", 1, Decimal.Divide (n1, n1));
1161 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1162 public void Round_InvalidDecimals_Negative ()
1164 Decimal.Round (254.9m, -1);
1168 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1169 public void Round_InvalidDecimals_TooHigh ()
1171 Decimal.Round (254.9m, 29);
1175 public void Round_OddValue ()
1177 decimal five = 5.5555555555555555555555555555m;
1178 AssertEquals ("5,5_,00", 6, Decimal.Round (five, 0));
1179 AssertEquals ("5,5_,01", 5.6m, Decimal.Round (five, 1));
1180 AssertEquals ("5,5_,02", 5.56m, Decimal.Round (five, 2));
1181 AssertEquals ("5,5_,03", 5.556m, Decimal.Round (five, 3));
1182 AssertEquals ("5,5_,04", 5.5556m, Decimal.Round (five, 4));
1183 AssertEquals ("5,5_,05", 5.55556m, Decimal.Round (five, 5));
1184 AssertEquals ("5,5_,06", 5.555556m, Decimal.Round (five, 6));
1185 AssertEquals ("5,5_,07", 5.5555556m, Decimal.Round (five, 7));
1186 AssertEquals ("5,5_,08", 5.55555556m, Decimal.Round (five, 8));
1187 AssertEquals ("5,5_,09", 5.555555556m, Decimal.Round (five, 9));
1188 AssertEquals ("5,5_,10", 5.5555555556m, Decimal.Round (five, 10));
1189 AssertEquals ("5,5_,11", 5.55555555556m, Decimal.Round (five, 11));
1190 AssertEquals ("5,5_,12", 5.555555555556m, Decimal.Round (five, 12));
1191 AssertEquals ("5,5_,13", 5.5555555555556m, Decimal.Round (five, 13));
1192 AssertEquals ("5,5_,14", 5.55555555555556m, Decimal.Round (five, 14));
1193 AssertEquals ("5,5_,15", 5.555555555555556m, Decimal.Round (five, 15));
1194 AssertEquals ("5,5_,16", 5.5555555555555556m, Decimal.Round (five, 16));
1195 AssertEquals ("5,5_,17", 5.55555555555555556m, Decimal.Round (five, 17));
1196 AssertEquals ("5,5_,18", 5.555555555555555556m, Decimal.Round (five, 18));
1197 AssertEquals ("5,5_,19", 5.5555555555555555556m, Decimal.Round (five, 19));
1198 AssertEquals ("5,5_,20", 5.55555555555555555556m, Decimal.Round (five, 20));
1199 AssertEquals ("5,5_,21", 5.555555555555555555556m, Decimal.Round (five, 21));
1200 AssertEquals ("5,5_,22", 5.5555555555555555555556m, Decimal.Round (five, 22));
1201 AssertEquals ("5,5_,23", 5.55555555555555555555556m, Decimal.Round (five, 23));
1202 AssertEquals ("5,5_,24", 5.555555555555555555555556m, Decimal.Round (five, 24));
1203 AssertEquals ("5,5_,25", 5.5555555555555555555555556m, Decimal.Round (five, 25));
1204 AssertEquals ("5,5_,26", 5.55555555555555555555555556m, Decimal.Round (five, 26));
1205 AssertEquals ("5,5_,27", 5.555555555555555555555555556m, Decimal.Round (five, 27));
1206 AssertEquals ("5.5_,28", 5.5555555555555555555555555555m, Decimal.Round (five, 28));
1210 public void Round_EvenValue ()
1212 AssertEquals ("2,2_5,00", 2, Decimal.Round (2.5m, 0));
1213 AssertEquals ("2,2_5,01", 2.2m, Decimal.Round (2.25m, 1));
1214 AssertEquals ("2,2_5,02", 2.22m, Decimal.Round (2.225m, 2));
1215 AssertEquals ("2,2_5,03", 2.222m, Decimal.Round (2.2225m, 3));
1216 AssertEquals ("2,2_5,04", 2.2222m, Decimal.Round (2.22225m, 4));
1217 AssertEquals ("2,2_5,05", 2.22222m, Decimal.Round (2.222225m, 5));
1218 AssertEquals ("2,2_5,06", 2.222222m, Decimal.Round (2.2222225m, 6));
1219 AssertEquals ("2,2_5,07", 2.2222222m, Decimal.Round (2.22222225m, 7));
1220 AssertEquals ("2,2_5,08", 2.22222222m, Decimal.Round (2.222222225m, 8));
1221 AssertEquals ("2,2_5,09", 2.222222222m, Decimal.Round (2.2222222225m, 9));
1222 AssertEquals ("2,2_5,10", 2.2222222222m, Decimal.Round (2.22222222225m, 10));
1223 AssertEquals ("2,2_5,11", 2.22222222222m, Decimal.Round (2.222222222225m, 11));
1224 AssertEquals ("2,2_5,12", 2.222222222222m, Decimal.Round (2.2222222222225m, 12));
1225 AssertEquals ("2,2_5,13", 2.2222222222222m, Decimal.Round (2.22222222222225m, 13));
1226 AssertEquals ("2,2_5,14", 2.22222222222222m, Decimal.Round (2.222222222222225m, 14));
1227 AssertEquals ("2,2_5,15", 2.222222222222222m, Decimal.Round (2.2222222222222225m, 15));
1228 AssertEquals ("2,2_5,16", 2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16));
1229 AssertEquals ("2,2_5,17", 2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17));
1230 AssertEquals ("2,2_5,18", 2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18));
1231 AssertEquals ("2,2_5,19", 2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19));
1232 AssertEquals ("2,2_5,20", 2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20));
1233 AssertEquals ("2,2_5,21", 2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21));
1234 AssertEquals ("2,2_5,22", 2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22));
1235 AssertEquals ("2,2_5,23", 2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23));
1236 AssertEquals ("2,2_5,24", 2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24));
1237 AssertEquals ("2,2_5,25", 2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25));
1238 AssertEquals ("2,2_5,26", 2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26));
1239 AssertEquals ("2,2_5,27", 2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27));
1240 AssertEquals ("2,2_5,28", 2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28));
1244 public void Round_OddValue_Negative ()
1246 decimal five = -5.5555555555555555555555555555m;
1247 AssertEquals ("-5,5_,00", -6, Decimal.Round (five, 0));
1248 AssertEquals ("-5,5_,01", -5.6m, Decimal.Round (five, 1));
1249 AssertEquals ("-5,5_,02", -5.56m, Decimal.Round (five, 2));
1250 AssertEquals ("-5,5_,03", -5.556m, Decimal.Round (five, 3));
1251 AssertEquals ("-5,5_,04", -5.5556m, Decimal.Round (five, 4));
1252 AssertEquals ("-5,5_,05", -5.55556m, Decimal.Round (five, 5));
1253 AssertEquals ("-5,5_,06", -5.555556m, Decimal.Round (five, 6));
1254 AssertEquals ("-5,5_,07", -5.5555556m, Decimal.Round (five, 7));
1255 AssertEquals ("-5,5_,08", -5.55555556m, Decimal.Round (five, 8));
1256 AssertEquals ("-5,5_,09", -5.555555556m, Decimal.Round (five, 9));
1257 AssertEquals ("-5,5_,10", -5.5555555556m, Decimal.Round (five, 10));
1258 AssertEquals ("-5,5_,11", -5.55555555556m, Decimal.Round (five, 11));
1259 AssertEquals ("-5,5_,12", -5.555555555556m, Decimal.Round (five, 12));
1260 AssertEquals ("-5,5_,13", -5.5555555555556m, Decimal.Round (five, 13));
1261 AssertEquals ("-5,5_,14", -5.55555555555556m, Decimal.Round (five, 14));
1262 AssertEquals ("-5,5_,15", -5.555555555555556m, Decimal.Round (five, 15));
1263 AssertEquals ("-5,5_,16", -5.5555555555555556m, Decimal.Round (five, 16));
1264 AssertEquals ("-5,5_,17", -5.55555555555555556m, Decimal.Round (five, 17));
1265 AssertEquals ("-5,5_,18", -5.555555555555555556m, Decimal.Round (five, 18));
1266 AssertEquals ("-5,5_,19", -5.5555555555555555556m, Decimal.Round (five, 19));
1267 AssertEquals ("-5,5_,20", -5.55555555555555555556m, Decimal.Round (five, 20));
1268 AssertEquals ("-5,5_,21", -5.555555555555555555556m, Decimal.Round (five, 21));
1269 AssertEquals ("-5,5_,22", -5.5555555555555555555556m, Decimal.Round (five, 22));
1270 AssertEquals ("-5,5_,23", -5.55555555555555555555556m, Decimal.Round (five, 23));
1271 AssertEquals ("-5,5_,24", -5.555555555555555555555556m, Decimal.Round (five, 24));
1272 AssertEquals ("-5,5_,25", -5.5555555555555555555555556m, Decimal.Round (five, 25));
1273 AssertEquals ("-5,5_,26", -5.55555555555555555555555556m, Decimal.Round (five, 26));
1274 AssertEquals ("-5,5_,27", -5.555555555555555555555555556m, Decimal.Round (five, 27));
1275 AssertEquals ("-5.5_,28", -5.5555555555555555555555555555m, Decimal.Round (five, 28));
1279 public void Round_EvenValue_Negative ()
1281 AssertEquals ("-2,2_5,00", -2, Decimal.Round (-2.5m, 0));
1282 AssertEquals ("-2,2_5,01", -2.2m, Decimal.Round (-2.25m, 1));
1283 AssertEquals ("-2,2_5,02", -2.22m, Decimal.Round (-2.225m, 2));
1284 AssertEquals ("-2,2_5,03", -2.222m, Decimal.Round (-2.2225m, 3));
1285 AssertEquals ("-2,2_5,04", -2.2222m, Decimal.Round (-2.22225m, 4));
1286 AssertEquals ("-2,2_5,05", -2.22222m, Decimal.Round (-2.222225m, 5));
1287 AssertEquals ("-2,2_5,06", -2.222222m, Decimal.Round (-2.2222225m, 6));
1288 AssertEquals ("-2,2_5,07", -2.2222222m, Decimal.Round (-2.22222225m, 7));
1289 AssertEquals ("-2,2_5,08", -2.22222222m, Decimal.Round (-2.222222225m, 8));
1290 AssertEquals ("-2,2_5,09", -2.222222222m, Decimal.Round (-2.2222222225m, 9));
1291 AssertEquals ("-2,2_5,10", -2.2222222222m, Decimal.Round (-2.22222222225m, 10));
1292 AssertEquals ("-2,2_5,11", -2.22222222222m, Decimal.Round (-2.222222222225m, 11));
1293 AssertEquals ("-2,2_5,12", -2.222222222222m, Decimal.Round (-2.2222222222225m, 12));
1294 AssertEquals ("-2,2_5,13", -2.2222222222222m, Decimal.Round (-2.22222222222225m, 13));
1295 AssertEquals ("-2,2_5,14", -2.22222222222222m, Decimal.Round (-2.222222222222225m, 14));
1296 AssertEquals ("-2,2_5,15", -2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15));
1297 AssertEquals ("-2,2_5,16", -2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16));
1298 AssertEquals ("-2,2_5,17", -2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17));
1299 AssertEquals ("-2,2_5,18", -2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18));
1300 AssertEquals ("-2,2_5,19", -2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19));
1301 AssertEquals ("-2,2_5,20", -2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20));
1302 AssertEquals ("-2,2_5,21", -2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21));
1303 AssertEquals ("-2,2_5,22", -2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22));
1304 AssertEquals ("-2,2_5,23", -2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23));
1305 AssertEquals ("-2,2_5,24", -2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24));
1306 AssertEquals ("-2,2_5,25", -2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25));
1307 AssertEquals ("-2,2_5,26", -2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26));
1308 AssertEquals ("-2,2_5,27", -2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27));
1309 AssertEquals ("-2,2_5,28", -2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28));
1312 [Test] // bug #59425
1313 public void ParseAndKeepPrecision ()
1316 AssertEquals (value, value, Decimal.Parse (value).ToString ());
1318 for (int i = 0; i < 28; i++) {
1320 AssertEquals (i.ToString (), value, Decimal.Parse (value).ToString ());
1324 AssertEquals (value, value, Decimal.Parse (value).ToString ());
1326 for (int i = 0; i < 28; i++) {
1328 AssertEquals ("-" + i.ToString (), value, Decimal.Parse (value).ToString ());
1333 public void ToString_G ()
1335 AssertEquals ("00", "1.0", (1.0m).ToString ());
1336 AssertEquals ("01", "0.1", (0.1m).ToString ());
1337 AssertEquals ("02", "0.01", (0.01m).ToString ());
1338 AssertEquals ("03", "0.001", (0.001m).ToString ());
1339 AssertEquals ("04", "0.0001", (0.0001m).ToString ());
1340 AssertEquals ("05", "0.00001", (0.00001m).ToString ());
1341 AssertEquals ("06", "0.000001", (0.000001m).ToString ());
1342 AssertEquals ("07", "0.0000001", (0.0000001m).ToString ());
1343 AssertEquals ("08", "0.00000001", (0.00000001m).ToString ());
1344 AssertEquals ("09", "0.000000001", (0.000000001m).ToString ());
1345 AssertEquals ("10", "0.0000000001", (0.0000000001m).ToString ());
1346 AssertEquals ("11", "0.00000000001", (0.00000000001m).ToString ());
1347 AssertEquals ("12", "0.000000000001", (0.000000000001m).ToString ());
1348 AssertEquals ("13", "0.0000000000001", (0.0000000000001m).ToString ());
1349 AssertEquals ("14", "0.00000000000001", (0.00000000000001m).ToString ());
1350 AssertEquals ("15", "0.000000000000001", (0.000000000000001m).ToString ());
1351 AssertEquals ("16", "0.0000000000000001", (0.0000000000000001m).ToString ());
1352 AssertEquals ("17", "0.00000000000000001", (0.00000000000000001m).ToString ());
1353 AssertEquals ("18", "0.000000000000000001", (0.000000000000000001m).ToString ());
1354 AssertEquals ("19", "0.0000000000000000001", (0.0000000000000000001m).ToString ());
1355 AssertEquals ("20", "0.00000000000000000001", (0.00000000000000000001m).ToString ());
1356 AssertEquals ("21", "0.000000000000000000001", (0.000000000000000000001m).ToString ());
1357 AssertEquals ("22", "0.0000000000000000000001", (0.0000000000000000000001m).ToString ());
1358 AssertEquals ("23", "0.00000000000000000000001", (0.00000000000000000000001m).ToString ());
1359 AssertEquals ("24", "0.000000000000000000000001", (0.000000000000000000000001m).ToString ());
1360 AssertEquals ("25", "0.0000000000000000000000001", (0.0000000000000000000000001m).ToString ());
1361 AssertEquals ("26", "0.00000000000000000000000001", (0.00000000000000000000000001m).ToString ());
1362 AssertEquals ("27", "0.000000000000000000000000001", (0.000000000000000000000000001m).ToString ());
1363 AssertEquals ("28", "0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString ());