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
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, NfiBroken;
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 = "%%%";
112 NfiBroken = new NumberFormatInfo ();
113 NfiBroken.NumberDecimalSeparator = ".";
114 NfiBroken.NumberGroupSeparator = ".";
115 NfiBroken.CurrencyDecimalSeparator = ".";
116 NfiBroken.CurrencyGroupSeparator = ".";
119 [TestFixtureTearDown]
120 public void FixtureTearDown ()
122 Thread.CurrentThread.CurrentCulture = old_culture;
126 public void TestToString ()
128 ToStringTest [] tab = {
129 new ToStringTest ("F", 12.345678m, "12.35"),
130 new ToStringTest ("F3", 12.345678m, "12.346"),
131 new ToStringTest ("F0", 12.345678m, "12"),
132 new ToStringTest ("F7", 12.345678m, "12.3456780"),
133 new ToStringTest ("g", 12.345678m, "12.345678"),
134 new ToStringTest ("E", 12.345678m, "1.234568E+001"),
135 new ToStringTest ("E3", 12.345678m, "1.235E+001"),
136 new ToStringTest ("E0", 12.345678m, "1E+001"),
137 new ToStringTest ("e8", 12.345678m, "1.23456780e+001"),
138 new ToStringTest ("F", 0.0012m, "0.00"),
139 new ToStringTest ("F3", 0.0012m, "0.001"),
140 new ToStringTest ("F0", 0.0012m, "0"),
141 new ToStringTest ("F6", 0.0012m, "0.001200"),
142 new ToStringTest ("e", 0.0012m, "1.200000e-003"),
143 new ToStringTest ("E3", 0.0012m, "1.200E-003"),
144 new ToStringTest ("E0", 0.0012m, "1E-003"),
145 new ToStringTest ("E6", 0.0012m, "1.200000E-003"),
146 new ToStringTest ("F4", -0.001234m, "-0.0012"),
147 new ToStringTest ("E3", -0.001234m, "-1.234E-003"),
148 new ToStringTest ("g", -0.000012m, "-0.000012"),
149 new ToStringTest ("g0", -0.000012m, "-1.2e-05"),
150 new ToStringTest ("g2", -0.000012m, "-1.2e-05"),
151 new ToStringTest ("g20", -0.000012m, "-1.2e-05"),
152 new ToStringTest ("g", -0.00012m, "-0.00012"),
153 new ToStringTest ("g4", -0.00012m, "-0.00012"),
154 new ToStringTest ("g7", -0.00012m, "-0.00012"),
155 new ToStringTest ("g", -0.0001234m, "-0.0001234"),
156 new ToStringTest ("g", -0.0012m, "-0.0012"),
157 new ToStringTest ("g", -0.001234m, "-0.001234"),
158 new ToStringTest ("g", -0.012m, "-0.012"),
159 new ToStringTest ("g4", -0.012m, "-0.012"),
160 new ToStringTest ("g", -0.12m, "-0.12"),
161 new ToStringTest ("g", -1.2m, "-1.2"),
162 new ToStringTest ("g4", -120m, "-120"),
163 new ToStringTest ("g", -12.000m, "-12.000"),
164 new ToStringTest ("g0", -12.000m, "-12"),
165 new ToStringTest ("g6", -12.000m, "-12"),
166 new ToStringTest ("g", -12m, "-12"),
167 new ToStringTest ("g", -120m, "-120"),
168 new ToStringTest ("g", -1200m, "-1200"),
169 new ToStringTest ("g4", -1200m, "-1200"),
170 new ToStringTest ("g", -1234m, "-1234"),
171 new ToStringTest ("g", -12000m, "-12000"),
172 new ToStringTest ("g4", -12000m, "-1.2e+04"),
173 new ToStringTest ("g5", -12000m, "-12000"),
174 new ToStringTest ("g", -12345m, "-12345"),
175 new ToStringTest ("g", -120000m, "-120000"),
176 new ToStringTest ("g4", -120000m, "-1.2e+05"),
177 new ToStringTest ("g5", -120000m, "-1.2e+05"),
178 new ToStringTest ("g6", -120000m, "-120000"),
179 new ToStringTest ("g", -123456.1m, "-123456.1"),
180 new ToStringTest ("g5", -123456.1m, "-1.2346e+05"),
181 new ToStringTest ("g6", -123456.1m, "-123456"),
182 new ToStringTest ("g", -1200000m, "-1200000"),
183 new ToStringTest ("g", -123456.1m, "-123456.1"),
184 new ToStringTest ("g", -123456.1m, "-123456.1"),
185 new ToStringTest ("g", -1234567.1m, "-1234567.1"),
186 new ToStringTest ("g", -12000000m, "-12000000"),
187 new ToStringTest ("g", -12345678.1m, "-12345678.1"),
188 new ToStringTest ("g", -12000000000000000000m, "-12000000000000000000"),
189 new ToStringTest ("F", -123, "-123.00"),
190 new ToStringTest ("F3", -123, "-123.000"),
191 new ToStringTest ("F0", -123, "-123"),
192 new ToStringTest ("E3", -123, "-1.230E+002"),
193 new ToStringTest ("E0", -123, "-1E+002"),
194 new ToStringTest ("E", -123, "-1.230000E+002"),
195 new ToStringTest ("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),
196 new ToStringTest ("F", Decimal.MinValue, "-79228162514264337593543950335.00"),
197 new ToStringTest ("F0", Decimal.MinValue, "-79228162514264337593543950335"),
198 new ToStringTest ("E", Decimal.MinValue, "-7.922816E+028"),
199 new ToStringTest ("E3", Decimal.MinValue, "-7.923E+028"),
200 new ToStringTest ("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),
201 #if !TARGET_JVM // TargetJvmNotWorking
202 new ToStringTest ("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),
204 new ToStringTest ("E0", Decimal.MinValue, "-8E+028"),
205 new ToStringTest ("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
206 new ToStringTest ("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
207 new ToStringTest ("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
208 new ToStringTest ("n3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
209 new ToStringTest ("n0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
210 new ToStringTest ("n", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
211 new ToStringTest ("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),
212 new ToStringTest ("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),
213 new ToStringTest ("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),
214 new ToStringTest ("P", 123456.7891m, "12,345,678.91 %"),
215 new ToStringTest ("P", -123456.7892m, "-12,345,678.92 %"),
216 new ToStringTest ("P3", 1234.56789m, "123,456.789 %"),
219 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
221 for (int i = 0; i < tab.Length; i++) {
223 string s = tab [i].d.ToString (tab [i].format, nfi);
224 Assert.AreEqual (tab [i].str, s, "A01 tab[" + i + "].format = '" + tab [i].format + "')");
225 } catch (OverflowException) {
226 Assert.Fail (tab [i].d.ToString (tab [i].format, nfi) + " (format = '" + tab [i].format + "'): unexpected exception !");
227 } catch (NUnit.Framework.AssertionException e) {
229 } catch (Exception e) {
230 Assert.Fail ("Unexpected Exception when i = " + i + ". e = " + e);
236 public void TestCurrencyPattern ()
238 NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
239 Decimal d = -1234567.8976m;
240 string [] ergCurrencyNegativePattern = new String [16] {
241 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
242 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
243 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
244 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
247 for (int i = 0; i < ergCurrencyNegativePattern.Length; i++) {
248 nfi2.CurrencyNegativePattern = i;
249 if (d.ToString ("C", nfi2) != ergCurrencyNegativePattern [i]) {
250 Assert.Fail ("CurrencyNegativePattern #" + i + " failed: " +
251 d.ToString ("C", nfi2) + " != " + ergCurrencyNegativePattern [i]);
256 string [] ergCurrencyPositivePattern = new String [4] {
257 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
260 for (int i = 0; i < ergCurrencyPositivePattern.Length; i++) {
261 nfi2.CurrencyPositivePattern = i;
262 if (d.ToString ("C", nfi2) != ergCurrencyPositivePattern [i]) {
263 Assert.Fail ("CurrencyPositivePattern #" + i + " failed: " +
264 d.ToString ("C", nfi2) + " != " + ergCurrencyPositivePattern [i]);
270 public void TestNumberNegativePattern ()
272 NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
273 Decimal d = -1234.89765m;
274 string [] ergNumberNegativePattern = new String [5] {
275 "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",
278 for (int i = 0; i < ergNumberNegativePattern.Length; i++) {
279 nfi2.NumberNegativePattern = i;
280 Assert.AreEqual (ergNumberNegativePattern [i], d.ToString ("N", nfi2), "NumberNegativePattern #" + i);
285 public void TestBrokenNFI ()
287 Assert.AreEqual (5.3m, decimal.Parse ("5.3", NumberStyles.Number, NfiBroken), "Parsing with broken NFI");
291 [Category ("TargetJvmNotWorking")]
292 public void TestPercentPattern ()
294 NumberFormatInfo nfi2 = (NumberFormatInfo) NfiUser.Clone ();
295 Decimal d = -1234.8976m;
296 string [] ergPercentNegativePattern = new String [3] {
297 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
300 for (int i = 0; i < ergPercentNegativePattern.Length; i++) {
301 nfi2.PercentNegativePattern = i;
302 if (d.ToString ("P", nfi2) != ergPercentNegativePattern [i]) {
303 Assert.Fail ("PercentNegativePattern #" + i + " failed: " +
304 d.ToString ("P", nfi2) + " != " + ergPercentNegativePattern [i]);
309 string [] ergPercentPositivePattern = new String [3] {
310 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
313 for (int i = 0; i < ergPercentPositivePattern.Length; i++) {
314 nfi2.PercentPositivePattern = i;
315 if (d.ToString ("P", nfi2) != ergPercentPositivePattern [i]) {
316 Assert.Fail ("PercentPositivePattern #" + i + " failed: " +
317 d.ToString ("P", nfi2) + " != " + ergPercentPositivePattern [i]);
323 new ParseTest("1.2345", 1.2345m),
324 new ParseTest("1.2345\0", 1.2345m),
325 new ParseTest("1.2345\0\0\0\0", 1.2345m),
326 new ParseTest("-9876543210", -9876543210m),
327 new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol
328 + " ( 79,228,162,514,264,337,593,543,950,335.000 ) ",
329 Decimal.MinValue, NumberStyles.Currency),
330 new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),
331 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
332 new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),
333 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
334 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
335 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
336 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
337 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
338 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
342 [Category ("TargetJvmNotWorking")]
343 public void TestParse ()
347 for (int i = 0; i < tab.Length; i++) {
349 d = Decimal.Parse (tab [i].str, tab [i].style, NumberFormatInfo.InvariantInfo);
350 if (tab [i].exceptionFlag) {
351 Assert.Fail (tab [i].str + ": missing exception !");
352 } else if (d != tab [i].d) {
353 Assert.Fail (tab [i].str + " != " + d);
355 } catch (OverflowException) {
356 if (!tab [i].exceptionFlag) {
357 Assert.Fail (tab [i].str + ": unexpected exception !");
363 d = Decimal.Parse (null);
364 Assert.Fail ("Expected ArgumentNullException");
365 } catch (ArgumentNullException) {
370 d = Decimal.Parse ("123nx");
371 Assert.Fail ("Expected FormatException");
372 } catch (FormatException) {
377 d = Decimal.Parse ("79228162514264337593543950336");
378 Assert.Fail ("Expected OverflowException" + d);
379 } catch (OverflowException) {
384 d = Decimal.Parse ("5\05");
385 Assert.Fail ("Expected FormatException" + d);
386 } catch (FormatException) {
392 public void TestConstants ()
394 Assert.AreEqual (0m, Decimal.Zero, "Zero");
395 Assert.AreEqual (1m, Decimal.One, "One");
396 Assert.AreEqual (-1m, Decimal.MinusOne, "MinusOne");
397 Assert.AreEqual (79228162514264337593543950335m, Decimal.MaxValue, "MaxValue");
398 Assert.AreEqual (-79228162514264337593543950335m, Decimal.MinValue, "MinValue");
399 Assert.IsTrue (-1m == Decimal.MinusOne, "MinusOne 2");
403 public void TestConstructInt32 ()
405 decimal [] dtab = { 0m, 1m, -1m, 123456m, -1234567m };
406 int [] itab = { 0, 1, -1, 123456, -1234567 };
410 for (int i = 0; i < dtab.GetLength (0); i++) {
411 d = new Decimal (itab [i]);
412 if ((decimal) d != dtab [i]) {
413 Assert.Fail ("Int32 -> Decimal: " + itab [i] + " != " + d);
417 Assert.Fail ("Decimal -> Int32: " + d + " != " + itab [i]);
422 d = new Decimal (Int32.MaxValue);
423 Assert.IsTrue ((int) d == Int32.MaxValue);
425 d = new Decimal (Int32.MinValue);
426 Assert.IsTrue ((int) d == Int32.MinValue);
430 public void TestConstructUInt32 ()
432 decimal [] dtab = { 0m, 1m, 123456m, 123456789m };
433 uint [] itab = { 0, 1, 123456, 123456789 };
437 for (int i = 0; i < dtab.GetLength (0); i++) {
438 d = new Decimal (itab [i]);
439 if ((decimal) d != dtab [i]) {
440 Assert.Fail ("UInt32 -> Decimal: " + itab [i] + " != " + d);
444 Assert.Fail ("Decimal -> UInt32: " + d + " != " + itab [i]);
449 d = new Decimal (UInt32.MaxValue);
450 Assert.IsTrue ((uint) d == UInt32.MaxValue);
452 d = new Decimal (UInt32.MinValue);
453 Assert.IsTrue ((uint) d == UInt32.MinValue);
457 public void TestConstructInt64 ()
459 decimal [] dtab = { 0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m };
460 long [] itab = { 0, 1, -1, 9876543, -9876543210L, 12345678987654321L };
464 for (int i = 0; i < dtab.GetLength (0); i++) {
465 d = new Decimal (itab [i]);
466 if ((decimal) d != dtab [i]) {
467 Assert.Fail ("Int64 -> Decimal: " + itab [i] + " != " + d);
471 Assert.Fail ("Decimal -> Int64: " + d + " != " + itab [i]);
476 d = new Decimal (Int64.MaxValue);
477 Assert.IsTrue ((long) d == Int64.MaxValue);
479 d = new Decimal (Int64.MinValue);
480 Assert.IsTrue ((long) d == Int64.MinValue);
484 public void TestConstructUInt64 ()
486 decimal [] dtab = { 0m, 1m, 987654321m, 123456789876543210m };
487 ulong [] itab = { 0, 1, 987654321, 123456789876543210L };
491 for (int i = 0; i < dtab.GetLength (0); i++) {
492 d = new Decimal (itab [i]);
493 if ((decimal) d != dtab [i]) {
494 Assert.Fail ("UInt64 -> Decimal: " + itab [i] + " != " + d);
498 Assert.Fail ("Decimal -> UInt64: " + d + " != " + itab [i]);
503 d = new Decimal (UInt64.MaxValue);
504 Assert.IsTrue ((ulong) d == UInt64.MaxValue);
506 d = new Decimal (UInt64.MinValue);
507 Assert.IsTrue ((ulong) d == UInt64.MinValue);
511 public void TestConstructSingle ()
515 d = new Decimal (-1.2345678f);
516 Assert.AreEqual (-1.234568m, (decimal) d, "A#01");
519 Assert.AreEqual (3.0f, (float) d, "A#02");
521 d = new Decimal (0.0f);
522 Assert.AreEqual (0m, (decimal) d, "A#03");
523 Assert.AreEqual (0.0f, (float) d, "A#04");
525 d = new Decimal (1.0f);
526 Assert.AreEqual (1m, (decimal) d, "A#05");
527 Assert.AreEqual (1.0f, (float) d, "A#06");
529 d = new Decimal (-1.2345678f);
530 Assert.AreEqual (-1.234568m, (decimal) d, "A#07");
531 Assert.AreEqual (-1.234568f, (float) d, "A#08");
533 d = new Decimal (1.2345673f);
534 Assert.AreEqual (1.234567m, (decimal) d, "A#09");
536 d = new Decimal (1.2345673e7f);
537 Assert.AreEqual (12345670m, (decimal) d, "A#10");
539 d = new Decimal (1.2345673e-17f);
540 Assert.AreEqual (0.00000000000000001234567m, (decimal) d, "A#11");
541 Assert.AreEqual (1.234567e-17f, (float) d, "A#12");
545 d = new Decimal (Single.MaxValue);
547 } catch (OverflowException) {
551 d = new Decimal (Single.NaN);
553 } catch (OverflowException) {
557 d = new Decimal (Single.PositiveInfinity);
559 } catch (OverflowException) {
564 public void TestConstructSingleRounding_NowWorking ()
568 d = new Decimal (1765.23454f);
569 Assert.AreEqual (1765.234m, d, "failed banker's rule rounding test 2");
571 d = new Decimal (0.00017652356f);
572 Assert.AreEqual (0.0001765236m, d, "06");
574 d = new Decimal (0.000176523554f);
575 Assert.AreEqual (0.0001765236m, d, "failed banker's rule rounding test 3");
577 d = new Decimal (0.00017652354f);
578 Assert.AreEqual (0.0001765235m, d, "08");
580 d = new Decimal (0.00017652346f);
581 Assert.AreEqual (0.0001765235m, d, "09");
583 d = new Decimal (0.000176523454f);
584 Assert.AreEqual (0.0001765234m, d, "failed banker's rule rounding test 4");
586 d = new Decimal (0.00017652344f);
587 Assert.AreEqual (0.0001765234m, d, "11");
590 public void TestConstructSingleRounding ()
594 d = new Decimal (1765.2356f);
595 Assert.IsTrue (d == 1765.236m, "01");
597 d = new Decimal (1765.23554f);
598 Assert.IsTrue (d == 1765.236m, "failed banker's rule rounding test 1");
600 d = new Decimal (1765.2354f);
601 Assert.IsTrue (d == 1765.235m, "03");
603 d = new Decimal (1765.2346f);
604 Assert.IsTrue (d == 1765.235m, "04");
606 d = new Decimal (1765.2344f);
607 Assert.IsTrue (d == 1765.234m, "05");
609 d = new Decimal (3.7652356e10f);
610 Assert.IsTrue (d == 37652360000m, "12");
612 d = new Decimal (3.7652356e20f);
613 Assert.IsTrue (d == 376523600000000000000m, "13");
615 d = new Decimal (3.76523554e20f);
616 Assert.IsTrue (d == 376523600000000000000m, "failed banker's rule rounding test 5");
618 d = new Decimal (3.7652352e20f);
619 Assert.IsTrue (d == 376523500000000000000m, "15");
621 d = new Decimal (3.7652348e20f);
622 Assert.IsTrue (d == 376523500000000000000m, "16");
624 d = new Decimal (3.76523454e20f);
625 Assert.IsTrue (d == 376523400000000000000m, "failed banker's rule rounding test 6");
627 d = new Decimal (3.7652342e20f);
628 Assert.IsTrue (d == 376523400000000000000m, "18");
632 [SetCulture("en-US")]
633 public void TestConstructDouble ()
637 d = new Decimal (0.0);
638 Assert.IsTrue ((decimal) d == 0m);
640 d = new Decimal (1.0);
641 Assert.IsTrue ((decimal) d == 1m);
642 Assert.IsTrue (1.0 == (double) d);
644 d = new Decimal (-1.2345678901234);
645 Assert.IsTrue ((decimal) d == -1.2345678901234m);
646 Assert.IsTrue (-1.2345678901234 == (double) d);
648 d = new Decimal (1.2345678901234);
649 Assert.IsTrue ((decimal) d == 1.2345678901234m);
651 d = new Decimal (1.2345678901234e8);
652 Assert.IsTrue ((decimal) d == 123456789.01234m);
653 Assert.IsTrue (1.2345678901234e8 == (double) d);
655 d = new Decimal (1.2345678901234e16);
656 Assert.IsTrue ((decimal) d == 12345678901234000m);
657 Assert.IsTrue (1.2345678901234e16 == (double) d);
659 d = new Decimal (1.2345678901234e24);
660 Assert.IsTrue ((decimal) d == 1234567890123400000000000m);
661 Assert.IsTrue (1.2345678901234e24 == (double) d);
663 d = new Decimal (1.2345678901234e28);
664 Assert.IsTrue ((decimal) d == 1.2345678901234e28m);
665 Assert.IsTrue (1.2345678901234e28 == (double) d);
667 d = new Decimal (7.2345678901234e28);
668 Assert.IsTrue ((decimal) d == 7.2345678901234e28m);
669 Assert.IsTrue (new Decimal ((double) d) == d);
671 d = new Decimal (1.2345678901234e-8);
672 Assert.IsTrue ((decimal) d == 1.2345678901234e-8m);
674 d = new Decimal (1.2345678901234e-14);
675 Assert.IsTrue ((decimal) d == 1.2345678901234e-14m);
676 Assert.IsTrue (1.2345678901234e-14 == (double) d);
678 d = new Decimal (1.2342278901234e-25);
679 Assert.AreEqual (d, 1.234e-25m, "A10");
682 // Make sure that 0.6 is turned into
683 // the 96 bit value 6 with the magnitude set to
685 double mydouble = 0.6;
686 d = new Decimal (mydouble);
687 int [] bits = Decimal.GetBits (d);
688 Assert.AreEqual (bits [0], 6, "f1");
689 Assert.AreEqual (bits [1], 0, "f2");
690 Assert.AreEqual (bits [2], 0, "f3");
691 Assert.AreEqual (bits [3], 65536, "f4");
694 // Make sure that we properly parse this value
695 // this in particular exposes a bug in the
696 // unmanaged version which rounds to 1234 instead
697 // of 1235, here to make sure we do not regress
700 mydouble = 1.2345679329684657e-25;
701 d = new Decimal (mydouble);
702 Assert.AreEqual (d.ToString (), "0.0000000000000000000000001235", "f5");
706 d = new Decimal (8e28);
708 } catch (OverflowException) {
712 d = new Decimal (8e48);
714 } catch (OverflowException) {
718 d = new Decimal (Double.NaN);
720 } catch (OverflowException) {
724 d = new Decimal (Double.PositiveInfinity);
726 } catch (OverflowException) {
731 public void TestConstructDoubleRound ()
737 d = new Decimal (1765.231234567857);
738 Assert.AreEqual (1765.23123456786m, d, "A01");
741 d = new Decimal (1765.2312345678554);
742 Assert.AreEqual (1765.23123456786m, d, "A02, failed banker's rule rounding test 1");
743 Assert.AreEqual (1765.23123456786, (double) d, "A03");
746 d = new Decimal (1765.231234567853);
747 Assert.IsTrue (d == 1765.23123456785m);
750 d = new Decimal (1765.231234567847);
751 Assert.IsTrue (d == 1765.23123456785m);
754 d = new Decimal (1765.231234567843);
755 Assert.IsTrue (d == 1765.23123456784m);
758 d = new Decimal (1.765231234567857e-9);
759 Assert.IsTrue (d == 1.76523123456786e-9m);
762 d = new Decimal (1.7652312345678554e-9);
763 Assert.IsTrue (d == 1.76523123456786e-9m, "failed banker's rule rounding test 3");
766 d = new Decimal (1.765231234567853e-9);
767 Assert.IsTrue (d == 1.76523123456785e-9m);
770 d = new Decimal (1.765231234567857e+24);
771 Assert.IsTrue (d == 1.76523123456786e+24m);
774 d = new Decimal (1.7652312345678554e+24);
775 Assert.IsTrue (d == 1.76523123456786e+24m, "failed banker's rule rounding test 4");
778 d = new Decimal (1.765231234567853e+24);
779 Assert.IsTrue (d == 1.76523123456785e+24m);
782 d = new Decimal (1765.2312345678454);
783 Assert.IsTrue (d == 1765.23123456785m);
784 } catch (Exception e) {
785 Assert.Fail ("At TestNum = " + TestNum + " unexpected exception. e = " + e);
790 public void TestNegate ()
794 d = new Decimal (12345678);
795 Assert.IsTrue ((decimal) Decimal.Negate (d) == -12345678m);
799 public void TestPartConstruct ()
803 d = new Decimal (parts0);
804 Assert.IsTrue (d == 0);
806 d = new Decimal (parts1);
807 Assert.IsTrue (d == 1);
809 d = new Decimal (parts2);
810 Assert.IsTrue (d == 4294967296m);
812 d = new Decimal (parts3);
813 Assert.IsTrue (d == 18446744073709551616m);
815 d = new Decimal (parts4);
816 Assert.IsTrue (d == 0m);
818 d = new Decimal (parts5);
819 Assert.IsTrue (d == 18446744078004518913m);
821 d = new Decimal (partsMaxValue);
822 Assert.IsTrue (d == Decimal.MaxValue);
824 d = new Decimal (partsMinValue);
825 Assert.IsTrue (d == Decimal.MinValue);
827 d = new Decimal (parts6);
828 int [] erg = Decimal.GetBits (d);
829 for (int i = 0; i < 4; i++) {
830 Assert.IsTrue (erg [i] == parts6 [i]);
835 public void TestFloorTruncate ()
838 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
839 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
840 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
841 {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},
842 {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},
843 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
844 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
849 for (int i = 0; i < dtab.GetLength (0); i++) {
850 d = Decimal.Floor (dtab [i, 0]);
851 if (d != dtab [i, 1]) {
852 Assert.Fail ("Floor: Floor(" + dtab [i, 0] + ") != " + d);
854 d = Decimal.Truncate (dtab [i, 0]);
855 if (d != dtab [i, 2]) {
856 Assert.Fail ("Truncate: Truncate(" + dtab [i, 0] + ") != " + d);
862 public void Truncate ()
865 decimal dt = Decimal.Truncate (dd);
866 Assert.AreEqual (249.9m, dd, "Original");
867 Assert.AreEqual (249m, dt, "Truncate");
868 Assert.AreEqual (249, (byte) dd, "Cast-Byte");
869 Assert.AreEqual (249, (char) dd, "Cast-Char");
870 Assert.AreEqual (249, (short) dd, "Cast-Int16");
871 Assert.AreEqual (249, (ushort) dd, "Cast-UInt16");
872 Assert.AreEqual (249, (int) dd, "Cast-Int32");
873 Assert.AreEqual (249, (uint) dd, "Cast-UInt32");
874 Assert.AreEqual (249, (long) dd, "Cast-Int64");
875 Assert.AreEqual (249, (ulong) dd, "Cast-UInt64");
879 public void TestRound ()
882 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
883 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
884 {1.2355m, 3, 1.236m},
885 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
886 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
887 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
888 {-47893764694.4578m, 5, -47893764694.4578m}
893 for (int i = 0; i < dtab.GetLength (0); i++) {
894 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
895 if (d != dtab [i, 2]) {
896 Assert.Fail ("Round: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
902 public void TestRoundFailures ()
910 for (int i = 0; i < dtab.GetLength (0); i++) {
911 d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
912 if (d != dtab [i, 2]) {
913 Assert.Fail ("FailRound: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
919 public void ParseInt64 ()
921 long max = Int64.MaxValue;
922 Decimal dmax = Decimal.Parse (max.ToString ());
923 Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax), "Int64.MaxValue");
925 long min = Int64.MinValue;
926 Decimal dmin = Decimal.Parse (min.ToString ());
927 Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin), "Int64.MinValue");
930 dmax = Decimal.Parse (dmax.ToString ());
931 Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m), "Int64.MaxValue+1.1");
934 dmin = Decimal.Parse (dmin.ToString ());
935 Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m), "Int64.MinValue-1.1");
939 public void ToByte ()
942 Assert.AreEqual (254, Decimal.ToByte (d), "Decimal.ToByte");
943 Assert.AreEqual (255, Convert.ToByte (d), "Convert.ToByte");
944 Assert.AreEqual (255, (d as IConvertible).ToByte (null), "IConvertible.ToByte");
948 public void ToSByte ()
951 Assert.AreEqual (126, Decimal.ToSByte (d), "Decimal.ToSByte");
952 Assert.AreEqual (127, Convert.ToSByte (d), "Convert.ToSByte");
953 Assert.AreEqual (127, (d as IConvertible).ToSByte (null), "IConvertible.ToSByte");
955 Assert.AreEqual (-126, Decimal.ToSByte (d), "-Decimal.ToSByte");
956 Assert.AreEqual (-127, Convert.ToSByte (d), "-Convert.ToSByte");
957 Assert.AreEqual (-127, (d as IConvertible).ToSByte (null), "-IConvertible.ToSByte");
961 public void ToInt16 ()
964 Assert.AreEqual (254, Decimal.ToInt16 (d), "Decimal.ToInt16");
965 Assert.AreEqual (255, Convert.ToInt16 (d), "Convert.ToInt16");
966 Assert.AreEqual (255, (d as IConvertible).ToInt16 (null), "IConvertible.ToInt16");
968 Assert.AreEqual (-254, Decimal.ToInt16 (d), "-Decimal.ToInt16");
969 Assert.AreEqual (-255, Convert.ToInt16 (d), "-Convert.ToInt16");
970 Assert.AreEqual (-255, (d as IConvertible).ToInt16 (null), "-IConvertible.ToInt16");
974 public void ToUInt16 ()
977 Assert.AreEqual (254, Decimal.ToUInt16 (d), "Decimal.ToUInt16");
978 Assert.AreEqual (255, Convert.ToUInt16 (d), "Convert.ToUInt16");
979 Assert.AreEqual (255, (d as IConvertible).ToUInt16 (null), "IConvertible.ToUInt16");
983 public void ToInt32 ()
986 Assert.AreEqual (254, Decimal.ToInt32 (d), "Decimal.ToInt32");
987 Assert.AreEqual (255, Convert.ToInt32 (d), "Convert.ToInt32");
988 Assert.AreEqual (255, (d as IConvertible).ToInt32 (null), "IConvertible.ToInt32");
990 Assert.AreEqual (-254, Decimal.ToInt32 (d), "-Decimal.ToInt32");
991 Assert.AreEqual (-255, Convert.ToInt32 (d), "-Convert.ToInt32");
992 Assert.AreEqual (-255, (d as IConvertible).ToInt32 (null), "-IConvertible.ToInt32");
996 public void ToUInt32 ()
999 Assert.AreEqual (254, Decimal.ToUInt32 (d), "Decimal.ToUInt32");
1000 Assert.AreEqual (255, Convert.ToUInt32 (d), "Convert.ToUInt32");
1001 Assert.AreEqual (255, (d as IConvertible).ToUInt32 (null), "IConvertible.ToUInt32");
1005 public void ToInt64 ()
1008 Assert.AreEqual (254, Decimal.ToInt64 (d), "Decimal.ToInt64");
1009 Assert.AreEqual (255, Convert.ToInt64 (d), "Convert.ToInt64");
1010 Assert.AreEqual (255, (d as IConvertible).ToInt64 (null), "IConvertible.ToInt64");
1012 Assert.AreEqual (-254, Decimal.ToInt64 (d), "-Decimal.ToInt64");
1013 Assert.AreEqual (-255, Convert.ToInt64 (d), "-Convert.ToInt64");
1014 Assert.AreEqual (-255, (d as IConvertible).ToInt64 (null), "-IConvertible.ToInt64");
1018 [ExpectedException (typeof (OverflowException))]
1019 public void ToInt64_TooBig ()
1021 Decimal d = (Decimal) Int64.MaxValue;
1023 long value = Decimal.ToInt64 (d);
1027 [ExpectedException (typeof (OverflowException))]
1028 public void ToInt64_TooSmall ()
1030 Decimal d = (Decimal) Int64.MinValue;
1032 long value = Decimal.ToInt64 (d);
1036 public void ToUInt64 ()
1039 Assert.AreEqual (254, Decimal.ToUInt64 (d), "Decimal.ToUInt64");
1040 Assert.AreEqual (255, Convert.ToUInt64 (d), "Convert.ToUInt64");
1041 Assert.AreEqual (255, (d as IConvertible).ToUInt64 (null), "IConvertible.ToUInt64");
1045 public void ToSingle ()
1048 Assert.AreEqual (254.9f, Decimal.ToSingle (d), "Decimal.ToSingle");
1049 Assert.AreEqual (254.9f, Convert.ToSingle (d), "Convert.ToSingle");
1050 Assert.AreEqual (254.9f, (d as IConvertible).ToSingle (null), "IConvertible.ToSingle");
1052 Assert.AreEqual (-254.9f, Decimal.ToSingle (d), "-Decimal.ToSingle");
1053 Assert.AreEqual (-254.9f, Convert.ToSingle (d), "-Convert.ToSingle");
1054 Assert.AreEqual (-254.9f, (d as IConvertible).ToSingle (null), "-IConvertible.ToSingle");
1058 public void ToDouble ()
1061 Assert.AreEqual (254.9d, Decimal.ToDouble (d), "Decimal.ToDouble");
1062 Assert.AreEqual (254.9d, Convert.ToDouble (d), "Convert.ToDouble");
1063 Assert.AreEqual (254.9d, (d as IConvertible).ToDouble (null), "IConvertible.ToDouble");
1065 Assert.AreEqual (-254.9d, Decimal.ToDouble (d), "-Decimal.ToDouble");
1066 Assert.AreEqual (-254.9d, Convert.ToDouble (d), "-Convert.ToDouble");
1067 Assert.AreEqual (-254.9d, (d as IConvertible).ToDouble (null), "-IConvertible.ToDouble");
1071 [SetCulture("en-US")]
1072 public void ToString_Defaults ()
1075 // everything defaults to "G"
1076 string def = d.ToString ("G");
1077 Assert.AreEqual (def, d.ToString (), "ToString()");
1078 Assert.AreEqual (def, d.ToString ((IFormatProvider) null), "ToString((IFormatProvider)null)");
1079 Assert.AreEqual (def, d.ToString ((string) null), "ToString((string)null)");
1080 Assert.AreEqual (def, d.ToString (String.Empty), "ToString(empty)");
1081 Assert.AreEqual (def, d.ToString (null, null), "ToString(null,null)");
1082 Assert.AreEqual (def, d.ToString (String.Empty, null), "ToString(empty,null)");
1084 Assert.AreEqual ("254.9", def, "ToString()");
1088 public void CastTruncRounding ()
1090 // casting truncs decimal value (not normal nor banker's rounding)
1091 Assert.AreEqual (254, (long) (254.9m), "254.9==254");
1092 Assert.AreEqual (-254, (long) (-254.9m), "-254.9=-254");
1093 Assert.AreEqual (255, (long) (255.9m), "255.9==256");
1094 Assert.AreEqual (-255, (long) (-255.9m), "-255.9=-256");
1098 public void ParseFractions ()
1100 decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);
1101 Assert.AreEqual (0.5234567890123454678901234568m, d1, "f1");
1102 decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);
1103 Assert.AreEqual (0.4921420654348652943463423146m, d2, "f2");
1107 [ExpectedException (typeof (OverflowException))]
1108 public void Parse_Int64_Overflow ()
1110 // Int64.MaxValue + 1 + small fraction to allow 30 digits
1111 // 123456789012345678901234567890
1112 decimal d = Decimal.Parse ("9223372036854775808.0000000009", CultureInfo.InvariantCulture);
1117 public void ParseEmptyNumberGroupSeparator ()
1119 CultureInfo originalCulture = CultureInfo.CurrentCulture;
1120 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
1122 var nf = new NumberFormatInfo ();
1123 nf.NumberDecimalSeparator = ".";
1124 nf.NumberGroupSeparator = "";
1125 decimal d = decimal.Parse ("4.5", nf);
1126 Assert.AreEqual (4.5, d);
1128 Thread.CurrentThread.CurrentCulture = originalCulture;
1133 [Category ("TargetJvmNotWorking")]
1134 public void TryParse ()
1138 // These should return false
1139 Assert.AreEqual (false, Decimal.TryParse ("79228162514264337593543950336", out r));
1140 Assert.AreEqual (false, Decimal.TryParse ("123nx", NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1141 Assert.AreEqual (false, Decimal.TryParse (null, NumberStyles.Number, CultureInfo.InvariantCulture, out r));
1143 // These should pass
1144 for (int i = 0; i < tab.Length; i++) {
1145 Assert.AreEqual (!tab [i].exceptionFlag,
1146 Decimal.TryParse (tab [i].str, tab [i].style,
1147 NumberFormatInfo.InvariantInfo, out r));
1152 [ExpectedException (typeof (DivideByZeroException))]
1153 public void Remainder_ByZero ()
1155 Decimal.Remainder (254.9m, 0m);
1159 public void Remainder ()
1161 decimal p1 = 254.9m;
1163 decimal n1 = -254.9m;
1164 decimal n2 = -12.1m;
1166 Assert.AreEqual (0.8m, Decimal.Remainder (p1, p2), "254.9 % 12.1");
1167 Assert.AreEqual (-0.8m, Decimal.Remainder (n1, p2), "-254.9 % 12.1");
1168 Assert.AreEqual (0.8m, Decimal.Remainder (p1, n2), "254.9 % -12.1");
1169 Assert.AreEqual (-0.8m, Decimal.Remainder (n1, n2), "-254.9 % -12.1");
1171 Assert.AreEqual (12.1m, Decimal.Remainder (p2, p1), "12.1 % 254.9");
1172 Assert.AreEqual (-12.1m, Decimal.Remainder (n2, p1), "-12.1 % 254.9");
1173 Assert.AreEqual (12.1m, Decimal.Remainder (p2, n1), "12.1 % -254.9");
1174 Assert.AreEqual (-12.1m, Decimal.Remainder (n2, n1), "-12.1 % -254.9");
1176 Assert.AreEqual (0.0m, Decimal.Remainder (p1, p1), "12.1 % 12.1");
1177 Assert.AreEqual (0.0m, Decimal.Remainder (n1, p1), "-12.1 % 12.1");
1178 Assert.AreEqual (0.0m, Decimal.Remainder (p1, n1), "12.1 % -12.1");
1179 Assert.AreEqual (0.0m, Decimal.Remainder (n1, n1), "-12.1 % -12.1");
1183 public void Remainder2 ()
1189 Assert.AreEqual (0.00m, a % c, "20.0M % 10.00M");
1194 [ExpectedException (typeof (DivideByZeroException))]
1195 public void Divide_ByZero ()
1197 Decimal.Divide (254.9m, 0m);
1201 public void Divide ()
1203 decimal p1 = 254.9m;
1205 decimal n1 = -254.9m;
1206 decimal n2 = -12.1m;
1208 decimal c1 = 21.066115702479338842975206612m;
1209 decimal c2 = 0.0474695959199686151431934092m;
1211 Assert.AreEqual (c1, Decimal.Divide (p1, p2), "254.9 / 12.1");
1212 Assert.AreEqual (-c1, Decimal.Divide (n1, p2), "-254.9 / 12.1");
1213 Assert.AreEqual (-c1, Decimal.Divide (p1, n2), "254.9 / -12.1");
1214 Assert.AreEqual (c1, Decimal.Divide (n1, n2), "-254.9 / -12.1");
1216 Assert.AreEqual (c2, Decimal.Divide (p2, p1), "12.1 / 254.9");
1217 Assert.AreEqual (-c2, Decimal.Divide (n2, p1), "-12.1 / 254.9");
1218 Assert.AreEqual (-c2, Decimal.Divide (p2, n1), "12.1 / -254.9");
1219 Assert.AreEqual (c2, Decimal.Divide (n2, n1), "-12.1 / -254.9");
1221 Assert.AreEqual (1, Decimal.Divide (p1, p1), "12.1 / 12.1");
1222 Assert.AreEqual (-1, Decimal.Divide (n1, p1), "-12.1 / 12.1");
1223 Assert.AreEqual (-1, Decimal.Divide (p1, n1), "12.1 / -12.1");
1224 Assert.AreEqual (1, Decimal.Divide (n1, n1), "-12.1 / -12.1");
1228 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1229 public void Round_InvalidDecimals_Negative ()
1231 Decimal.Round (254.9m, -1);
1235 [ExpectedException (typeof (ArgumentOutOfRangeException))]
1236 public void Round_InvalidDecimals_TooHigh ()
1238 Decimal.Round (254.9m, 29);
1242 public void Round_OddValue ()
1244 decimal five = 5.5555555555555555555555555555m;
1245 Assert.AreEqual (6, Decimal.Round (five, 0), "5,5_,00");
1246 Assert.AreEqual (5.6m, Decimal.Round (five, 1), "5,5_,01");
1247 Assert.AreEqual (5.56m, Decimal.Round (five, 2), "5,5_,02");
1248 Assert.AreEqual (5.556m, Decimal.Round (five, 3), "5,5_,03");
1249 Assert.AreEqual (5.5556m, Decimal.Round (five, 4), "5,5_,04");
1250 Assert.AreEqual (5.55556m, Decimal.Round (five, 5), "5,5_,05");
1251 Assert.AreEqual (5.555556m, Decimal.Round (five, 6), "5,5_,06");
1252 Assert.AreEqual (5.5555556m, Decimal.Round (five, 7), "5,5_,07");
1253 Assert.AreEqual (5.55555556m, Decimal.Round (five, 8), "5,5_,08");
1254 Assert.AreEqual (5.555555556m, Decimal.Round (five, 9), "5,5_,09");
1255 Assert.AreEqual (5.5555555556m, Decimal.Round (five, 10), "5,5_,10");
1256 Assert.AreEqual (5.55555555556m, Decimal.Round (five, 11), "5,5_,11");
1257 Assert.AreEqual (5.555555555556m, Decimal.Round (five, 12), "5,5_,12");
1258 Assert.AreEqual (5.5555555555556m, Decimal.Round (five, 13), "5,5_,13");
1259 Assert.AreEqual (5.55555555555556m, Decimal.Round (five, 14), "5,5_,14");
1260 Assert.AreEqual (5.555555555555556m, Decimal.Round (five, 15), "5,5_,15");
1261 Assert.AreEqual (5.5555555555555556m, Decimal.Round (five, 16), "5,5_,16");
1262 Assert.AreEqual (5.55555555555555556m, Decimal.Round (five, 17), "5,5_,17");
1263 Assert.AreEqual (5.555555555555555556m, Decimal.Round (five, 18), "5,5_,18");
1264 Assert.AreEqual (5.5555555555555555556m, Decimal.Round (five, 19), "5,5_,19");
1265 Assert.AreEqual (5.55555555555555555556m, Decimal.Round (five, 20), "5,5_,20");
1266 Assert.AreEqual (5.555555555555555555556m, Decimal.Round (five, 21), "5,5_,21");
1267 Assert.AreEqual (5.5555555555555555555556m, Decimal.Round (five, 22), "5,5_,22");
1268 Assert.AreEqual (5.55555555555555555555556m, Decimal.Round (five, 23), "5,5_,23");
1269 Assert.AreEqual (5.555555555555555555555556m, Decimal.Round (five, 24), "5,5_,24");
1270 Assert.AreEqual (5.5555555555555555555555556m, Decimal.Round (five, 25), "5,5_,25");
1271 Assert.AreEqual (5.55555555555555555555555556m, Decimal.Round (five, 26), "5,5_,26");
1272 Assert.AreEqual (5.555555555555555555555555556m, Decimal.Round (five, 27), "5,5_,27");
1273 Assert.AreEqual (5.5555555555555555555555555555m, Decimal.Round (five, 28), "5.5_,28");
1277 public void Round_EvenValue ()
1279 Assert.AreEqual (2, Decimal.Round (2.5m, 0), "2,2_5,00");
1280 Assert.AreEqual (2.2m, Decimal.Round (2.25m, 1), "2,2_5,01");
1281 Assert.AreEqual (2.22m, Decimal.Round (2.225m, 2), "2,2_5,02");
1282 Assert.AreEqual (2.222m, Decimal.Round (2.2225m, 3), "2,2_5,03");
1283 Assert.AreEqual (2.2222m, Decimal.Round (2.22225m, 4), "2,2_5,04");
1284 Assert.AreEqual (2.22222m, Decimal.Round (2.222225m, 5), "2,2_5,05");
1285 Assert.AreEqual (2.222222m, Decimal.Round (2.2222225m, 6), "2,2_5,06");
1286 Assert.AreEqual (2.2222222m, Decimal.Round (2.22222225m, 7), "2,2_5,07");
1287 Assert.AreEqual (2.22222222m, Decimal.Round (2.222222225m, 8), "2,2_5,08");
1288 Assert.AreEqual (2.222222222m, Decimal.Round (2.2222222225m, 9), "2,2_5,09");
1289 Assert.AreEqual (2.2222222222m, Decimal.Round (2.22222222225m, 10), "2,2_5,10");
1290 Assert.AreEqual (2.22222222222m, Decimal.Round (2.222222222225m, 11), "2,2_5,11");
1291 Assert.AreEqual (2.222222222222m, Decimal.Round (2.2222222222225m, 12), "2,2_5,12");
1292 Assert.AreEqual (2.2222222222222m, Decimal.Round (2.22222222222225m, 13), "2,2_5,13");
1293 Assert.AreEqual (2.22222222222222m, Decimal.Round (2.222222222222225m, 14), "2,2_5,14");
1294 Assert.AreEqual (2.222222222222222m, Decimal.Round (2.2222222222222225m, 15), "2,2_5,15");
1295 Assert.AreEqual (2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16), "2,2_5,16");
1296 Assert.AreEqual (2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17), "2,2_5,17");
1297 Assert.AreEqual (2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18), "2,2_5,18");
1298 Assert.AreEqual (2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19), "2,2_5,19");
1299 Assert.AreEqual (2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20), "2,2_5,20");
1300 Assert.AreEqual (2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21), "2,2_5,21");
1301 Assert.AreEqual (2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22), "2,2_5,22");
1302 Assert.AreEqual (2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23), "2,2_5,23");
1303 Assert.AreEqual (2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24), "2,2_5,24");
1304 Assert.AreEqual (2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25), "2,2_5,25");
1305 Assert.AreEqual (2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26), "2,2_5,26");
1306 Assert.AreEqual (2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27), "2,2_5,27");
1307 Assert.AreEqual (2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28), "2,2_5,28");
1311 public void Round_OddValue_Negative ()
1313 decimal five = -5.5555555555555555555555555555m;
1314 Assert.AreEqual (-6, Decimal.Round (five, 0), "-5,5_,00");
1315 Assert.AreEqual (-5.6m, Decimal.Round (five, 1), "-5,5_,01");
1316 Assert.AreEqual (-5.56m, Decimal.Round (five, 2), "-5,5_,02");
1317 Assert.AreEqual (-5.556m, Decimal.Round (five, 3), "-5,5_,03");
1318 Assert.AreEqual (-5.5556m, Decimal.Round (five, 4), "-5,5_,04");
1319 Assert.AreEqual (-5.55556m, Decimal.Round (five, 5), "-5,5_,05");
1320 Assert.AreEqual (-5.555556m, Decimal.Round (five, 6), "-5,5_,06");
1321 Assert.AreEqual (-5.5555556m, Decimal.Round (five, 7), "-5,5_,07");
1322 Assert.AreEqual (-5.55555556m, Decimal.Round (five, 8), "-5,5_,08");
1323 Assert.AreEqual (-5.555555556m, Decimal.Round (five, 9), "-5,5_,09");
1324 Assert.AreEqual (-5.5555555556m, Decimal.Round (five, 10), "-5,5_,10");
1325 Assert.AreEqual (-5.55555555556m, Decimal.Round (five, 11), "-5,5_,11");
1326 Assert.AreEqual (-5.555555555556m, Decimal.Round (five, 12), "-5,5_,12");
1327 Assert.AreEqual (-5.5555555555556m, Decimal.Round (five, 13), "-5,5_,13");
1328 Assert.AreEqual (-5.55555555555556m, Decimal.Round (five, 14), "-5,5_,14");
1329 Assert.AreEqual (-5.555555555555556m, Decimal.Round (five, 15), "-5,5_,15");
1330 Assert.AreEqual (-5.5555555555555556m, Decimal.Round (five, 16), "-5,5_,16");
1331 Assert.AreEqual (-5.55555555555555556m, Decimal.Round (five, 17), "-5,5_,17");
1332 Assert.AreEqual (-5.555555555555555556m, Decimal.Round (five, 18), "-5,5_,18");
1333 Assert.AreEqual (-5.5555555555555555556m, Decimal.Round (five, 19), "-5,5_,19");
1334 Assert.AreEqual (-5.55555555555555555556m, Decimal.Round (five, 20), "-5,5_,20");
1335 Assert.AreEqual (-5.555555555555555555556m, Decimal.Round (five, 21), "-5,5_,21");
1336 Assert.AreEqual (-5.5555555555555555555556m, Decimal.Round (five, 22), "-5,5_,22");
1337 Assert.AreEqual (-5.55555555555555555555556m, Decimal.Round (five, 23), "-5,5_,23");
1338 Assert.AreEqual (-5.555555555555555555555556m, Decimal.Round (five, 24), "-5,5_,24");
1339 Assert.AreEqual (-5.5555555555555555555555556m, Decimal.Round (five, 25), "-5,5_,25");
1340 Assert.AreEqual (-5.55555555555555555555555556m, Decimal.Round (five, 26), "-5,5_,26");
1341 Assert.AreEqual (-5.555555555555555555555555556m, Decimal.Round (five, 27), "-5,5_,27");
1342 Assert.AreEqual (-5.5555555555555555555555555555m, Decimal.Round (five, 28), "-5.5_,28");
1346 public void Round_EvenValue_Negative ()
1348 Assert.AreEqual (-2, Decimal.Round (-2.5m, 0), "-2,2_5,00");
1349 Assert.AreEqual (-2.2m, Decimal.Round (-2.25m, 1), "-2,2_5,01");
1350 Assert.AreEqual (-2.22m, Decimal.Round (-2.225m, 2), "-2,2_5,02");
1351 Assert.AreEqual (-2.222m, Decimal.Round (-2.2225m, 3), "-2,2_5,03");
1352 Assert.AreEqual (-2.2222m, Decimal.Round (-2.22225m, 4), "-2,2_5,04");
1353 Assert.AreEqual (-2.22222m, Decimal.Round (-2.222225m, 5), "-2,2_5,05");
1354 Assert.AreEqual (-2.222222m, Decimal.Round (-2.2222225m, 6), "-2,2_5,06");
1355 Assert.AreEqual (-2.2222222m, Decimal.Round (-2.22222225m, 7), "-2,2_5,07");
1356 Assert.AreEqual (-2.22222222m, Decimal.Round (-2.222222225m, 8), "-2,2_5,08");
1357 Assert.AreEqual (-2.222222222m, Decimal.Round (-2.2222222225m, 9), "-2,2_5,09");
1358 Assert.AreEqual (-2.2222222222m, Decimal.Round (-2.22222222225m, 10), "-2,2_5,10");
1359 Assert.AreEqual (-2.22222222222m, Decimal.Round (-2.222222222225m, 11), "-2,2_5,11");
1360 Assert.AreEqual (-2.222222222222m, Decimal.Round (-2.2222222222225m, 12), "-2,2_5,12");
1361 Assert.AreEqual (-2.2222222222222m, Decimal.Round (-2.22222222222225m, 13), "-2,2_5,13");
1362 Assert.AreEqual (-2.22222222222222m, Decimal.Round (-2.222222222222225m, 14), "-2,2_5,14");
1363 Assert.AreEqual (-2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15), "-2,2_5,15");
1364 Assert.AreEqual (-2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16), "-2,2_5,16");
1365 Assert.AreEqual (-2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17), "-2,2_5,17");
1366 Assert.AreEqual (-2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18), "-2,2_5,18");
1367 Assert.AreEqual (-2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19), "-2,2_5,19");
1368 Assert.AreEqual (-2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20), "-2,2_5,20");
1369 Assert.AreEqual (-2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21), "-2,2_5,21");
1370 Assert.AreEqual (-2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22), "-2,2_5,22");
1371 Assert.AreEqual (-2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23), "-2,2_5,23");
1372 Assert.AreEqual (-2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24), "-2,2_5,24");
1373 Assert.AreEqual (-2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25), "-2,2_5,25");
1374 Assert.AreEqual (-2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26), "-2,2_5,26");
1375 Assert.AreEqual (-2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27), "-2,2_5,27");
1376 Assert.AreEqual (-2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28), "-2,2_5,28");
1379 [Test] // bug #59425
1380 [SetCulture("en-US")]
1381 public void ParseAndKeepPrecision ()
1384 Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1386 for (int i = 0; i < 28; i++) {
1388 Assert.AreEqual (value, Decimal.Parse (value).ToString (), i.ToString ());
1392 Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
1394 for (int i = 0; i < 28; i++) {
1396 Assert.AreEqual (value, Decimal.Parse (value).ToString (), "-" + i.ToString ());
1401 [SetCulture("en-US")]
1402 public void ToString_G ()
1404 Assert.AreEqual ("1.0", (1.0m).ToString (), "00");
1405 Assert.AreEqual ("0.1", (0.1m).ToString (), "01");
1406 Assert.AreEqual ("0.01", (0.01m).ToString (), "02");
1407 Assert.AreEqual ("0.001", (0.001m).ToString (), "03");
1408 Assert.AreEqual ("0.0001", (0.0001m).ToString (), "04");
1409 Assert.AreEqual ("0.00001", (0.00001m).ToString (), "05");
1410 Assert.AreEqual ("0.000001", (0.000001m).ToString (), "06");
1411 Assert.AreEqual ("0.0000001", (0.0000001m).ToString (), "07");
1412 Assert.AreEqual ("0.00000001", (0.00000001m).ToString (), "08");
1413 Assert.AreEqual ("0.000000001", (0.000000001m).ToString (), "09");
1414 Assert.AreEqual ("0.0000000001", (0.0000000001m).ToString (), "10");
1415 Assert.AreEqual ("0.00000000001", (0.00000000001m).ToString (), "11");
1416 Assert.AreEqual ("0.000000000001", (0.000000000001m).ToString (), "12");
1417 Assert.AreEqual ("0.0000000000001", (0.0000000000001m).ToString (), "13");
1418 Assert.AreEqual ("0.00000000000001", (0.00000000000001m).ToString (), "14");
1419 Assert.AreEqual ("0.000000000000001", (0.000000000000001m).ToString (), "15");
1420 Assert.AreEqual ("0.0000000000000001", (0.0000000000000001m).ToString (), "16");
1421 Assert.AreEqual ("0.00000000000000001", (0.00000000000000001m).ToString (), "17");
1422 Assert.AreEqual ("0.000000000000000001", (0.000000000000000001m).ToString (), "18");
1423 Assert.AreEqual ("0.0000000000000000001", (0.0000000000000000001m).ToString (), "19");
1424 Assert.AreEqual ("0.00000000000000000001", (0.00000000000000000001m).ToString (), "20");
1425 Assert.AreEqual ("0.000000000000000000001", (0.000000000000000000001m).ToString (), "21");
1426 Assert.AreEqual ("0.0000000000000000000001", (0.0000000000000000000001m).ToString (), "22");
1427 Assert.AreEqual ("0.00000000000000000000001", (0.00000000000000000000001m).ToString (), "23");
1428 Assert.AreEqual ("0.000000000000000000000001", (0.000000000000000000000001m).ToString (), "24");
1429 Assert.AreEqual ("0.0000000000000000000000001", (0.0000000000000000000000001m).ToString (), "25");
1430 Assert.AreEqual ("0.00000000000000000000000001", (0.00000000000000000000000001m).ToString (), "26");
1431 Assert.AreEqual ("0.000000000000000000000000001", (0.000000000000000000000000001m).ToString (), "27");
1432 Assert.AreEqual ("0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString (), "28");
1436 public void MidpointRoundingAwayFromZero ()
1438 MidpointRounding m = MidpointRounding.AwayFromZero;
1439 Assert.AreEqual (4, Math.Round (3.5M, m), "#1");
1440 Assert.AreEqual (3, Math.Round (2.8M, m), "#2");
1441 Assert.AreEqual (3, Math.Round (2.5M, m), "#3");
1442 Assert.AreEqual (2, Math.Round (2.1M, m), "#4");
1443 Assert.AreEqual (-2, Math.Round (-2.1M, m), "#5");
1444 Assert.AreEqual (-3, Math.Round (-2.5M, m), "#6");
1445 Assert.AreEqual (-3, Math.Round (-2.8M, m), "#7");
1446 Assert.AreEqual (-4, Math.Round (-3.5M, m), "#8");
1448 Assert.AreEqual (3.1M, Math.Round (3.05M, 1, m), "#9");
1449 Assert.AreEqual (2.1M, Math.Round (2.08M, 1, m), "#10");
1450 Assert.AreEqual (2.1M, Math.Round (2.05M, 1, m), "#11");
1451 Assert.AreEqual (2.0M, Math.Round (2.01M, 1, m), "#12");
1452 Assert.AreEqual (-2.0M, Math.Round (-2.01M, 1, m), "#13");
1453 Assert.AreEqual (-2.1M, Math.Round (-2.05M, 1, m), "#14");
1454 Assert.AreEqual (-2.1M, Math.Round (-2.08M, 1, m), "#15");
1455 Assert.AreEqual (-3.1M, Math.Round (-3.05M, 1, m), "#16");
1460 public void Parse_NumberGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
1462 NumberFormatInfo nf = new NumberFormatInfo ();
1463 nf.NumberGroupSeparator = "";
1464 Decimal.Parse ("1.5", nf);
1469 public void Parse_CurrencyGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
1471 NumberFormatInfo nf = new NumberFormatInfo ();
1472 nf.CurrencyGroupSeparator = "";
1473 Decimal.Parse ("\u00A41.5", NumberStyles.Currency, nf);
1478 public void Parse_LeadingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1480 NumberFormatInfo nf = new NumberFormatInfo ();
1481 nf.PositiveSign = "";
1483 Decimal.Parse ("+15", nf);
1484 } catch (FormatException) {
1488 Assert.Fail ("Expected FormatException");
1493 public void Parse_LeadingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1495 NumberFormatInfo nf = new NumberFormatInfo ();
1496 nf.NegativeSign = "";
1498 Decimal.Parse ("-15", nf);
1499 } catch (FormatException) {
1503 Assert.Fail ("Expected FormatException");
1508 public void Parse_TrailingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1510 NumberFormatInfo nf = new NumberFormatInfo ();
1511 nf.PositiveSign = "";
1513 Decimal.Parse ("15+", nf);
1514 } catch (FormatException) {
1518 Assert.Fail ("Expected FormatException");
1523 public void Parse_TrailingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
1525 NumberFormatInfo nf = new NumberFormatInfo ();
1526 nf.NegativeSign = "";
1528 Decimal.Parse ("15-", nf);
1529 } catch (FormatException) {
1533 Assert.Fail ("Expected FormatException");