+ [Test]
+ public void Truncate ()
+ {
+ decimal dd = 249.9m;
+ decimal dt = Decimal.Truncate (dd);
+ Assert.AreEqual (249.9m, dd, "Original");
+ Assert.AreEqual (249m, dt, "Truncate");
+ Assert.AreEqual (249, (byte) dd, "Cast-Byte");
+ Assert.AreEqual (249, (char) dd, "Cast-Char");
+ Assert.AreEqual (249, (short) dd, "Cast-Int16");
+ Assert.AreEqual (249, (ushort) dd, "Cast-UInt16");
+ Assert.AreEqual (249, (int) dd, "Cast-Int32");
+ Assert.AreEqual (249, (uint) dd, "Cast-UInt32");
+ Assert.AreEqual (249, (long) dd, "Cast-Int64");
+ Assert.AreEqual (249, (ulong) dd, "Cast-UInt64");
+ }
+
+ [Test]
+ public void TestRound ()
+ {
+ decimal [,] dtab = {
+ {1m, 0, 1m}, {1.234567890m, 1, 1.2m},
+ {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m},
+ {1.2355m, 3, 1.236m},
+ {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m},
+ {47893764694.4578563236436621m, 7, 47893764694.4578563m},
+ {-47893764694.4578563236436621m, 9, -47893764694.457856324m},
+ {-47893764694.4578m, 5, -47893764694.4578m}
+ };
+
+ decimal d;
+
+ for (int i = 0; i < dtab.GetLength (0); i++) {
+ d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
+ if (d != dtab [i, 2]) {
+ Assert.Fail ("Round: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
+ }
+ }
+ }
+
+ [Test]
+ public void TestRoundFailures ()
+ {
+ decimal [,] dtab = {
+ {1.2345m, 3, 1.234m}
+ };
+
+ decimal d;
+
+ for (int i = 0; i < dtab.GetLength (0); i++) {
+ d = Decimal.Round (dtab [i, 0], (int) dtab [i, 1]);
+ if (d != dtab [i, 2]) {
+ Assert.Fail ("FailRound: Round(" + dtab [i, 0] + "," + (int) dtab [i, 1] + ") != " + d);
+ }
+ }
+ }
+
+ [Test]
+ public void ParseInt64 ()
+ {
+ long max = Int64.MaxValue;
+ Decimal dmax = Decimal.Parse (max.ToString ());
+ Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax), "Int64.MaxValue");
+
+ long min = Int64.MinValue;
+ Decimal dmin = Decimal.Parse (min.ToString ());
+ Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin), "Int64.MinValue");
+
+ dmax += 1.1m;
+ dmax = Decimal.Parse (dmax.ToString ());
+ Assert.AreEqual (Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m), "Int64.MaxValue+1.1");
+
+ dmin -= 1.1m;
+ dmin = Decimal.Parse (dmin.ToString ());
+ Assert.AreEqual (Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m), "Int64.MinValue-1.1");
+ }
+
+ [Test]
+ public void ToByte ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254, Decimal.ToByte (d), "Decimal.ToByte");
+ Assert.AreEqual (255, Convert.ToByte (d), "Convert.ToByte");
+ Assert.AreEqual (255, (d as IConvertible).ToByte (null), "IConvertible.ToByte");
+ }
+
+ [Test]
+ public void ToSByte ()
+ {
+ Decimal d = 126.9m;
+ Assert.AreEqual (126, Decimal.ToSByte (d), "Decimal.ToSByte");
+ Assert.AreEqual (127, Convert.ToSByte (d), "Convert.ToSByte");
+ Assert.AreEqual (127, (d as IConvertible).ToSByte (null), "IConvertible.ToSByte");
+ d = -d;
+ Assert.AreEqual (-126, Decimal.ToSByte (d), "-Decimal.ToSByte");
+ Assert.AreEqual (-127, Convert.ToSByte (d), "-Convert.ToSByte");
+ Assert.AreEqual (-127, (d as IConvertible).ToSByte (null), "-IConvertible.ToSByte");
+ }
+
+ [Test]
+ public void ToInt16 ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254, Decimal.ToInt16 (d), "Decimal.ToInt16");
+ Assert.AreEqual (255, Convert.ToInt16 (d), "Convert.ToInt16");
+ Assert.AreEqual (255, (d as IConvertible).ToInt16 (null), "IConvertible.ToInt16");
+ d = -d;
+ Assert.AreEqual (-254, Decimal.ToInt16 (d), "-Decimal.ToInt16");
+ Assert.AreEqual (-255, Convert.ToInt16 (d), "-Convert.ToInt16");
+ Assert.AreEqual (-255, (d as IConvertible).ToInt16 (null), "-IConvertible.ToInt16");
+ }
+
+ [Test]
+ public void ToUInt16 ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254, Decimal.ToUInt16 (d), "Decimal.ToUInt16");
+ Assert.AreEqual (255, Convert.ToUInt16 (d), "Convert.ToUInt16");
+ Assert.AreEqual (255, (d as IConvertible).ToUInt16 (null), "IConvertible.ToUInt16");
+ }
+
+ [Test]
+ public void ToInt32 ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254, Decimal.ToInt32 (d), "Decimal.ToInt32");
+ Assert.AreEqual (255, Convert.ToInt32 (d), "Convert.ToInt32");
+ Assert.AreEqual (255, (d as IConvertible).ToInt32 (null), "IConvertible.ToInt32");
+ d = -d;
+ Assert.AreEqual (-254, Decimal.ToInt32 (d), "-Decimal.ToInt32");
+ Assert.AreEqual (-255, Convert.ToInt32 (d), "-Convert.ToInt32");
+ Assert.AreEqual (-255, (d as IConvertible).ToInt32 (null), "-IConvertible.ToInt32");
+ }
+
+ [Test]
+ public void ToUInt32 ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254, Decimal.ToUInt32 (d), "Decimal.ToUInt32");
+ Assert.AreEqual (255, Convert.ToUInt32 (d), "Convert.ToUInt32");
+ Assert.AreEqual (255, (d as IConvertible).ToUInt32 (null), "IConvertible.ToUInt32");
+ }
+
+ [Test]
+ public void ToInt64 ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254, Decimal.ToInt64 (d), "Decimal.ToInt64");
+ Assert.AreEqual (255, Convert.ToInt64 (d), "Convert.ToInt64");
+ Assert.AreEqual (255, (d as IConvertible).ToInt64 (null), "IConvertible.ToInt64");
+ d = -d;
+ Assert.AreEqual (-254, Decimal.ToInt64 (d), "-Decimal.ToInt64");
+ Assert.AreEqual (-255, Convert.ToInt64 (d), "-Convert.ToInt64");
+ Assert.AreEqual (-255, (d as IConvertible).ToInt64 (null), "-IConvertible.ToInt64");
+ }
+
+ [Test]
+ [ExpectedException (typeof (OverflowException))]
+ public void ToInt64_TooBig ()
+ {
+ Decimal d = (Decimal) Int64.MaxValue;
+ d += 1.1m;
+ long value = Decimal.ToInt64 (d);
+ }
+
+ [Test]
+ [ExpectedException (typeof (OverflowException))]
+ public void ToInt64_TooSmall ()
+ {
+ Decimal d = (Decimal) Int64.MinValue;
+ d -= 1.1m;
+ long value = Decimal.ToInt64 (d);
+ }
+
+ [Test]
+ public void ToUInt64 ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254, Decimal.ToUInt64 (d), "Decimal.ToUInt64");
+ Assert.AreEqual (255, Convert.ToUInt64 (d), "Convert.ToUInt64");
+ Assert.AreEqual (255, (d as IConvertible).ToUInt64 (null), "IConvertible.ToUInt64");
+ }
+
+ [Test]
+ public void ToSingle ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254.9f, Decimal.ToSingle (d), "Decimal.ToSingle");
+ Assert.AreEqual (254.9f, Convert.ToSingle (d), "Convert.ToSingle");
+ Assert.AreEqual (254.9f, (d as IConvertible).ToSingle (null), "IConvertible.ToSingle");
+ d = -d;
+ Assert.AreEqual (-254.9f, Decimal.ToSingle (d), "-Decimal.ToSingle");
+ Assert.AreEqual (-254.9f, Convert.ToSingle (d), "-Convert.ToSingle");
+ Assert.AreEqual (-254.9f, (d as IConvertible).ToSingle (null), "-IConvertible.ToSingle");
+ }
+
+ [Test]
+ public void ToDouble ()
+ {
+ Decimal d = 254.9m;
+ Assert.AreEqual (254.9d, Decimal.ToDouble (d), "Decimal.ToDouble");
+ Assert.AreEqual (254.9d, Convert.ToDouble (d), "Convert.ToDouble");
+ Assert.AreEqual (254.9d, (d as IConvertible).ToDouble (null), "IConvertible.ToDouble");
+ d = -d;
+ Assert.AreEqual (-254.9d, Decimal.ToDouble (d), "-Decimal.ToDouble");
+ Assert.AreEqual (-254.9d, Convert.ToDouble (d), "-Convert.ToDouble");
+ Assert.AreEqual (-254.9d, (d as IConvertible).ToDouble (null), "-IConvertible.ToDouble");
+ }
+
+ [Test]
+ [SetCulture("en-US")]
+ public void ToString_Defaults ()
+ {
+ Decimal d = 254.9m;
+ // everything defaults to "G"
+ string def = d.ToString ("G");
+ Assert.AreEqual (def, d.ToString (), "ToString()");
+ Assert.AreEqual (def, d.ToString ((IFormatProvider) null), "ToString((IFormatProvider)null)");
+ Assert.AreEqual (def, d.ToString ((string) null), "ToString((string)null)");
+ Assert.AreEqual (def, d.ToString (String.Empty), "ToString(empty)");
+ Assert.AreEqual (def, d.ToString (null, null), "ToString(null,null)");
+ Assert.AreEqual (def, d.ToString (String.Empty, null), "ToString(empty,null)");
+
+ Assert.AreEqual ("254.9", def, "ToString()");
+ }
+
+ [Test]
+ public void CastTruncRounding ()
+ {
+ // casting truncs decimal value (not normal nor banker's rounding)
+ Assert.AreEqual (254, (long) (254.9m), "254.9==254");
+ Assert.AreEqual (-254, (long) (-254.9m), "-254.9=-254");
+ Assert.AreEqual (255, (long) (255.9m), "255.9==256");
+ Assert.AreEqual (-255, (long) (-255.9m), "-255.9=-256");
+ }
+
+ [Test]
+ public void ParseFractions ()
+ {
+ decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);
+ Assert.AreEqual (0.5234567890123454678901234568m, d1, "f1");
+ decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);
+ Assert.AreEqual (0.4921420654348652943463423146m, d2, "f2");
+ }
+
+ [Test]
+ [ExpectedException (typeof (OverflowException))]
+ public void Parse_Int64_Overflow ()
+ {
+ // Int64.MaxValue + 1 + small fraction to allow 30 digits
+ // 123456789012345678901234567890
+ decimal d = Decimal.Parse ("9223372036854775808.0000000009", CultureInfo.InvariantCulture);
+ long l = (long) d;
+ }
+/* Not yet fixed
+ [Test]
+ public void ParseEmptyNumberGroupSeparator ()
+ {
+ CultureInfo originalCulture = CultureInfo.CurrentCulture;
+ Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
+ try {
+ var nf = new NumberFormatInfo ();
+ nf.NumberDecimalSeparator = ".";
+ nf.NumberGroupSeparator = "";
+ decimal d = decimal.Parse ("4.5", nf);
+ Assert.AreEqual (4.5, d);
+ } finally {
+ Thread.CurrentThread.CurrentCulture = originalCulture;
+ }
+ }
+*/
+
+ [Test]
+ public void ParseCultureSeparator ()
+ {
+ Assert.AreEqual (2.2m, decimal.Parse ("2.2", new CultureInfo("es-MX")));
+ }
+
+ [Test]
+ [Category ("TargetJvmNotWorking")]
+ public void TryParse ()
+ {
+ Decimal r;
+
+ // These should return false
+ Assert.AreEqual (false, Decimal.TryParse ("79228162514264337593543950336", out r));
+ Assert.AreEqual (false, Decimal.TryParse ("123nx", NumberStyles.Number, CultureInfo.InvariantCulture, out r));
+ Assert.AreEqual (false, Decimal.TryParse (null, NumberStyles.Number, CultureInfo.InvariantCulture, out r));
+
+ // These should pass
+ for (int i = 0; i < tab.Length; i++) {
+ Assert.AreEqual (!tab [i].exceptionFlag,
+ Decimal.TryParse (tab [i].str, tab [i].style,
+ NumberFormatInfo.InvariantInfo, out r));
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (DivideByZeroException))]
+ public void Remainder_ByZero ()
+ {
+ Decimal.Remainder (254.9m, 0m);
+ }
+
+ [Test]
+ public void Remainder ()
+ {
+ decimal p1 = 254.9m;
+ decimal p2 = 12.1m;
+ decimal n1 = -254.9m;
+ decimal n2 = -12.1m;
+
+ Assert.AreEqual (0.8m, Decimal.Remainder (p1, p2), "254.9 % 12.1");
+ Assert.AreEqual (-0.8m, Decimal.Remainder (n1, p2), "-254.9 % 12.1");
+ Assert.AreEqual (0.8m, Decimal.Remainder (p1, n2), "254.9 % -12.1");
+ Assert.AreEqual (-0.8m, Decimal.Remainder (n1, n2), "-254.9 % -12.1");
+
+ Assert.AreEqual (12.1m, Decimal.Remainder (p2, p1), "12.1 % 254.9");
+ Assert.AreEqual (-12.1m, Decimal.Remainder (n2, p1), "-12.1 % 254.9");
+ Assert.AreEqual (12.1m, Decimal.Remainder (p2, n1), "12.1 % -254.9");
+ Assert.AreEqual (-12.1m, Decimal.Remainder (n2, n1), "-12.1 % -254.9");
+
+ Assert.AreEqual (0.0m, Decimal.Remainder (p1, p1), "12.1 % 12.1");
+ Assert.AreEqual (0.0m, Decimal.Remainder (n1, p1), "-12.1 % 12.1");
+ Assert.AreEqual (0.0m, Decimal.Remainder (p1, n1), "12.1 % -12.1");
+ Assert.AreEqual (0.0m, Decimal.Remainder (n1, n1), "-12.1 % -12.1");
+ }
+
+ [Test]
+ public void Remainder2 ()
+ {
+ decimal a = 20.0M;
+ decimal b = 10.0M;
+ decimal c = 10.00M;
+
+ Assert.AreEqual (0.00m, a % c, "20.0M % 10.00M");
+
+ }
+
+ [Test]
+ [ExpectedException (typeof (DivideByZeroException))]
+ public void Divide_ByZero ()
+ {
+ Decimal.Divide (254.9m, 0m);
+ }
+
+ [Test]
+ public void Divide ()
+ {
+ decimal p1 = 254.9m;
+ decimal p2 = 12.1m;
+ decimal n1 = -254.9m;
+ decimal n2 = -12.1m;
+
+ decimal c1 = 21.066115702479338842975206612m;
+ decimal c2 = 0.0474695959199686151431934092m;
+
+ Assert.AreEqual (c1, Decimal.Divide (p1, p2), "254.9 / 12.1");
+ Assert.AreEqual (-c1, Decimal.Divide (n1, p2), "-254.9 / 12.1");
+ Assert.AreEqual (-c1, Decimal.Divide (p1, n2), "254.9 / -12.1");
+ Assert.AreEqual (c1, Decimal.Divide (n1, n2), "-254.9 / -12.1");
+
+ Assert.AreEqual (c2, Decimal.Divide (p2, p1), "12.1 / 254.9");
+ Assert.AreEqual (-c2, Decimal.Divide (n2, p1), "-12.1 / 254.9");
+ Assert.AreEqual (-c2, Decimal.Divide (p2, n1), "12.1 / -254.9");
+ Assert.AreEqual (c2, Decimal.Divide (n2, n1), "-12.1 / -254.9");
+
+ Assert.AreEqual (1, Decimal.Divide (p1, p1), "12.1 / 12.1");
+ Assert.AreEqual (-1, Decimal.Divide (n1, p1), "-12.1 / 12.1");
+ Assert.AreEqual (-1, Decimal.Divide (p1, n1), "12.1 / -12.1");
+ Assert.AreEqual (1, Decimal.Divide (n1, n1), "-12.1 / -12.1");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Round_InvalidDecimals_Negative ()
+ {
+ Decimal.Round (254.9m, -1);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentOutOfRangeException))]
+ public void Round_InvalidDecimals_TooHigh ()
+ {
+ Decimal.Round (254.9m, 29);
+ }
+
+ [Test]
+ public void Round_OddValue ()
+ {
+ decimal five = 5.5555555555555555555555555555m;
+ Assert.AreEqual (6, Decimal.Round (five, 0), "5,5_,00");
+ Assert.AreEqual (5.6m, Decimal.Round (five, 1), "5,5_,01");
+ Assert.AreEqual (5.56m, Decimal.Round (five, 2), "5,5_,02");
+ Assert.AreEqual (5.556m, Decimal.Round (five, 3), "5,5_,03");
+ Assert.AreEqual (5.5556m, Decimal.Round (five, 4), "5,5_,04");
+ Assert.AreEqual (5.55556m, Decimal.Round (five, 5), "5,5_,05");
+ Assert.AreEqual (5.555556m, Decimal.Round (five, 6), "5,5_,06");
+ Assert.AreEqual (5.5555556m, Decimal.Round (five, 7), "5,5_,07");
+ Assert.AreEqual (5.55555556m, Decimal.Round (five, 8), "5,5_,08");
+ Assert.AreEqual (5.555555556m, Decimal.Round (five, 9), "5,5_,09");
+ Assert.AreEqual (5.5555555556m, Decimal.Round (five, 10), "5,5_,10");
+ Assert.AreEqual (5.55555555556m, Decimal.Round (five, 11), "5,5_,11");
+ Assert.AreEqual (5.555555555556m, Decimal.Round (five, 12), "5,5_,12");
+ Assert.AreEqual (5.5555555555556m, Decimal.Round (five, 13), "5,5_,13");
+ Assert.AreEqual (5.55555555555556m, Decimal.Round (five, 14), "5,5_,14");
+ Assert.AreEqual (5.555555555555556m, Decimal.Round (five, 15), "5,5_,15");
+ Assert.AreEqual (5.5555555555555556m, Decimal.Round (five, 16), "5,5_,16");
+ Assert.AreEqual (5.55555555555555556m, Decimal.Round (five, 17), "5,5_,17");
+ Assert.AreEqual (5.555555555555555556m, Decimal.Round (five, 18), "5,5_,18");
+ Assert.AreEqual (5.5555555555555555556m, Decimal.Round (five, 19), "5,5_,19");
+ Assert.AreEqual (5.55555555555555555556m, Decimal.Round (five, 20), "5,5_,20");
+ Assert.AreEqual (5.555555555555555555556m, Decimal.Round (five, 21), "5,5_,21");
+ Assert.AreEqual (5.5555555555555555555556m, Decimal.Round (five, 22), "5,5_,22");
+ Assert.AreEqual (5.55555555555555555555556m, Decimal.Round (five, 23), "5,5_,23");
+ Assert.AreEqual (5.555555555555555555555556m, Decimal.Round (five, 24), "5,5_,24");
+ Assert.AreEqual (5.5555555555555555555555556m, Decimal.Round (five, 25), "5,5_,25");
+ Assert.AreEqual (5.55555555555555555555555556m, Decimal.Round (five, 26), "5,5_,26");
+ Assert.AreEqual (5.555555555555555555555555556m, Decimal.Round (five, 27), "5,5_,27");
+ Assert.AreEqual (5.5555555555555555555555555555m, Decimal.Round (five, 28), "5.5_,28");
+ }
+
+ [Test]
+ public void Round_EvenValue ()
+ {
+ Assert.AreEqual (2, Decimal.Round (2.5m, 0), "2,2_5,00");
+ Assert.AreEqual (2.2m, Decimal.Round (2.25m, 1), "2,2_5,01");
+ Assert.AreEqual (2.22m, Decimal.Round (2.225m, 2), "2,2_5,02");
+ Assert.AreEqual (2.222m, Decimal.Round (2.2225m, 3), "2,2_5,03");
+ Assert.AreEqual (2.2222m, Decimal.Round (2.22225m, 4), "2,2_5,04");
+ Assert.AreEqual (2.22222m, Decimal.Round (2.222225m, 5), "2,2_5,05");
+ Assert.AreEqual (2.222222m, Decimal.Round (2.2222225m, 6), "2,2_5,06");
+ Assert.AreEqual (2.2222222m, Decimal.Round (2.22222225m, 7), "2,2_5,07");
+ Assert.AreEqual (2.22222222m, Decimal.Round (2.222222225m, 8), "2,2_5,08");
+ Assert.AreEqual (2.222222222m, Decimal.Round (2.2222222225m, 9), "2,2_5,09");
+ Assert.AreEqual (2.2222222222m, Decimal.Round (2.22222222225m, 10), "2,2_5,10");
+ Assert.AreEqual (2.22222222222m, Decimal.Round (2.222222222225m, 11), "2,2_5,11");
+ Assert.AreEqual (2.222222222222m, Decimal.Round (2.2222222222225m, 12), "2,2_5,12");
+ Assert.AreEqual (2.2222222222222m, Decimal.Round (2.22222222222225m, 13), "2,2_5,13");
+ Assert.AreEqual (2.22222222222222m, Decimal.Round (2.222222222222225m, 14), "2,2_5,14");
+ Assert.AreEqual (2.222222222222222m, Decimal.Round (2.2222222222222225m, 15), "2,2_5,15");
+ Assert.AreEqual (2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16), "2,2_5,16");
+ Assert.AreEqual (2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17), "2,2_5,17");
+ Assert.AreEqual (2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18), "2,2_5,18");
+ Assert.AreEqual (2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19), "2,2_5,19");
+ Assert.AreEqual (2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20), "2,2_5,20");
+ Assert.AreEqual (2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21), "2,2_5,21");
+ Assert.AreEqual (2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22), "2,2_5,22");
+ Assert.AreEqual (2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23), "2,2_5,23");
+ Assert.AreEqual (2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24), "2,2_5,24");
+ Assert.AreEqual (2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25), "2,2_5,25");
+ Assert.AreEqual (2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26), "2,2_5,26");
+ Assert.AreEqual (2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27), "2,2_5,27");
+ Assert.AreEqual (2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28), "2,2_5,28");
+ }
+
+ [Test]
+ public void Round_OddValue_Negative ()
+ {
+ decimal five = -5.5555555555555555555555555555m;
+ Assert.AreEqual (-6, Decimal.Round (five, 0), "-5,5_,00");
+ Assert.AreEqual (-5.6m, Decimal.Round (five, 1), "-5,5_,01");
+ Assert.AreEqual (-5.56m, Decimal.Round (five, 2), "-5,5_,02");
+ Assert.AreEqual (-5.556m, Decimal.Round (five, 3), "-5,5_,03");
+ Assert.AreEqual (-5.5556m, Decimal.Round (five, 4), "-5,5_,04");
+ Assert.AreEqual (-5.55556m, Decimal.Round (five, 5), "-5,5_,05");
+ Assert.AreEqual (-5.555556m, Decimal.Round (five, 6), "-5,5_,06");
+ Assert.AreEqual (-5.5555556m, Decimal.Round (five, 7), "-5,5_,07");
+ Assert.AreEqual (-5.55555556m, Decimal.Round (five, 8), "-5,5_,08");
+ Assert.AreEqual (-5.555555556m, Decimal.Round (five, 9), "-5,5_,09");
+ Assert.AreEqual (-5.5555555556m, Decimal.Round (five, 10), "-5,5_,10");
+ Assert.AreEqual (-5.55555555556m, Decimal.Round (five, 11), "-5,5_,11");
+ Assert.AreEqual (-5.555555555556m, Decimal.Round (five, 12), "-5,5_,12");
+ Assert.AreEqual (-5.5555555555556m, Decimal.Round (five, 13), "-5,5_,13");
+ Assert.AreEqual (-5.55555555555556m, Decimal.Round (five, 14), "-5,5_,14");
+ Assert.AreEqual (-5.555555555555556m, Decimal.Round (five, 15), "-5,5_,15");
+ Assert.AreEqual (-5.5555555555555556m, Decimal.Round (five, 16), "-5,5_,16");
+ Assert.AreEqual (-5.55555555555555556m, Decimal.Round (five, 17), "-5,5_,17");
+ Assert.AreEqual (-5.555555555555555556m, Decimal.Round (five, 18), "-5,5_,18");
+ Assert.AreEqual (-5.5555555555555555556m, Decimal.Round (five, 19), "-5,5_,19");
+ Assert.AreEqual (-5.55555555555555555556m, Decimal.Round (five, 20), "-5,5_,20");
+ Assert.AreEqual (-5.555555555555555555556m, Decimal.Round (five, 21), "-5,5_,21");
+ Assert.AreEqual (-5.5555555555555555555556m, Decimal.Round (five, 22), "-5,5_,22");
+ Assert.AreEqual (-5.55555555555555555555556m, Decimal.Round (five, 23), "-5,5_,23");
+ Assert.AreEqual (-5.555555555555555555555556m, Decimal.Round (five, 24), "-5,5_,24");
+ Assert.AreEqual (-5.5555555555555555555555556m, Decimal.Round (five, 25), "-5,5_,25");
+ Assert.AreEqual (-5.55555555555555555555555556m, Decimal.Round (five, 26), "-5,5_,26");
+ Assert.AreEqual (-5.555555555555555555555555556m, Decimal.Round (five, 27), "-5,5_,27");
+ Assert.AreEqual (-5.5555555555555555555555555555m, Decimal.Round (five, 28), "-5.5_,28");
+ }
+
+ [Test]
+ public void Round_EvenValue_Negative ()
+ {
+ Assert.AreEqual (-2, Decimal.Round (-2.5m, 0), "-2,2_5,00");
+ Assert.AreEqual (-2.2m, Decimal.Round (-2.25m, 1), "-2,2_5,01");
+ Assert.AreEqual (-2.22m, Decimal.Round (-2.225m, 2), "-2,2_5,02");
+ Assert.AreEqual (-2.222m, Decimal.Round (-2.2225m, 3), "-2,2_5,03");
+ Assert.AreEqual (-2.2222m, Decimal.Round (-2.22225m, 4), "-2,2_5,04");
+ Assert.AreEqual (-2.22222m, Decimal.Round (-2.222225m, 5), "-2,2_5,05");
+ Assert.AreEqual (-2.222222m, Decimal.Round (-2.2222225m, 6), "-2,2_5,06");
+ Assert.AreEqual (-2.2222222m, Decimal.Round (-2.22222225m, 7), "-2,2_5,07");
+ Assert.AreEqual (-2.22222222m, Decimal.Round (-2.222222225m, 8), "-2,2_5,08");
+ Assert.AreEqual (-2.222222222m, Decimal.Round (-2.2222222225m, 9), "-2,2_5,09");
+ Assert.AreEqual (-2.2222222222m, Decimal.Round (-2.22222222225m, 10), "-2,2_5,10");
+ Assert.AreEqual (-2.22222222222m, Decimal.Round (-2.222222222225m, 11), "-2,2_5,11");
+ Assert.AreEqual (-2.222222222222m, Decimal.Round (-2.2222222222225m, 12), "-2,2_5,12");
+ Assert.AreEqual (-2.2222222222222m, Decimal.Round (-2.22222222222225m, 13), "-2,2_5,13");
+ Assert.AreEqual (-2.22222222222222m, Decimal.Round (-2.222222222222225m, 14), "-2,2_5,14");
+ Assert.AreEqual (-2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15), "-2,2_5,15");
+ Assert.AreEqual (-2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16), "-2,2_5,16");
+ Assert.AreEqual (-2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17), "-2,2_5,17");
+ Assert.AreEqual (-2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18), "-2,2_5,18");
+ Assert.AreEqual (-2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19), "-2,2_5,19");
+ Assert.AreEqual (-2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20), "-2,2_5,20");
+ Assert.AreEqual (-2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21), "-2,2_5,21");
+ Assert.AreEqual (-2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22), "-2,2_5,22");
+ Assert.AreEqual (-2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23), "-2,2_5,23");
+ Assert.AreEqual (-2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24), "-2,2_5,24");
+ Assert.AreEqual (-2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25), "-2,2_5,25");
+ Assert.AreEqual (-2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26), "-2,2_5,26");
+ Assert.AreEqual (-2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27), "-2,2_5,27");
+ Assert.AreEqual (-2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28), "-2,2_5,28");
+ }
+
+ [Test] // bug #59425
+ [SetCulture("en-US")]
+ public void ParseAndKeepPrecision ()
+ {
+ string value = "5";
+ Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
+ value += '.';
+ for (int i = 0; i < 28; i++) {
+ value += "0";
+ Assert.AreEqual (value, Decimal.Parse (value).ToString (), i.ToString ());
+ }
+
+ value = "-5";
+ Assert.AreEqual (value, value, Decimal.Parse (value).ToString ());
+ value += '.';
+ for (int i = 0; i < 28; i++) {
+ value += "0";
+ Assert.AreEqual (value, Decimal.Parse (value).ToString (), "-" + i.ToString ());
+ }
+ }
+
+ [Test]
+ [SetCulture("en-US")]
+ public void ToString_G ()
+ {
+ Assert.AreEqual ("1.0", (1.0m).ToString (), "00");
+ Assert.AreEqual ("0.1", (0.1m).ToString (), "01");
+ Assert.AreEqual ("0.01", (0.01m).ToString (), "02");
+ Assert.AreEqual ("0.001", (0.001m).ToString (), "03");
+ Assert.AreEqual ("0.0001", (0.0001m).ToString (), "04");
+ Assert.AreEqual ("0.00001", (0.00001m).ToString (), "05");
+ Assert.AreEqual ("0.000001", (0.000001m).ToString (), "06");
+ Assert.AreEqual ("0.0000001", (0.0000001m).ToString (), "07");
+ Assert.AreEqual ("0.00000001", (0.00000001m).ToString (), "08");
+ Assert.AreEqual ("0.000000001", (0.000000001m).ToString (), "09");
+ Assert.AreEqual ("0.0000000001", (0.0000000001m).ToString (), "10");
+ Assert.AreEqual ("0.00000000001", (0.00000000001m).ToString (), "11");
+ Assert.AreEqual ("0.000000000001", (0.000000000001m).ToString (), "12");
+ Assert.AreEqual ("0.0000000000001", (0.0000000000001m).ToString (), "13");
+ Assert.AreEqual ("0.00000000000001", (0.00000000000001m).ToString (), "14");
+ Assert.AreEqual ("0.000000000000001", (0.000000000000001m).ToString (), "15");
+ Assert.AreEqual ("0.0000000000000001", (0.0000000000000001m).ToString (), "16");
+ Assert.AreEqual ("0.00000000000000001", (0.00000000000000001m).ToString (), "17");
+ Assert.AreEqual ("0.000000000000000001", (0.000000000000000001m).ToString (), "18");
+ Assert.AreEqual ("0.0000000000000000001", (0.0000000000000000001m).ToString (), "19");
+ Assert.AreEqual ("0.00000000000000000001", (0.00000000000000000001m).ToString (), "20");
+ Assert.AreEqual ("0.000000000000000000001", (0.000000000000000000001m).ToString (), "21");
+ Assert.AreEqual ("0.0000000000000000000001", (0.0000000000000000000001m).ToString (), "22");
+ Assert.AreEqual ("0.00000000000000000000001", (0.00000000000000000000001m).ToString (), "23");
+ Assert.AreEqual ("0.000000000000000000000001", (0.000000000000000000000001m).ToString (), "24");
+ Assert.AreEqual ("0.0000000000000000000000001", (0.0000000000000000000000001m).ToString (), "25");
+ Assert.AreEqual ("0.00000000000000000000000001", (0.00000000000000000000000001m).ToString (), "26");
+ Assert.AreEqual ("0.000000000000000000000000001", (0.000000000000000000000000001m).ToString (), "27");
+ Assert.AreEqual ("0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString (), "28");
+ }
+
+ [Test]
+ public void MidpointRoundingAwayFromZero ()
+ {
+ MidpointRounding m = MidpointRounding.AwayFromZero;
+ Assert.AreEqual (4, Math.Round (3.5M, m), "#1");
+ Assert.AreEqual (3, Math.Round (2.8M, m), "#2");
+ Assert.AreEqual (3, Math.Round (2.5M, m), "#3");
+ Assert.AreEqual (2, Math.Round (2.1M, m), "#4");
+ Assert.AreEqual (-2, Math.Round (-2.1M, m), "#5");
+ Assert.AreEqual (-3, Math.Round (-2.5M, m), "#6");
+ Assert.AreEqual (-3, Math.Round (-2.8M, m), "#7");
+ Assert.AreEqual (-4, Math.Round (-3.5M, m), "#8");
+
+ Assert.AreEqual (3.1M, Math.Round (3.05M, 1, m), "#9");
+ Assert.AreEqual (2.1M, Math.Round (2.08M, 1, m), "#10");
+ Assert.AreEqual (2.1M, Math.Round (2.05M, 1, m), "#11");
+ Assert.AreEqual (2.0M, Math.Round (2.01M, 1, m), "#12");
+ Assert.AreEqual (-2.0M, Math.Round (-2.01M, 1, m), "#13");
+ Assert.AreEqual (-2.1M, Math.Round (-2.05M, 1, m), "#14");
+ Assert.AreEqual (-2.1M, Math.Round (-2.08M, 1, m), "#15");
+ Assert.AreEqual (-3.1M, Math.Round (-3.05M, 1, m), "#16");
+ }
+
+ [Test] // bug #4814
+ [SetCulture("")]
+ public void Parse_NumberGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
+ {
+ NumberFormatInfo nf = new NumberFormatInfo ();
+ nf.NumberGroupSeparator = "";
+ Decimal.Parse ("1.5", nf);
+ }
+
+ [Test] // bug #4814
+ [SetCulture("")]
+ public void Parse_CurrencyGroupSeparatorIsEmpty_DoNotThrowIndexOutOfRangeException ()
+ {
+ NumberFormatInfo nf = new NumberFormatInfo ();
+ nf.CurrencyGroupSeparator = "";
+ Decimal.Parse ("\u00A41.5", NumberStyles.Currency, nf);
+ }
+
+ [Test] // bug #4814
+ [SetCulture("")]
+ public void Parse_LeadingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
+ {
+ NumberFormatInfo nf = new NumberFormatInfo ();
+ nf.PositiveSign = "";
+ try {
+ Decimal.Parse ("+15", nf);
+ } catch (FormatException) {
+ return;
+ }
+
+ Assert.Fail ("Expected FormatException");
+ }
+
+ [Test] // bug #4814
+ [SetCulture("")]
+ public void Parse_LeadingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
+ {
+ NumberFormatInfo nf = new NumberFormatInfo ();
+ nf.NegativeSign = "";
+ try {
+ Decimal.Parse ("-15", nf);
+ } catch (FormatException) {
+ return;
+ }
+
+ Assert.Fail ("Expected FormatException");
+ }
+
+ [Test] // bug #4814
+ [SetCulture("")]
+ public void Parse_TrailingSign_PositiveSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
+ {
+ NumberFormatInfo nf = new NumberFormatInfo ();
+ nf.PositiveSign = "";
+ try {
+ Decimal.Parse ("15+", nf);
+ } catch (FormatException) {
+ return;
+ }
+
+ Assert.Fail ("Expected FormatException");
+ }
+
+ [Test] // bug #4814
+ [SetCulture("")]
+ public void Parse_TrailingSign_NegativeSignIsEmpty_DoNotThrowIndexOutOfRangeException ()
+ {
+ NumberFormatInfo nf = new NumberFormatInfo ();
+ nf.NegativeSign = "";
+ try {
+ Decimal.Parse ("15-", nf);
+ } catch (FormatException) {
+ return;
+ }
+
+ Assert.Fail ("Expected FormatException");
+ }
+
+ [Test]
+ [SetCulture("en-US")]
+ public void ParseZeros ()
+ {
+ var d = Decimal.Parse ("0.000");
+ var bits = Decimal.GetBits (d);
+ Assert.AreEqual (0, bits[0], "#1");
+ Assert.AreEqual (0, bits[1], "#2");
+ Assert.AreEqual (0, bits[2], "#3");
+ Assert.AreEqual (196608, bits[3], "#4");
+ Assert.AreEqual ("0.000", d.ToString (), "#5");
+
+ d = Decimal.Parse("0.000000000000000000000000000000000000000000000000000000000000000000");
+ Assert.AreEqual ("0.0000000000000000000000000000", d.ToString (), "#10");
+
+ d = Decimal.Parse ("0.");
+ Assert.AreEqual ("0", d.ToString (), "#11");
+ }