1 // DecimalTest.cs - NUnit Test Cases for the System.Decimal struct
\r
4 // Martin Weindel (martin.weindel@t-online.de)
\r
5 // Sebastien Pouliot <sebastien@ximian.com>
\r
7 // (C) Martin Weindel, 2001
\r
8 // Copyright (C) 2004 Novell (http://www.novell.com)
\r
11 using NUnit.Framework;
\r
14 using System.Globalization;
\r
15 using System.Runtime.CompilerServices;
\r
16 using System.Threading;
\r
18 namespace MonoTests.System {
\r
19 internal struct ParseTest
\r
21 public ParseTest(String str, bool exceptionFlag)
\r
24 this.exceptionFlag = exceptionFlag;
\r
25 this.style = NumberStyles.Number;
\r
29 public ParseTest(String str, Decimal d)
\r
32 this.exceptionFlag = false;
\r
33 this.style = NumberStyles.Number;
\r
37 public ParseTest(String str, Decimal d, NumberStyles style)
\r
40 this.exceptionFlag = false;
\r
47 public NumberStyles style;
\r
48 public bool exceptionFlag;
\r
51 internal struct ToStringTest
\r
53 public ToStringTest(String format, Decimal d, String str)
\r
55 this.format = format;
\r
60 public String format;
\r
66 public class DecimalTest : Assertion
\r
68 private const int negativeBitValue = unchecked ((int)0x80000000);
\r
69 private const int negativeScale4Value = unchecked ((int)0x80040000);
\r
70 private int [] parts0 = {0,0,0,0}; //Positive Zero.
\r
71 private int [] parts1 = {1,0,0,0};
\r
72 private int [] parts2 = {0,1,0,0};
\r
73 private int [] parts3 = {0,0,1,0};
\r
74 private int [] parts4 = {0,0,0,negativeBitValue}; // Negative zero.
\r
75 private int [] parts5 = {1,1,1,0};
\r
76 private int [] partsMaxValue = {-1,-1,-1,0};
\r
77 private int [] partsMinValue = {-1,-1,-1,negativeBitValue};
\r
78 private int [] parts6 = {1234, 5678, 8888, negativeScale4Value};
\r
79 private NumberFormatInfo NfiUser;
\r
81 private CultureInfo old_culture;
\r
84 public void FixtureSetUp ()
\r
86 old_culture = Thread.CurrentThread.CurrentCulture;
\r
88 // Set culture to en-US and don't let the user override.
\r
89 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
\r
91 NfiUser = new NumberFormatInfo();
\r
92 NfiUser.CurrencyDecimalDigits = 3;
\r
93 NfiUser.CurrencyDecimalSeparator = ",";
\r
94 NfiUser.CurrencyGroupSeparator = "_";
\r
95 NfiUser.CurrencyGroupSizes = new int[] { 2,1,0 };
\r
96 NfiUser.CurrencyNegativePattern = 10;
\r
97 NfiUser.CurrencyPositivePattern = 3;
\r
98 NfiUser.CurrencySymbol = "XYZ";
\r
99 NfiUser.NumberDecimalSeparator = "##";
\r
100 NfiUser.NumberDecimalDigits = 4;
\r
101 NfiUser.NumberGroupSeparator = "__";
\r
102 NfiUser.NumberGroupSizes = new int[] { 2,1 };
\r
103 NfiUser.PercentDecimalDigits = 1;
\r
104 NfiUser.PercentDecimalSeparator = ";";
\r
105 NfiUser.PercentGroupSeparator = "~";
\r
106 NfiUser.PercentGroupSizes = new int[] {1};
\r
107 NfiUser.PercentNegativePattern = 2;
\r
108 NfiUser.PercentPositivePattern = 2;
\r
109 NfiUser.PercentSymbol = "%%%";
\r
112 [TestFixtureTearDown]
\r
113 public void FixtureTearDown ()
\r
115 Thread.CurrentThread.CurrentCulture = old_culture;
\r
118 public void TestToString()
\r
120 ToStringTest[] tab = {
\r
121 new ToStringTest("F", 12.345678m, "12.35"),
\r
122 new ToStringTest("F3", 12.345678m, "12.346"),
\r
123 new ToStringTest("F0", 12.345678m, "12"),
\r
124 new ToStringTest("F7", 12.345678m, "12.3456780"),
\r
125 new ToStringTest("g", 12.345678m, "12.345678"),
\r
126 new ToStringTest("E", 12.345678m, "1.234568E+001"),
\r
127 new ToStringTest("E3", 12.345678m, "1.235E+001"),
\r
128 new ToStringTest("E0", 12.345678m, "1E+001"),
\r
129 new ToStringTest("e8", 12.345678m, "1.23456780e+001"),
\r
130 new ToStringTest("F", 0.0012m, "0.00"),
\r
131 new ToStringTest("F3", 0.0012m, "0.001"),
\r
132 new ToStringTest("F0", 0.0012m, "0"),
\r
133 new ToStringTest("F6", 0.0012m, "0.001200"),
\r
134 new ToStringTest("e", 0.0012m, "1.200000e-003"),
\r
135 new ToStringTest("E3", 0.0012m, "1.200E-003"),
\r
136 new ToStringTest("E0", 0.0012m, "1E-003"),
\r
137 new ToStringTest("E6", 0.0012m, "1.200000E-003"),
\r
138 new ToStringTest("F4", -0.001234m, "-0.0012"),
\r
139 new ToStringTest("E3", -0.001234m, "-1.234E-003"),
\r
141 new ToStringTest("g", -0.000012m, "-1.2e-05"),
\r
143 new ToStringTest("g", -0.000012m, "-0.000012"),
\r
145 new ToStringTest("g", -0.00012m, "-0.00012"),
\r
146 new ToStringTest("g4", -0.00012m, "-0.00012"),
\r
147 new ToStringTest("g7", -0.00012m, "-0.00012"),
\r
148 new ToStringTest("g", -0.0001234m, "-0.0001234"),
\r
149 new ToStringTest("g", -0.0012m, "-0.0012"),
\r
150 new ToStringTest("g", -0.001234m, "-0.001234"),
\r
151 new ToStringTest("g", -0.012m, "-0.012"),
\r
152 new ToStringTest("g4", -0.012m, "-0.012"),
\r
153 new ToStringTest("g", -0.12m, "-0.12"),
\r
154 new ToStringTest("g", -1.2m, "-1.2"),
\r
155 new ToStringTest("g4", -120m, "-120"),
\r
156 new ToStringTest("g", -12m, "-12"),
\r
157 new ToStringTest("g", -120m, "-120"),
\r
158 new ToStringTest("g", -1200m, "-1200"),
\r
159 new ToStringTest("g4", -1200m, "-1200"),
\r
160 new ToStringTest("g", -1234m, "-1234"),
\r
161 new ToStringTest("g", -12000m, "-12000"),
\r
162 new ToStringTest("g4", -12000m, "-1.2e+04"),
\r
163 new ToStringTest("g5", -12000m, "-12000"),
\r
164 new ToStringTest("g", -12345m, "-12345"),
\r
165 new ToStringTest("g", -120000m, "-120000"),
\r
166 new ToStringTest("g4", -120000m, "-1.2e+05"),
\r
167 new ToStringTest("g5", -120000m, "-1.2e+05"),
\r
168 new ToStringTest("g6", -120000m, "-120000"),
\r
169 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
170 new ToStringTest("g5", -123456.1m, "-1.2346e+05"),
\r
171 new ToStringTest("g6", -123456.1m, "-123456"),
\r
172 new ToStringTest("g", -1200000m, "-1200000"),
\r
173 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
174 new ToStringTest("g", -123456.1m, "-123456.1"),
\r
175 new ToStringTest("g", -1234567.1m, "-1234567.1"),
\r
176 new ToStringTest("g", -12000000m, "-12000000"),
\r
177 new ToStringTest("g", -12345678.1m, "-12345678.1"),
\r
178 new ToStringTest("g", -12000000000000000000m, "-12000000000000000000"),
\r
179 new ToStringTest("F", -123, "-123.00"),
\r
180 new ToStringTest("F3", -123, "-123.000"),
\r
181 new ToStringTest("F0", -123, "-123"),
\r
182 new ToStringTest("E3", -123, "-1.230E+002"),
\r
183 new ToStringTest("E0", -123, "-1E+002"),
\r
184 new ToStringTest("E", -123, "-1.230000E+002"),
\r
185 new ToStringTest("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),
\r
186 new ToStringTest("F", Decimal.MinValue, "-79228162514264337593543950335.00"),
\r
187 new ToStringTest("F0", Decimal.MinValue, "-79228162514264337593543950335"),
\r
188 new ToStringTest("E", Decimal.MinValue, "-7.922816E+028"),
\r
189 new ToStringTest("E3", Decimal.MinValue, "-7.923E+028"),
\r
190 new ToStringTest("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),
\r
191 new ToStringTest("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),
\r
192 new ToStringTest("E0", Decimal.MinValue, "-8E+028"),
\r
193 new ToStringTest("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
\r
194 new ToStringTest("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
\r
195 new ToStringTest("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
\r
196 new ToStringTest("n3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
\r
197 new ToStringTest("n0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
\r
198 new ToStringTest("n", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
\r
199 new ToStringTest("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),
\r
200 new ToStringTest("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),
\r
201 new ToStringTest("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),
\r
202 new ToStringTest("P", 123456.7891m, "12,345,678.91 %"),
\r
203 new ToStringTest("P", -123456.7892m, "-12,345,678.92 %"),
\r
204 new ToStringTest("P3", 1234.56789m, "123,456.789 %"),
\r
207 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
\r
209 for (int i = 0; i < tab.Length; i++)
\r
213 string s = tab[i].d.ToString(tab[i].format, nfi);
\r
214 AssertEquals("A01 tab[" + i + "].format = '" + tab[i].format + "')", tab[i].str, s);
\r
216 catch (OverflowException)
\r
218 Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");
\r
220 catch (NUnit.Framework.AssertionException e) {
\r
223 catch (Exception e) {
\r
224 Fail ("Unexpected Exception when i = " + i + ". e = " + e);
\r
229 public void TestCurrencyPattern()
\r
231 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
232 Decimal d = -1234567.8976m;
\r
233 string[] ergCurrencyNegativePattern = new String[16] {
\r
234 "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
\r
235 "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
\r
236 "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
\r
237 "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
\r
240 for (int i = 0; i < ergCurrencyNegativePattern.Length; i++)
\r
242 nfi2.CurrencyNegativePattern = i;
\r
243 if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i])
\r
245 Fail("CurrencyNegativePattern #" + i + " failed: " +
\r
246 d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);
\r
251 string[] ergCurrencyPositivePattern = new String[4] {
\r
252 "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
\r
255 for (int i = 0; i < ergCurrencyPositivePattern.Length; i++)
\r
257 nfi2.CurrencyPositivePattern = i;
\r
258 if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i])
\r
260 Fail("CurrencyPositivePattern #" + i + " failed: " +
\r
261 d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);
\r
266 public void TestNumberNegativePattern()
\r
268 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
269 Decimal d = -1234.89765m;
\r
270 string[] ergNumberNegativePattern = new String[5] {
\r
271 "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",
\r
274 for (int i = 0; i < ergNumberNegativePattern.Length; i++)
\r
276 nfi2.NumberNegativePattern = i;
\r
277 AssertEquals ("NumberNegativePattern #" + i, ergNumberNegativePattern[i], d.ToString("N", nfi2));
\r
281 public void TestPercentPattern()
\r
283 NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
\r
284 Decimal d = -1234.8976m;
\r
285 string[] ergPercentNegativePattern = new String[3] {
\r
286 "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
\r
289 for (int i = 0; i < ergPercentNegativePattern.Length; i++)
\r
291 nfi2.PercentNegativePattern = i;
\r
292 if (d.ToString("P", nfi2) != ergPercentNegativePattern[i])
\r
294 Fail("PercentNegativePattern #" + i + " failed: " +
\r
295 d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);
\r
300 string[] ergPercentPositivePattern = new String[3] {
\r
301 "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
\r
304 for (int i = 0; i < ergPercentPositivePattern.Length; i++)
\r
306 nfi2.PercentPositivePattern = i;
\r
307 if (d.ToString("P", nfi2) != ergPercentPositivePattern[i])
\r
309 Fail("PercentPositivePattern #" + i + " failed: " +
\r
310 d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);
\r
315 public void TestParse()
\r
317 ParseTest[] tab = {
\r
318 new ParseTest("1.2345", 1.2345m),
\r
319 new ParseTest("-9876543210", -9876543210m),
\r
320 new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol
\r
321 + " ( 79,228,162,514,264,337,593,543,950,335.000 ) ", Decimal.MinValue, NumberStyles.Currency),
\r
322 new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),
\r
323 new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
\r
324 new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),
\r
325 new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
\r
326 new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
\r
327 new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
\r
328 new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
\r
329 new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
\r
330 new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
\r
334 for (int i = 0; i < tab.Length; i++)
\r
338 d = Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);
\r
339 if (tab[i].exceptionFlag)
\r
341 Fail(tab[i].str + ": missing exception !");
\r
343 else if (d != tab[i].d)
\r
345 Fail(tab[i].str + " != " + d);
\r
348 catch (OverflowException)
\r
350 if (!tab[i].exceptionFlag)
\r
352 Fail(tab[i].str + ": unexpected exception !");
\r
359 d = Decimal.Parse(null);
\r
360 Fail("Expected ArgumentNullException");
\r
362 catch (ArgumentNullException)
\r
369 d = Decimal.Parse("123nx");
\r
370 Fail("Expected FormatException");
\r
372 catch (FormatException)
\r
379 d = Decimal.Parse("79228162514264337593543950336");
\r
380 Fail("Expected OverflowException" + d);
\r
382 catch (OverflowException)
\r
388 public void TestConstants()
\r
390 AssertEquals ("Zero", 0m, Decimal.Zero);
\r
391 AssertEquals ("One", 1m, Decimal.One);
\r
392 AssertEquals ("MinusOne", -1m, Decimal.MinusOne);
\r
393 AssertEquals ("MaxValue", 79228162514264337593543950335m, Decimal.MaxValue);
\r
394 AssertEquals ("MinValue", -79228162514264337593543950335m, Decimal.MinValue);
\r
395 Assert ("MinusOne 2", -1m == Decimal.MinusOne);
\r
398 public void TestConstructInt32()
\r
400 decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};
\r
401 int[] itab = {0, 1, -1, 123456, -1234567};
\r
405 for (int i = 0; i < dtab.GetLength(0); i++)
\r
407 d = new Decimal(itab[i]);
\r
408 if ((decimal)d != dtab[i])
\r
410 Fail("Int32 -> Decimal: " + itab[i] + " != " + d);
\r
417 Fail("Decimal -> Int32: " + d + " != " + itab[i]);
\r
422 d = new Decimal(Int32.MaxValue);
\r
423 Assert((int)d == Int32.MaxValue);
\r
425 d = new Decimal(Int32.MinValue);
\r
426 Assert((int)d == Int32.MinValue);
\r
429 public void TestConstructUInt32()
\r
431 decimal[] dtab = {0m, 1m, 123456m, 123456789m};
\r
432 uint[] itab = {0, 1, 123456, 123456789};
\r
436 for (int i = 0; i < dtab.GetLength(0); i++)
\r
438 d = new Decimal(itab[i]);
\r
439 if ((decimal)d != dtab[i])
\r
441 Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);
\r
448 Fail("Decimal -> UInt32: " + d + " != " + itab[i]);
\r
453 d = new Decimal(UInt32.MaxValue);
\r
454 Assert((uint)d == UInt32.MaxValue);
\r
456 d = new Decimal(UInt32.MinValue);
\r
457 Assert((uint)d == UInt32.MinValue);
\r
460 public void TestConstructInt64()
\r
462 decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};
\r
463 long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};
\r
467 for (int i = 0; i < dtab.GetLength(0); i++)
\r
469 d = new Decimal(itab[i]);
\r
470 if ((decimal)d != dtab[i])
\r
472 Fail("Int64 -> Decimal: " + itab[i] + " != " + d);
\r
479 Fail("Decimal -> Int64: " + d + " != " + itab[i]);
\r
484 d = new Decimal(Int64.MaxValue);
\r
485 Assert((long)d == Int64.MaxValue);
\r
487 d = new Decimal(Int64.MinValue);
\r
488 Assert((long)d == Int64.MinValue);
\r
491 public void TestConstructUInt64()
\r
493 decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};
\r
494 ulong[] itab = {0, 1, 987654321, 123456789876543210L};
\r
498 for (int i = 0; i < dtab.GetLength(0); i++)
\r
500 d = new Decimal(itab[i]);
\r
501 if ((decimal)d != dtab[i])
\r
503 Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);
\r
507 ulong n = (ulong) d;
\r
510 Fail("Decimal -> UInt64: " + d + " != " + itab[i]);
\r
515 d = new Decimal(UInt64.MaxValue);
\r
516 Assert((ulong)d == UInt64.MaxValue);
\r
518 d = new Decimal(UInt64.MinValue);
\r
519 Assert((ulong)d == UInt64.MinValue);
\r
522 public void TestConstructSingle()
\r
526 d = new Decimal(-1.2345678f);
\r
527 AssertEquals("A#01", -1.234568m, (decimal)d);
\r
530 AssertEquals("A#02", 3.0f, (float)d);
\r
532 d = new Decimal(0.0f);
\r
533 AssertEquals("A#03", 0m, (decimal)d);
\r
534 AssertEquals("A#04", 0.0f, (float)d);
\r
536 d = new Decimal(1.0f);
\r
537 AssertEquals("A#05", 1m, (decimal)d);
\r
538 AssertEquals("A#06", 1.0f, (float)d);
\r
540 d = new Decimal(-1.2345678f);
\r
541 AssertEquals("A#07", -1.234568m, (decimal)d);
\r
542 AssertEquals("A#08", -1.234568f, (float)d);
\r
544 d = new Decimal(1.2345673f);
\r
545 AssertEquals("A#09", 1.234567m, (decimal)d);
\r
547 d = new Decimal(1.2345673e7f);
\r
548 AssertEquals("A#10", 12345670m, (decimal)d);
\r
550 d = new Decimal(1.2345673e-17f);
\r
551 AssertEquals("A#11", 0.00000000000000001234567m, (decimal)d);
\r
552 AssertEquals("A#12", 1.234567e-17f, (float)d);
\r
557 d = new Decimal(Single.MaxValue);
\r
560 catch (OverflowException)
\r
566 d = new Decimal(Single.NaN);
\r
569 catch (OverflowException)
\r
575 d = new Decimal(Single.PositiveInfinity);
\r
578 catch (OverflowException)
\r
583 public void TestConstructSingleRounding_NowWorking ()
\r
587 d = new Decimal(1765.23454f);
\r
588 AssertEquals ("failed banker's rule rounding test 2", 1765.234m, d);
\r
590 d = new Decimal(0.00017652356f);
\r
591 AssertEquals ("06", 0.0001765236m, d);
\r
593 d = new Decimal(0.000176523554f);
\r
594 AssertEquals ("failed banker's rule rounding test 3", 0.0001765236m, d);
\r
596 d = new Decimal(0.00017652354f);
\r
597 AssertEquals ("08", 0.0001765235m, d);
\r
599 d = new Decimal(0.00017652346f);
\r
600 AssertEquals ("09", 0.0001765235m, d);
\r
602 d = new Decimal(0.000176523454f);
\r
603 AssertEquals ("failed banker's rule rounding test 4", 0.0001765234m, d);
\r
605 d = new Decimal(0.00017652344f);
\r
606 AssertEquals ("11", 0.0001765234m, d);
\r
609 public void TestConstructSingleRounding()
\r
613 d = new Decimal(1765.2356f);
\r
614 Assert("01", d == 1765.236m);
\r
616 d = new Decimal(1765.23554f);
\r
617 Assert("failed banker's rule rounding test 1", d == 1765.236m);
\r
619 d = new Decimal(1765.2354f);
\r
620 Assert("03", d == 1765.235m);
\r
622 d = new Decimal(1765.2346f);
\r
623 Assert("04", d == 1765.235m);
\r
625 d = new Decimal(1765.2344f);
\r
626 Assert("05", d == 1765.234m);
\r
628 d = new Decimal(3.7652356e10f);
\r
629 Assert("12", d == 37652360000m);
\r
631 d = new Decimal(3.7652356e20f);
\r
632 Assert("13", d == 376523600000000000000m);
\r
634 d = new Decimal(3.76523554e20f);
\r
635 Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);
\r
637 d = new Decimal(3.7652352e20f);
\r
638 Assert("15", d == 376523500000000000000m);
\r
640 d = new Decimal(3.7652348e20f);
\r
641 Assert("16", d == 376523500000000000000m);
\r
643 d = new Decimal(3.76523454e20f);
\r
644 Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);
\r
646 d = new Decimal(3.7652342e20f);
\r
647 Assert("18", d == 376523400000000000000m);
\r
650 public void TestConstructDouble()
\r
654 d = new Decimal(0.0);
\r
655 Assert((decimal)d == 0m);
\r
657 d = new Decimal(1.0);
\r
658 Assert((decimal)d == 1m);
\r
659 Assert(1.0 == (double)d);
\r
661 d = new Decimal(-1.2345678901234);
\r
662 Assert((decimal)d == -1.2345678901234m);
\r
663 Assert(-1.2345678901234 == (double)d);
\r
665 d = new Decimal(1.2345678901234);
\r
666 Assert((decimal)d == 1.2345678901234m);
\r
668 d = new Decimal(1.2345678901234e8);
\r
669 Assert((decimal)d == 123456789.01234m);
\r
670 Assert(1.2345678901234e8 == (double)d);
\r
672 d = new Decimal(1.2345678901234e16);
\r
673 Assert((decimal)d == 12345678901234000m);
\r
674 Assert(1.2345678901234e16 == (double)d);
\r
676 d = new Decimal(1.2345678901234e24);
\r
677 Assert((decimal)d == 1234567890123400000000000m);
\r
678 Assert(1.2345678901234e24 == (double)d);
\r
680 d = new Decimal(1.2345678901234e28);
\r
681 Assert((decimal)d == 1.2345678901234e28m);
\r
682 Assert(1.2345678901234e28 == (double)d);
\r
684 d = new Decimal(7.2345678901234e28);
\r
685 Assert((decimal)d == 7.2345678901234e28m);
\r
686 Assert(new Decimal((double)d) == d);
\r
688 d = new Decimal(1.2345678901234e-8);
\r
689 Assert((decimal)d == 1.2345678901234e-8m);
\r
691 d = new Decimal(1.2345678901234e-14);
\r
692 Assert((decimal)d == 1.2345678901234e-14m);
\r
693 Assert(1.2345678901234e-14 == (double)d);
\r
695 d = new Decimal(1.2342278901234e-25);
\r
696 Assert((decimal)d == 1.234e-25m);
\r
701 d = new Decimal(8e28);
\r
704 catch (OverflowException)
\r
710 d = new Decimal(8e48);
\r
713 catch (OverflowException)
\r
719 d = new Decimal(Double.NaN);
\r
722 catch (OverflowException)
\r
728 d = new Decimal(Double.PositiveInfinity);
\r
731 catch (OverflowException)
\r
736 public void TestConstructDoubleRound()
\r
742 d = new Decimal(1765.231234567857);
\r
743 AssertEquals("A01", 1765.23123456786m, d);
\r
746 d = new Decimal(1765.2312345678554);
\r
747 AssertEquals("A02, failed banker's rule rounding test 1", 1765.23123456786m, d);
\r
748 AssertEquals("A03", 1765.23123456786, (double)d);
\r
751 d = new Decimal(1765.231234567853);
\r
752 Assert(d == 1765.23123456785m);
\r
755 d = new Decimal(1765.231234567847);
\r
756 Assert(d == 1765.23123456785m);
\r
759 d = new Decimal(1765.231234567843);
\r
760 Assert(d == 1765.23123456784m);
\r
763 d = new Decimal(1.765231234567857e-9);
\r
764 Assert(d == 1.76523123456786e-9m);
\r
767 d = new Decimal(1.7652312345678554e-9);
\r
768 Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);
\r
771 d = new Decimal(1.765231234567853e-9);
\r
772 Assert(d == 1.76523123456785e-9m);
\r
775 d = new Decimal(1.765231234567857e+24);
\r
776 Assert(d == 1.76523123456786e+24m);
\r
779 d = new Decimal(1.7652312345678554e+24);
\r
780 Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);
\r
783 d = new Decimal(1.765231234567853e+24);
\r
784 Assert(d == 1.76523123456785e+24m);
\r
787 d = new Decimal(1765.2312345678454);
\r
788 Assert(d == 1765.23123456785m);
\r
790 catch (Exception e) {
\r
791 Fail("At TestNum = " + TestNum + " unexpected exception. e = " + e);
\r
795 public void TestNegate()
\r
799 d = new Decimal(12345678);
\r
800 Assert((decimal)Decimal.Negate(d) == -12345678m);
\r
803 public void TestPartConstruct()
\r
807 d = new Decimal(parts0);
\r
810 d = new Decimal(parts1);
\r
813 d = new Decimal(parts2);
\r
814 Assert(d == 4294967296m);
\r
816 d = new Decimal(parts3);
\r
817 Assert(d == 18446744073709551616m);
\r
819 d = new Decimal(parts4);
\r
822 d = new Decimal(parts5);
\r
823 Assert(d == 18446744078004518913m);
\r
825 d = new Decimal(partsMaxValue);
\r
826 Assert(d == Decimal.MaxValue);
\r
828 d = new Decimal(partsMinValue);
\r
829 Assert(d == Decimal.MinValue);
\r
831 d = new Decimal(parts6);
\r
832 int[] erg = Decimal.GetBits(d);
\r
833 for (int i = 0; i < 4; i++)
\r
835 Assert(erg[i] == parts6[i]);
\r
839 public void TestFloorTruncate()
\r
841 decimal[,] dtab = {
\r
842 {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
\r
843 {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
\r
844 {-123456789012345.67890m, -123456789012346m, -123456789012345m},
\r
845 {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},
\r
846 {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},
\r
847 {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
\r
848 {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
\r
853 for (int i = 0; i < dtab.GetLength(0); i++)
\r
855 d = Decimal.Floor(dtab[i,0]);
\r
856 if (d != dtab[i,1])
\r
858 Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);
\r
860 d = Decimal.Truncate(dtab[i,0]);
\r
861 if (d != dtab[i,2])
\r
863 Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);
\r
869 public void Truncate ()
\r
871 decimal dd = 249.9m;
\r
872 decimal dt = Decimal.Truncate (dd);
\r
873 AssertEquals ("Original", 249.9m, dd);
\r
874 AssertEquals ("Truncate", 249m, dt);
\r
875 AssertEquals ("Cast-Byte", 249, (byte)dd);
\r
876 AssertEquals ("Cast-Char", 249, (char)dd);
\r
877 AssertEquals ("Cast-Int16", 249, (short)dd);
\r
878 AssertEquals ("Cast-UInt16", 249, (ushort)dd);
\r
879 AssertEquals ("Cast-Int32", 249, (int)dd);
\r
880 AssertEquals ("Cast-UInt32", 249, (uint)dd);
\r
881 AssertEquals ("Cast-Int64", 249, (long)dd);
\r
882 AssertEquals ("Cast-UInt64", 249, (ulong)dd);
\r
885 public void TestRound()
\r
887 decimal[,] dtab = {
\r
888 {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
\r
889 {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
\r
890 {1.2355m, 3, 1.236m},
\r
891 {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
\r
892 {47893764694.4578563236436621m, 7, 47893764694.4578563m},
\r
893 {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
\r
894 {-47893764694.4578m, 5, -47893764694.4578m}
\r
899 for (int i = 0; i < dtab.GetLength(0); i++)
\r
901 d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);
\r
902 if (d != dtab[i,2])
\r
904 Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
\r
909 public void TestRoundFailures ()
\r
911 decimal[,] dtab = {
\r
912 {1.2345m, 3, 1.234m}
\r
917 for (int i = 0; i < dtab.GetLength(0); i++)
\r
919 d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);
\r
920 if (d != dtab[i,2])
\r
922 Fail("FailRound: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
\r
928 public void ParseInt64 ()
\r
930 long max = Int64.MaxValue;
\r
931 Decimal dmax = Decimal.Parse (max.ToString ());
\r
932 AssertEquals ("Int64.MaxValue", Int64.MaxValue, Decimal.ToInt64 (dmax));
\r
934 long min = Int64.MinValue;
\r
935 Decimal dmin = Decimal.Parse (min.ToString ());
\r
936 AssertEquals ("Int64.MinValue", Int64.MinValue, Decimal.ToInt64 (dmin));
\r
939 dmax = Decimal.Parse (dmax.ToString ());
\r
940 AssertEquals ("Int64.MaxValue+1.1", Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m));
\r
943 dmin = Decimal.Parse (dmin.ToString ());
\r
944 AssertEquals ("Int64.MinValue-1.1", Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m));
\r
948 public void ToByte ()
\r
950 Decimal d = 254.9m;
\r
951 AssertEquals ("Decimal.ToByte", 254, Decimal.ToByte (d));
\r
952 AssertEquals ("Convert.ToByte", 255, Convert.ToByte (d));
\r
953 AssertEquals ("IConvertible.ToByte", 255, (d as IConvertible).ToByte (null));
\r
957 public void ToSByte ()
\r
959 Decimal d = 126.9m;
\r
960 AssertEquals ("Decimal.ToSByte", 126, Decimal.ToSByte (d));
\r
961 AssertEquals ("Convert.ToSByte", 127, Convert.ToSByte (d));
\r
962 AssertEquals ("IConvertible.ToSByte", 127, (d as IConvertible).ToSByte (null));
\r
964 AssertEquals ("-Decimal.ToSByte", -126, Decimal.ToSByte (d));
\r
965 AssertEquals ("-Convert.ToSByte", -127, Convert.ToSByte (d));
\r
966 AssertEquals ("-IConvertible.ToSByte", -127, (d as IConvertible).ToSByte (null));
\r
970 public void ToInt16 ()
\r
972 Decimal d = 254.9m;
\r
973 AssertEquals ("Decimal.ToInt16", 254, Decimal.ToInt16 (d));
\r
974 AssertEquals ("Convert.ToInt16", 255, Convert.ToInt16 (d));
\r
975 AssertEquals ("IConvertible.ToInt16", 255, (d as IConvertible).ToInt16 (null));
\r
977 AssertEquals ("-Decimal.ToInt16", -254, Decimal.ToInt16 (d));
\r
978 AssertEquals ("-Convert.ToInt16", -255, Convert.ToInt16 (d));
\r
979 AssertEquals ("-IConvertible.ToInt16", -255, (d as IConvertible).ToInt16 (null));
\r
983 public void ToUInt16 ()
\r
985 Decimal d = 254.9m;
\r
986 AssertEquals ("Decimal.ToUInt16", 254, Decimal.ToUInt16 (d));
\r
987 AssertEquals ("Convert.ToUInt16", 255, Convert.ToUInt16 (d));
\r
988 AssertEquals ("IConvertible.ToUInt16", 255, (d as IConvertible).ToUInt16 (null));
\r
992 public void ToInt32 ()
\r
994 Decimal d = 254.9m;
\r
995 AssertEquals ("Decimal.ToInt32", 254, Decimal.ToInt32 (d));
\r
996 AssertEquals ("Convert.ToInt32", 255, Convert.ToInt32 (d));
\r
997 AssertEquals ("IConvertible.ToInt32", 255, (d as IConvertible).ToInt32 (null));
\r
999 AssertEquals ("-Decimal.ToInt32", -254, Decimal.ToInt32 (d));
\r
1000 AssertEquals ("-Convert.ToInt32", -255, Convert.ToInt32 (d));
\r
1001 AssertEquals ("-IConvertible.ToInt32", -255, (d as IConvertible).ToInt32 (null));
\r
1005 public void ToUInt32 ()
\r
1007 Decimal d = 254.9m;
\r
1008 AssertEquals ("Decimal.ToUInt32", 254, Decimal.ToUInt32 (d));
\r
1009 AssertEquals ("Convert.ToUInt32", 255, Convert.ToUInt32 (d));
\r
1010 AssertEquals ("IConvertible.ToUInt32", 255, (d as IConvertible).ToUInt32 (null));
\r
1014 public void ToInt64 ()
\r
1016 Decimal d = 254.9m;
\r
1017 AssertEquals ("Decimal.ToInt64", 254, Decimal.ToInt64 (d));
\r
1018 AssertEquals ("Convert.ToInt64", 255, Convert.ToInt64 (d));
\r
1019 AssertEquals ("IConvertible.ToInt64", 255, (d as IConvertible).ToInt64 (null));
\r
1021 AssertEquals ("-Decimal.ToInt64", -254, Decimal.ToInt64 (d));
\r
1022 AssertEquals ("-Convert.ToInt64", -255, Convert.ToInt64 (d));
\r
1023 AssertEquals ("-IConvertible.ToInt64", -255, (d as IConvertible).ToInt64 (null));
\r
1027 [ExpectedException (typeof(OverflowException))]
\r
1028 public void ToInt64_TooBig ()
\r
1030 Decimal d = (Decimal) Int64.MaxValue;
\r
1032 long value = Decimal.ToInt64 (d);
\r
1036 [ExpectedException (typeof(OverflowException))]
\r
1037 public void ToInt64_TooSmall ()
\r
1039 Decimal d = (Decimal) Int64.MinValue;
\r
1041 long value = Decimal.ToInt64 (d);
\r
1045 public void ToUInt64 ()
\r
1047 Decimal d = 254.9m;
\r
1048 AssertEquals ("Decimal.ToUInt64", 254, Decimal.ToUInt64 (d));
\r
1049 AssertEquals ("Convert.ToUInt64", 255, Convert.ToUInt64 (d));
\r
1050 AssertEquals ("IConvertible.ToUInt64", 255, (d as IConvertible).ToUInt64 (null));
\r
1054 public void ToSingle ()
\r
1056 Decimal d = 254.9m;
\r
1057 AssertEquals ("Decimal.ToSingle", 254.9f, Decimal.ToSingle (d));
\r
1058 AssertEquals ("Convert.ToSingle", 254.9f, Convert.ToSingle (d));
\r
1059 AssertEquals ("IConvertible.ToSingle", 254.9f, (d as IConvertible).ToSingle (null));
\r
1061 AssertEquals ("-Decimal.ToSingle", -254.9f, Decimal.ToSingle (d));
\r
1062 AssertEquals ("-Convert.ToSingle", -254.9f, Convert.ToSingle (d));
\r
1063 AssertEquals ("-IConvertible.ToSingle", -254.9f, (d as IConvertible).ToSingle (null));
\r
1067 public void ToDouble ()
\r
1069 Decimal d = 254.9m;
\r
1070 AssertEquals ("Decimal.ToDouble", 254.9d, Decimal.ToDouble (d));
\r
1071 AssertEquals ("Convert.ToDouble", 254.9d, Convert.ToDouble (d));
\r
1072 AssertEquals ("IConvertible.ToDouble", 254.9d, (d as IConvertible).ToDouble (null));
\r
1074 AssertEquals ("-Decimal.ToDouble", -254.9d, Decimal.ToDouble (d));
\r
1075 AssertEquals ("-Convert.ToDouble", -254.9d, Convert.ToDouble (d));
\r
1076 AssertEquals ("-IConvertible.ToDouble", -254.9d, (d as IConvertible).ToDouble (null));
\r
1080 public void ToString_Defaults ()
\r
1082 Decimal d = 254.9m;
\r
1083 // everything defaults to "G"
\r
1084 string def = d.ToString ("G");
\r
1085 AssertEquals ("ToString()", def, d.ToString ());
\r
1086 AssertEquals ("ToString((IFormatProvider)null)", def, d.ToString ((IFormatProvider)null));
\r
1087 AssertEquals ("ToString((string)null)", def, d.ToString ((string)null));
\r
1088 AssertEquals ("ToString(empty)", def, d.ToString (String.Empty));
\r
1089 AssertEquals ("ToString(null,null)", def, d.ToString (null, null));
\r
1090 AssertEquals ("ToString(empty,null)", def, d.ToString (String.Empty, null));
\r
1092 AssertEquals ("ToString()", "254.9", def);
\r
1096 public void CastTruncRounding ()
\r
1098 // casting truncs decimal value (not normal nor banker's rounding)
\r
1099 AssertEquals ("254.9==254", 254, (long)(254.9m));
\r
1100 AssertEquals ("-254.9=-254", -254, (long)(-254.9m));
\r
1101 AssertEquals ("255.9==256", 255, (long)(255.9m));
\r
1102 AssertEquals ("-255.9=-256", -255, (long)(-255.9m));
\r
1106 public void ParseFractions ()
\r
1108 decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);
\r
1109 AssertEquals ("f1", 0.5234567890123454678901234568m, d1);
\r
1110 decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);
\r
1111 AssertEquals ("f2", 0.4921420654348652943463423146m, d2);
\r
1115 [ExpectedException (typeof (OverflowException))]
\r
1116 public void Parse_Int64_Overflow ()
\r
1118 // Int64.MaxValue + 1 + small fraction to allow 30 digits
\r
1119 // 123456789012345678901234567890
\r
1120 decimal d = Decimal.Parse ("9223372036854775808.0000000009", CultureInfo.InvariantCulture);
\r
1121 long l = (long) d;
\r
1125 [ExpectedException (typeof (DivideByZeroException))]
\r
1126 public void Remainder_ByZero ()
\r
1128 Decimal.Remainder (254.9m, 0m);
\r
1132 public void Remainder ()
\r
1134 decimal p1 = 254.9m;
\r
1135 decimal p2 = 12.1m;
\r
1136 decimal n1 = -254.9m;
\r
1137 decimal n2 = -12.1m;
\r
1139 AssertEquals ("254.9 % 12.1", 0.8m, Decimal.Remainder (p1, p2));
\r
1140 AssertEquals ("-254.9 % 12.1", -0.8m, Decimal.Remainder (n1, p2));
\r
1141 AssertEquals ("254.9 % -12.1", 0.8m, Decimal.Remainder (p1, n2));
\r
1142 AssertEquals ("-254.9 % -12.1", -0.8m, Decimal.Remainder (n1, n2));
\r
1144 AssertEquals ("12.1 % 254.9", 12.1m, Decimal.Remainder (p2, p1));
\r
1145 AssertEquals ("-12.1 % 254.9", -12.1m, Decimal.Remainder (n2, p1));
\r
1146 AssertEquals ("12.1 % -254.9", 12.1m, Decimal.Remainder (p2, n1));
\r
1147 AssertEquals ("-12.1 % -254.9", -12.1m, Decimal.Remainder (n2, n1));
\r
1149 AssertEquals ("12.1 % 12.1", 0.0m, Decimal.Remainder (p1, p1));
\r
1150 AssertEquals ("-12.1 % 12.1", 0.0m, Decimal.Remainder (n1, p1));
\r
1151 AssertEquals ("12.1 % -12.1", 0.0m, Decimal.Remainder (p1, n1));
\r
1152 AssertEquals ("-12.1 % -12.1", 0.0m, Decimal.Remainder (n1, n1));
\r
1154 AssertEquals ("12.1 % 12.1", 0, Decimal.Remainder (p1, p1));
\r
1155 AssertEquals ("-12.1 % 12.1", 0, Decimal.Remainder (n1, p1));
\r
1156 AssertEquals ("12.1 % -12.1", 0, Decimal.Remainder (p1, n1));
\r
1157 AssertEquals ("-12.1 % -12.1", 0, Decimal.Remainder (n1, n1));
\r
1162 [ExpectedException (typeof (DivideByZeroException))]
\r
1163 public void Divide_ByZero ()
\r
1165 Decimal.Divide (254.9m, 0m);
\r
1169 public void Divide ()
\r
1171 decimal p1 = 254.9m;
\r
1172 decimal p2 = 12.1m;
\r
1173 decimal n1 = -254.9m;
\r
1174 decimal n2 = -12.1m;
\r
1176 decimal c1 = 21.066115702479338842975206612m;
\r
1177 decimal c2 = 0.0474695959199686151431934092m;
\r
1179 AssertEquals ("254.9 / 12.1", c1, Decimal.Divide (p1, p2));
\r
1180 AssertEquals ("-254.9 / 12.1", -c1, Decimal.Divide (n1, p2));
\r
1181 AssertEquals ("254.9 / -12.1", -c1, Decimal.Divide (p1, n2));
\r
1182 AssertEquals ("-254.9 / -12.1", c1, Decimal.Divide (n1, n2));
\r
1184 AssertEquals ("12.1 / 254.9", c2, Decimal.Divide (p2, p1));
\r
1185 AssertEquals ("-12.1 / 254.9", -c2, Decimal.Divide (n2, p1));
\r
1186 AssertEquals ("12.1 / -254.9", -c2, Decimal.Divide (p2, n1));
\r
1187 AssertEquals ("-12.1 / -254.9", c2, Decimal.Divide (n2, n1));
\r
1189 AssertEquals ("12.1 / 12.1", 1, Decimal.Divide (p1, p1));
\r
1190 AssertEquals ("-12.1 / 12.1", -1, Decimal.Divide (n1, p1));
\r
1191 AssertEquals ("12.1 / -12.1", -1, Decimal.Divide (p1, n1));
\r
1192 AssertEquals ("-12.1 / -12.1", 1, Decimal.Divide (n1, n1));
\r
1196 [ExpectedException (typeof (ArgumentOutOfRangeException))]
\r
1197 public void Round_InvalidDecimals_Negative ()
\r
1199 Decimal.Round (254.9m, -1);
\r
1203 [ExpectedException (typeof (ArgumentOutOfRangeException))]
\r
1204 public void Round_InvalidDecimals_TooHigh ()
\r
1206 Decimal.Round (254.9m, 29);
\r
1210 public void Round_OddValue ()
\r
1212 decimal five = 5.5555555555555555555555555555m;
\r
1213 AssertEquals ("5,5_,00", 6, Decimal.Round (five, 0));
\r
1214 AssertEquals ("5,5_,01", 5.6m, Decimal.Round (five, 1));
\r
1215 AssertEquals ("5,5_,02", 5.56m, Decimal.Round (five, 2));
\r
1216 AssertEquals ("5,5_,03", 5.556m, Decimal.Round (five, 3));
\r
1217 AssertEquals ("5,5_,04", 5.5556m, Decimal.Round (five, 4));
\r
1218 AssertEquals ("5,5_,05", 5.55556m, Decimal.Round (five, 5));
\r
1219 AssertEquals ("5,5_,06", 5.555556m, Decimal.Round (five, 6));
\r
1220 AssertEquals ("5,5_,07", 5.5555556m, Decimal.Round (five, 7));
\r
1221 AssertEquals ("5,5_,08", 5.55555556m, Decimal.Round (five, 8));
\r
1222 AssertEquals ("5,5_,09", 5.555555556m, Decimal.Round (five, 9));
\r
1223 AssertEquals ("5,5_,10", 5.5555555556m, Decimal.Round (five, 10));
\r
1224 AssertEquals ("5,5_,11", 5.55555555556m, Decimal.Round (five, 11));
\r
1225 AssertEquals ("5,5_,12", 5.555555555556m, Decimal.Round (five, 12));
\r
1226 AssertEquals ("5,5_,13", 5.5555555555556m, Decimal.Round (five, 13));
\r
1227 AssertEquals ("5,5_,14", 5.55555555555556m, Decimal.Round (five, 14));
\r
1228 AssertEquals ("5,5_,15", 5.555555555555556m, Decimal.Round (five, 15));
\r
1229 AssertEquals ("5,5_,16", 5.5555555555555556m, Decimal.Round (five, 16));
\r
1230 AssertEquals ("5,5_,17", 5.55555555555555556m, Decimal.Round (five, 17));
\r
1231 AssertEquals ("5,5_,18", 5.555555555555555556m, Decimal.Round (five, 18));
\r
1232 AssertEquals ("5,5_,19", 5.5555555555555555556m, Decimal.Round (five, 19));
\r
1233 AssertEquals ("5,5_,20", 5.55555555555555555556m, Decimal.Round (five, 20));
\r
1234 AssertEquals ("5,5_,21", 5.555555555555555555556m, Decimal.Round (five, 21));
\r
1235 AssertEquals ("5,5_,22", 5.5555555555555555555556m, Decimal.Round (five, 22));
\r
1236 AssertEquals ("5,5_,23", 5.55555555555555555555556m, Decimal.Round (five, 23));
\r
1237 AssertEquals ("5,5_,24", 5.555555555555555555555556m, Decimal.Round (five, 24));
\r
1238 AssertEquals ("5,5_,25", 5.5555555555555555555555556m, Decimal.Round (five, 25));
\r
1239 AssertEquals ("5,5_,26", 5.55555555555555555555555556m, Decimal.Round (five, 26));
\r
1240 AssertEquals ("5,5_,27", 5.555555555555555555555555556m, Decimal.Round (five, 27));
\r
1241 AssertEquals ("5.5_,28", 5.5555555555555555555555555555m, Decimal.Round (five, 28));
\r
1245 public void Round_EvenValue ()
\r
1247 AssertEquals ("2,2_5,00", 2, Decimal.Round (2.5m, 0));
\r
1248 AssertEquals ("2,2_5,01", 2.2m, Decimal.Round (2.25m, 1));
\r
1249 AssertEquals ("2,2_5,02", 2.22m, Decimal.Round (2.225m, 2));
\r
1250 AssertEquals ("2,2_5,03", 2.222m, Decimal.Round (2.2225m, 3));
\r
1251 AssertEquals ("2,2_5,04", 2.2222m, Decimal.Round (2.22225m, 4));
\r
1252 AssertEquals ("2,2_5,05", 2.22222m, Decimal.Round (2.222225m, 5));
\r
1253 AssertEquals ("2,2_5,06", 2.222222m, Decimal.Round (2.2222225m, 6));
\r
1254 AssertEquals ("2,2_5,07", 2.2222222m, Decimal.Round (2.22222225m, 7));
\r
1255 AssertEquals ("2,2_5,08", 2.22222222m, Decimal.Round (2.222222225m, 8));
\r
1256 AssertEquals ("2,2_5,09", 2.222222222m, Decimal.Round (2.2222222225m, 9));
\r
1257 AssertEquals ("2,2_5,10", 2.2222222222m, Decimal.Round (2.22222222225m, 10));
\r
1258 AssertEquals ("2,2_5,11", 2.22222222222m, Decimal.Round (2.222222222225m, 11));
\r
1259 AssertEquals ("2,2_5,12", 2.222222222222m, Decimal.Round (2.2222222222225m, 12));
\r
1260 AssertEquals ("2,2_5,13", 2.2222222222222m, Decimal.Round (2.22222222222225m, 13));
\r
1261 AssertEquals ("2,2_5,14", 2.22222222222222m, Decimal.Round (2.222222222222225m, 14));
\r
1262 AssertEquals ("2,2_5,15", 2.222222222222222m, Decimal.Round (2.2222222222222225m, 15));
\r
1263 AssertEquals ("2,2_5,16", 2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16));
\r
1264 AssertEquals ("2,2_5,17", 2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17));
\r
1265 AssertEquals ("2,2_5,18", 2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18));
\r
1266 AssertEquals ("2,2_5,19", 2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19));
\r
1267 AssertEquals ("2,2_5,20", 2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20));
\r
1268 AssertEquals ("2,2_5,21", 2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21));
\r
1269 AssertEquals ("2,2_5,22", 2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22));
\r
1270 AssertEquals ("2,2_5,23", 2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23));
\r
1271 AssertEquals ("2,2_5,24", 2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24));
\r
1272 AssertEquals ("2,2_5,25", 2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25));
\r
1273 AssertEquals ("2,2_5,26", 2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26));
\r
1274 AssertEquals ("2,2_5,27", 2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27));
\r
1275 AssertEquals ("2,2_5,28", 2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28));
\r
1279 public void Round_OddValue_Negative ()
\r
1281 decimal five = -5.5555555555555555555555555555m;
\r
1282 AssertEquals ("-5,5_,00", -6, Decimal.Round (five, 0));
\r
1283 AssertEquals ("-5,5_,01", -5.6m, Decimal.Round (five, 1));
\r
1284 AssertEquals ("-5,5_,02", -5.56m, Decimal.Round (five, 2));
\r
1285 AssertEquals ("-5,5_,03", -5.556m, Decimal.Round (five, 3));
\r
1286 AssertEquals ("-5,5_,04", -5.5556m, Decimal.Round (five, 4));
\r
1287 AssertEquals ("-5,5_,05", -5.55556m, Decimal.Round (five, 5));
\r
1288 AssertEquals ("-5,5_,06", -5.555556m, Decimal.Round (five, 6));
\r
1289 AssertEquals ("-5,5_,07", -5.5555556m, Decimal.Round (five, 7));
\r
1290 AssertEquals ("-5,5_,08", -5.55555556m, Decimal.Round (five, 8));
\r
1291 AssertEquals ("-5,5_,09", -5.555555556m, Decimal.Round (five, 9));
\r
1292 AssertEquals ("-5,5_,10", -5.5555555556m, Decimal.Round (five, 10));
\r
1293 AssertEquals ("-5,5_,11", -5.55555555556m, Decimal.Round (five, 11));
\r
1294 AssertEquals ("-5,5_,12", -5.555555555556m, Decimal.Round (five, 12));
\r
1295 AssertEquals ("-5,5_,13", -5.5555555555556m, Decimal.Round (five, 13));
\r
1296 AssertEquals ("-5,5_,14", -5.55555555555556m, Decimal.Round (five, 14));
\r
1297 AssertEquals ("-5,5_,15", -5.555555555555556m, Decimal.Round (five, 15));
\r
1298 AssertEquals ("-5,5_,16", -5.5555555555555556m, Decimal.Round (five, 16));
\r
1299 AssertEquals ("-5,5_,17", -5.55555555555555556m, Decimal.Round (five, 17));
\r
1300 AssertEquals ("-5,5_,18", -5.555555555555555556m, Decimal.Round (five, 18));
\r
1301 AssertEquals ("-5,5_,19", -5.5555555555555555556m, Decimal.Round (five, 19));
\r
1302 AssertEquals ("-5,5_,20", -5.55555555555555555556m, Decimal.Round (five, 20));
\r
1303 AssertEquals ("-5,5_,21", -5.555555555555555555556m, Decimal.Round (five, 21));
\r
1304 AssertEquals ("-5,5_,22", -5.5555555555555555555556m, Decimal.Round (five, 22));
\r
1305 AssertEquals ("-5,5_,23", -5.55555555555555555555556m, Decimal.Round (five, 23));
\r
1306 AssertEquals ("-5,5_,24", -5.555555555555555555555556m, Decimal.Round (five, 24));
\r
1307 AssertEquals ("-5,5_,25", -5.5555555555555555555555556m, Decimal.Round (five, 25));
\r
1308 AssertEquals ("-5,5_,26", -5.55555555555555555555555556m, Decimal.Round (five, 26));
\r
1309 AssertEquals ("-5,5_,27", -5.555555555555555555555555556m, Decimal.Round (five, 27));
\r
1310 AssertEquals ("-5.5_,28", -5.5555555555555555555555555555m, Decimal.Round (five, 28));
\r
1314 public void Round_EvenValue_Negative ()
\r
1316 AssertEquals ("-2,2_5,00", -2, Decimal.Round (-2.5m, 0));
\r
1317 AssertEquals ("-2,2_5,01", -2.2m, Decimal.Round (-2.25m, 1));
\r
1318 AssertEquals ("-2,2_5,02", -2.22m, Decimal.Round (-2.225m, 2));
\r
1319 AssertEquals ("-2,2_5,03", -2.222m, Decimal.Round (-2.2225m, 3));
\r
1320 AssertEquals ("-2,2_5,04", -2.2222m, Decimal.Round (-2.22225m, 4));
\r
1321 AssertEquals ("-2,2_5,05", -2.22222m, Decimal.Round (-2.222225m, 5));
\r
1322 AssertEquals ("-2,2_5,06", -2.222222m, Decimal.Round (-2.2222225m, 6));
\r
1323 AssertEquals ("-2,2_5,07", -2.2222222m, Decimal.Round (-2.22222225m, 7));
\r
1324 AssertEquals ("-2,2_5,08", -2.22222222m, Decimal.Round (-2.222222225m, 8));
\r
1325 AssertEquals ("-2,2_5,09", -2.222222222m, Decimal.Round (-2.2222222225m, 9));
\r
1326 AssertEquals ("-2,2_5,10", -2.2222222222m, Decimal.Round (-2.22222222225m, 10));
\r
1327 AssertEquals ("-2,2_5,11", -2.22222222222m, Decimal.Round (-2.222222222225m, 11));
\r
1328 AssertEquals ("-2,2_5,12", -2.222222222222m, Decimal.Round (-2.2222222222225m, 12));
\r
1329 AssertEquals ("-2,2_5,13", -2.2222222222222m, Decimal.Round (-2.22222222222225m, 13));
\r
1330 AssertEquals ("-2,2_5,14", -2.22222222222222m, Decimal.Round (-2.222222222222225m, 14));
\r
1331 AssertEquals ("-2,2_5,15", -2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15));
\r
1332 AssertEquals ("-2,2_5,16", -2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16));
\r
1333 AssertEquals ("-2,2_5,17", -2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17));
\r
1334 AssertEquals ("-2,2_5,18", -2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18));
\r
1335 AssertEquals ("-2,2_5,19", -2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19));
\r
1336 AssertEquals ("-2,2_5,20", -2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20));
\r
1337 AssertEquals ("-2,2_5,21", -2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21));
\r
1338 AssertEquals ("-2,2_5,22", -2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22));
\r
1339 AssertEquals ("-2,2_5,23", -2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23));
\r
1340 AssertEquals ("-2,2_5,24", -2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24));
\r
1341 AssertEquals ("-2,2_5,25", -2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25));
\r
1342 AssertEquals ("-2,2_5,26", -2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26));
\r
1343 AssertEquals ("-2,2_5,27", -2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27));
\r
1344 AssertEquals ("-2,2_5,28", -2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28));
\r
1348 // http://bugzilla.ximian.com/show_bug.cgi?id=59425
1349 public void ParseAndKeepPrecision ()
1352 AssertEquals (value, value, Decimal.Parse (value).ToString ());
1354 for (int i=0; i < 28; i++) {
1356 AssertEquals (i.ToString(), value, Decimal.Parse (value).ToString ());
1360 AssertEquals (value, value, Decimal.Parse (value).ToString ());
1362 for (int i=0; i < 28; i++) {
1364 AssertEquals ("-" + i.ToString(), value, Decimal.Parse (value).ToString ());
1369 public void ToString_G ()
1371 AssertEquals ("00", "1.0", (1.0m).ToString ());
1372 AssertEquals ("01", "0.1", (0.1m).ToString ());
1373 AssertEquals ("02", "0.01", (0.01m).ToString ());
1374 AssertEquals ("03", "0.001", (0.001m).ToString ());
1375 AssertEquals ("04", "0.0001", (0.0001m).ToString ());
1376 AssertEquals ("05", "0.00001", (0.00001m).ToString ());
1377 AssertEquals ("06", "0.000001", (0.000001m).ToString ());
1378 AssertEquals ("07", "0.0000001", (0.0000001m).ToString ());
1379 AssertEquals ("08", "0.00000001", (0.00000001m).ToString ());
1380 AssertEquals ("09", "0.000000001", (0.000000001m).ToString ());
1381 AssertEquals ("10", "0.0000000001", (0.0000000001m).ToString ());
1382 AssertEquals ("11", "0.00000000001", (0.00000000001m).ToString ());
1383 AssertEquals ("12", "0.000000000001", (0.000000000001m).ToString ());
1384 AssertEquals ("13", "0.0000000000001", (0.0000000000001m).ToString ());
1385 AssertEquals ("14", "0.00000000000001", (0.00000000000001m).ToString ());
1386 AssertEquals ("15", "0.000000000000001", (0.000000000000001m).ToString ());
1387 AssertEquals ("16", "0.0000000000000001", (0.0000000000000001m).ToString ());
1388 AssertEquals ("17", "0.00000000000000001", (0.00000000000000001m).ToString ());
1389 AssertEquals ("18", "0.000000000000000001", (0.000000000000000001m).ToString ());
1390 AssertEquals ("19", "0.0000000000000000001", (0.0000000000000000001m).ToString ());
1391 AssertEquals ("20", "0.00000000000000000001", (0.00000000000000000001m).ToString ());
1392 AssertEquals ("21", "0.000000000000000000001", (0.000000000000000000001m).ToString ());
1393 AssertEquals ("22", "0.0000000000000000000001", (0.0000000000000000000001m).ToString ());
1394 AssertEquals ("23", "0.00000000000000000000001", (0.00000000000000000000001m).ToString ());
1395 AssertEquals ("24", "0.000000000000000000000001", (0.000000000000000000000001m).ToString ());
1396 AssertEquals ("25", "0.0000000000000000000000001", (0.0000000000000000000000001m).ToString ());
1397 AssertEquals ("26", "0.00000000000000000000000001", (0.00000000000000000000000001m).ToString ());
1398 AssertEquals ("27", "0.000000000000000000000000001", (0.000000000000000000000000001m).ToString ());
1399 AssertEquals ("28", "0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString ());