-// DecimalTest.cs - NUnit Test Cases for the System.Decimal struct\r
-//\r
-// Authors:\r
-// Martin Weindel (martin.weindel@t-online.de)\r
-// Sebastien Pouliot <sebastien@ximian.com>\r
-//\r
-// (C) Martin Weindel, 2001\r
-// Copyright (C) 2004 Novell (http://www.novell.com)\r
-// \r
-\r
-using NUnit.Framework;\r
-using System;\r
-\r
-using System.Globalization;\r
-using System.Runtime.CompilerServices;\r
-using System.Threading;\r
-\r
-namespace MonoTests.System {\r
- internal struct ParseTest\r
- {\r
- public ParseTest(String str, bool exceptionFlag)\r
- {\r
- this.str = str;\r
- this.exceptionFlag = exceptionFlag;\r
- this.style = NumberStyles.Number;\r
- this.d = 0;\r
- }\r
-\r
- public ParseTest(String str, Decimal d)\r
- {\r
- this.str = str;\r
- this.exceptionFlag = false;\r
- this.style = NumberStyles.Number;\r
- this.d = d;\r
- }\r
-\r
- public ParseTest(String str, Decimal d, NumberStyles style)\r
- {\r
- this.str = str;\r
- this.exceptionFlag = false;\r
- this.style = style;\r
- this.d = d;\r
- }\r
-\r
- public String str;\r
- public Decimal d;\r
- public NumberStyles style;\r
- public bool exceptionFlag;\r
- }\r
-\r
- internal struct ToStringTest\r
- {\r
- public ToStringTest(String format, Decimal d, String str)\r
- {\r
- this.format = format;\r
- this.d = d;\r
- this.str = str;\r
- }\r
-\r
- public String format;\r
- public Decimal d;\r
- public String str;\r
- }\r
-\r
- [TestFixture]\r
- public class DecimalTest : Assertion\r
- {\r
- private const int negativeBitValue = unchecked ((int)0x80000000);\r
- private const int negativeScale4Value = unchecked ((int)0x80040000);\r
- private int [] parts0 = {0,0,0,0}; //Positive Zero.\r
- private int [] parts1 = {1,0,0,0};\r
- private int [] parts2 = {0,1,0,0};\r
- private int [] parts3 = {0,0,1,0};\r
- private int [] parts4 = {0,0,0,negativeBitValue}; // Negative zero.\r
- private int [] parts5 = {1,1,1,0};\r
- private int [] partsMaxValue = {-1,-1,-1,0};\r
- private int [] partsMinValue = {-1,-1,-1,negativeBitValue};\r
- private int [] parts6 = {1234, 5678, 8888, negativeScale4Value};\r
- private NumberFormatInfo NfiUser;\r
-\r
- private CultureInfo old_culture;\r
-\r
- [TestFixtureSetUp]\r
- public void FixtureSetUp ()\r
- {\r
- old_culture = Thread.CurrentThread.CurrentCulture;\r
-\r
- // Set culture to en-US and don't let the user override.\r
- Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);\r
-\r
- NfiUser = new NumberFormatInfo();\r
- NfiUser.CurrencyDecimalDigits = 3;\r
- NfiUser.CurrencyDecimalSeparator = ",";\r
- NfiUser.CurrencyGroupSeparator = "_";\r
- NfiUser.CurrencyGroupSizes = new int[] { 2,1,0 };\r
- NfiUser.CurrencyNegativePattern = 10;\r
- NfiUser.CurrencyPositivePattern = 3;\r
- NfiUser.CurrencySymbol = "XYZ";\r
- NfiUser.NumberDecimalSeparator = "##";\r
- NfiUser.NumberDecimalDigits = 4;\r
- NfiUser.NumberGroupSeparator = "__";\r
- NfiUser.NumberGroupSizes = new int[] { 2,1 };\r
- NfiUser.PercentDecimalDigits = 1;\r
- NfiUser.PercentDecimalSeparator = ";";\r
- NfiUser.PercentGroupSeparator = "~";\r
- NfiUser.PercentGroupSizes = new int[] {1};\r
- NfiUser.PercentNegativePattern = 2;\r
- NfiUser.PercentPositivePattern = 2;\r
- NfiUser.PercentSymbol = "%%%";\r
- }\r
-\r
- [TestFixtureTearDown]\r
- public void FixtureTearDown ()\r
- {\r
- Thread.CurrentThread.CurrentCulture = old_culture;\r
- }\r
-\r
- public void TestToString()\r
- {\r
- ToStringTest[] tab = {\r
- new ToStringTest("F", 12.345678m, "12.35"),\r
- new ToStringTest("F3", 12.345678m, "12.346"),\r
- new ToStringTest("F0", 12.345678m, "12"),\r
- new ToStringTest("F7", 12.345678m, "12.3456780"),\r
- new ToStringTest("g", 12.345678m, "12.345678"),\r
- new ToStringTest("E", 12.345678m, "1.234568E+001"),\r
- new ToStringTest("E3", 12.345678m, "1.235E+001"),\r
- new ToStringTest("E0", 12.345678m, "1E+001"),\r
- new ToStringTest("e8", 12.345678m, "1.23456780e+001"),\r
- new ToStringTest("F", 0.0012m, "0.00"),\r
- new ToStringTest("F3", 0.0012m, "0.001"),\r
- new ToStringTest("F0", 0.0012m, "0"),\r
- new ToStringTest("F6", 0.0012m, "0.001200"),\r
- new ToStringTest("e", 0.0012m, "1.200000e-003"),\r
- new ToStringTest("E3", 0.0012m, "1.200E-003"),\r
- new ToStringTest("E0", 0.0012m, "1E-003"),\r
- new ToStringTest("E6", 0.0012m, "1.200000E-003"),\r
- new ToStringTest("F4", -0.001234m, "-0.0012"),\r
- new ToStringTest("E3", -0.001234m, "-1.234E-003"),\r
-#if NET_1_0\r
- new ToStringTest("g", -0.000012m, "-1.2e-05"),\r
-#else\r
- new ToStringTest("g", -0.000012m, "-0.000012"),\r
-#endif\r
- new ToStringTest("g", -0.00012m, "-0.00012"),\r
- new ToStringTest("g4", -0.00012m, "-0.00012"),\r
- new ToStringTest("g7", -0.00012m, "-0.00012"),\r
- new ToStringTest("g", -0.0001234m, "-0.0001234"),\r
- new ToStringTest("g", -0.0012m, "-0.0012"),\r
- new ToStringTest("g", -0.001234m, "-0.001234"),\r
- new ToStringTest("g", -0.012m, "-0.012"),\r
- new ToStringTest("g4", -0.012m, "-0.012"),\r
- new ToStringTest("g", -0.12m, "-0.12"),\r
- new ToStringTest("g", -1.2m, "-1.2"),\r
- new ToStringTest("g4", -120m, "-120"),\r
- new ToStringTest("g", -12m, "-12"),\r
- new ToStringTest("g", -120m, "-120"),\r
- new ToStringTest("g", -1200m, "-1200"),\r
- new ToStringTest("g4", -1200m, "-1200"),\r
- new ToStringTest("g", -1234m, "-1234"),\r
- new ToStringTest("g", -12000m, "-12000"),\r
- new ToStringTest("g4", -12000m, "-1.2e+04"),\r
- new ToStringTest("g5", -12000m, "-12000"),\r
- new ToStringTest("g", -12345m, "-12345"),\r
- new ToStringTest("g", -120000m, "-120000"),\r
- new ToStringTest("g4", -120000m, "-1.2e+05"),\r
- new ToStringTest("g5", -120000m, "-1.2e+05"),\r
- new ToStringTest("g6", -120000m, "-120000"),\r
- new ToStringTest("g", -123456.1m, "-123456.1"),\r
- new ToStringTest("g5", -123456.1m, "-1.2346e+05"),\r
- new ToStringTest("g6", -123456.1m, "-123456"),\r
- new ToStringTest("g", -1200000m, "-1200000"),\r
- new ToStringTest("g", -123456.1m, "-123456.1"),\r
- new ToStringTest("g", -123456.1m, "-123456.1"),\r
- new ToStringTest("g", -1234567.1m, "-1234567.1"),\r
- new ToStringTest("g", -12000000m, "-12000000"),\r
- new ToStringTest("g", -12345678.1m, "-12345678.1"),\r
- new ToStringTest("g", -12000000000000000000m, "-12000000000000000000"),\r
- new ToStringTest("F", -123, "-123.00"),\r
- new ToStringTest("F3", -123, "-123.000"),\r
- new ToStringTest("F0", -123, "-123"),\r
- new ToStringTest("E3", -123, "-1.230E+002"),\r
- new ToStringTest("E0", -123, "-1E+002"),\r
- new ToStringTest("E", -123, "-1.230000E+002"),\r
- new ToStringTest("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),\r
- new ToStringTest("F", Decimal.MinValue, "-79228162514264337593543950335.00"),\r
- new ToStringTest("F0", Decimal.MinValue, "-79228162514264337593543950335"),\r
- new ToStringTest("E", Decimal.MinValue, "-7.922816E+028"),\r
- new ToStringTest("E3", Decimal.MinValue, "-7.923E+028"),\r
- new ToStringTest("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),\r
- new ToStringTest("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),\r
- new ToStringTest("E0", Decimal.MinValue, "-8E+028"),\r
- new ToStringTest("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),\r
- new ToStringTest("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),\r
- new ToStringTest("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),\r
- new ToStringTest("n3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),\r
- new ToStringTest("n0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),\r
- new ToStringTest("n", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),\r
- new ToStringTest("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),\r
- new ToStringTest("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),\r
- new ToStringTest("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),\r
- new ToStringTest("P", 123456.7891m, "12,345,678.91 %"),\r
- new ToStringTest("P", -123456.7892m, "-12,345,678.92 %"),\r
- new ToStringTest("P3", 1234.56789m, "123,456.789 %"),\r
- };\r
-\r
- NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;\r
-\r
- for (int i = 0; i < tab.Length; i++) \r
- {\r
- try\r
- {\r
- string s = tab[i].d.ToString(tab[i].format, nfi);\r
- AssertEquals("A01 tab[" + i + "].format = '" + tab[i].format + "')", tab[i].str, s);\r
- } \r
- catch (OverflowException)\r
- {\r
- Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");\r
- }\r
- catch (NUnit.Framework.AssertionException e) {\r
- throw e;\r
- }\r
- catch (Exception e) {\r
- Fail ("Unexpected Exception when i = " + i + ". e = " + e);\r
- }\r
- } \r
- }\r
-\r
- public void TestCurrencyPattern()\r
- {\r
- NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
- Decimal d = -1234567.8976m;\r
- string[] ergCurrencyNegativePattern = new String[16] {\r
- "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",\r
- "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",\r
- "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",\r
- "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",\r
- };\r
-\r
- for (int i = 0; i < ergCurrencyNegativePattern.Length; i++) \r
- {\r
- nfi2.CurrencyNegativePattern = i;\r
- if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i]) \r
- {\r
- Fail("CurrencyNegativePattern #" + i + " failed: " +\r
- d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);\r
- }\r
- }\r
-\r
- d = 1234567.8976m;\r
- string[] ergCurrencyPositivePattern = new String[4] {\r
- "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",\r
- };\r
-\r
- for (int i = 0; i < ergCurrencyPositivePattern.Length; i++) \r
- {\r
- nfi2.CurrencyPositivePattern = i;\r
- if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i]) \r
- {\r
- Fail("CurrencyPositivePattern #" + i + " failed: " +\r
- d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);\r
- }\r
- }\r
- }\r
-\r
- public void TestNumberNegativePattern()\r
- {\r
- NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
- Decimal d = -1234.89765m;\r
- string[] ergNumberNegativePattern = new String[5] {\r
- "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",\r
- };\r
-\r
- for (int i = 0; i < ergNumberNegativePattern.Length; i++) \r
- {\r
- nfi2.NumberNegativePattern = i;\r
- AssertEquals ("NumberNegativePattern #" + i, ergNumberNegativePattern[i], d.ToString("N", nfi2));\r
- }\r
- }\r
- \r
- public void TestPercentPattern()\r
- {\r
- NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();\r
- Decimal d = -1234.8976m;\r
- string[] ergPercentNegativePattern = new String[3] {\r
- "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"\r
- };\r
-\r
- for (int i = 0; i < ergPercentNegativePattern.Length; i++) \r
- {\r
- nfi2.PercentNegativePattern = i;\r
- if (d.ToString("P", nfi2) != ergPercentNegativePattern[i]) \r
- {\r
- Fail("PercentNegativePattern #" + i + " failed: " +\r
- d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);\r
- }\r
- }\r
-\r
- d = 1234.8976m;\r
- string[] ergPercentPositivePattern = new String[3] {\r
- "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"\r
- };\r
-\r
- for (int i = 0; i < ergPercentPositivePattern.Length; i++) \r
- {\r
- nfi2.PercentPositivePattern = i;\r
- if (d.ToString("P", nfi2) != ergPercentPositivePattern[i]) \r
- {\r
- Fail("PercentPositivePattern #" + i + " failed: " +\r
- d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);\r
- }\r
- }\r
- }\r
-\r
- public void TestParse()\r
- {\r
- ParseTest[] tab = {\r
- new ParseTest("1.2345", 1.2345m),\r
- new ParseTest("-9876543210", -9876543210m),\r
- new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol \r
- + " ( 79,228,162,514,264,337,593,543,950,335.000 ) ", Decimal.MinValue, NumberStyles.Currency),\r
- new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),\r
- new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),\r
- new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),\r
- new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),\r
- new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),\r
- new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),\r
- new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),\r
- new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),\r
- new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)\r
- };\r
-\r
- Decimal d;\r
- for (int i = 0; i < tab.Length; i++) \r
- {\r
- try\r
- {\r
- d = Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);\r
- if (tab[i].exceptionFlag)\r
- {\r
- Fail(tab[i].str + ": missing exception !");\r
- }\r
- else if (d != tab[i].d) \r
- {\r
- Fail(tab[i].str + " != " + d);\r
- }\r
- } \r
- catch (OverflowException)\r
- {\r
- if (!tab[i].exceptionFlag)\r
- {\r
- Fail(tab[i].str + ": unexpected exception !");\r
- }\r
- }\r
- } \r
- \r
- try \r
- {\r
- d = Decimal.Parse(null);\r
- Fail("Expected ArgumentNullException");\r
- }\r
- catch (ArgumentNullException)\r
- {\r
- //ok\r
- }\r
-\r
- try \r
- {\r
- d = Decimal.Parse("123nx");\r
- Fail("Expected FormatException");\r
- }\r
- catch (FormatException)\r
- {\r
- //ok\r
- }\r
-\r
- try \r
- {\r
- d = Decimal.Parse("79228162514264337593543950336");\r
- Fail("Expected OverflowException" + d);\r
- }\r
- catch (OverflowException)\r
- {\r
- //ok\r
- }\r
- }\r
-\r
- public void TestConstants()\r
- {\r
- AssertEquals ("Zero", 0m, Decimal.Zero);\r
- AssertEquals ("One", 1m, Decimal.One);\r
- AssertEquals ("MinusOne", -1m, Decimal.MinusOne);\r
- AssertEquals ("MaxValue", 79228162514264337593543950335m, Decimal.MaxValue);\r
- AssertEquals ("MinValue", -79228162514264337593543950335m, Decimal.MinValue); \r
- Assert ("MinusOne 2", -1m == Decimal.MinusOne);\r
- }\r
-\r
- public void TestConstructInt32()\r
- {\r
- decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};\r
- int[] itab = {0, 1, -1, 123456, -1234567};\r
-\r
- Decimal d;\r
- \r
- for (int i = 0; i < dtab.GetLength(0); i++)\r
- {\r
- d = new Decimal(itab[i]);\r
- if ((decimal)d != dtab[i]) \r
- {\r
- Fail("Int32 -> Decimal: " + itab[i] + " != " + d);\r
- }\r
- else \r
- {\r
- int n = (int) d;\r
- if (n != itab[i]) \r
- {\r
- Fail("Decimal -> Int32: " + d + " != " + itab[i]);\r
- }\r
- }\r
- }\r
-\r
- d = new Decimal(Int32.MaxValue);\r
- Assert((int)d == Int32.MaxValue);\r
-\r
- d = new Decimal(Int32.MinValue);\r
- Assert((int)d == Int32.MinValue);\r
- }\r
-\r
- public void TestConstructUInt32()\r
- {\r
- decimal[] dtab = {0m, 1m, 123456m, 123456789m};\r
- uint[] itab = {0, 1, 123456, 123456789};\r
-\r
- Decimal d;\r
- \r
- for (int i = 0; i < dtab.GetLength(0); i++)\r
- {\r
- d = new Decimal(itab[i]);\r
- if ((decimal)d != dtab[i]) \r
- {\r
- Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);\r
- }\r
- else \r
- {\r
- uint n = (uint) d;\r
- if (n != itab[i]) \r
- {\r
- Fail("Decimal -> UInt32: " + d + " != " + itab[i]);\r
- }\r
- }\r
- }\r
-\r
- d = new Decimal(UInt32.MaxValue);\r
- Assert((uint)d == UInt32.MaxValue);\r
-\r
- d = new Decimal(UInt32.MinValue);\r
- Assert((uint)d == UInt32.MinValue);\r
- }\r
-\r
- public void TestConstructInt64()\r
- {\r
- decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};\r
- long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};\r
-\r
- Decimal d;\r
- \r
- for (int i = 0; i < dtab.GetLength(0); i++)\r
- {\r
- d = new Decimal(itab[i]);\r
- if ((decimal)d != dtab[i]) \r
- {\r
- Fail("Int64 -> Decimal: " + itab[i] + " != " + d);\r
- }\r
- else \r
- {\r
- long n = (long) d;\r
- if (n != itab[i]) \r
- {\r
- Fail("Decimal -> Int64: " + d + " != " + itab[i]);\r
- }\r
- }\r
- }\r
-\r
- d = new Decimal(Int64.MaxValue);\r
- Assert((long)d == Int64.MaxValue);\r
-\r
- d = new Decimal(Int64.MinValue);\r
- Assert((long)d == Int64.MinValue);\r
- }\r
-\r
- public void TestConstructUInt64()\r
- {\r
- decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};\r
- ulong[] itab = {0, 1, 987654321, 123456789876543210L};\r
-\r
- Decimal d;\r
- \r
- for (int i = 0; i < dtab.GetLength(0); i++)\r
- {\r
- d = new Decimal(itab[i]);\r
- if ((decimal)d != dtab[i]) \r
- {\r
- Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);\r
- }\r
- else \r
- {\r
- ulong n = (ulong) d;\r
- if (n != itab[i]) \r
- {\r
- Fail("Decimal -> UInt64: " + d + " != " + itab[i]);\r
- }\r
- }\r
- }\r
-\r
- d = new Decimal(UInt64.MaxValue);\r
- Assert((ulong)d == UInt64.MaxValue);\r
-\r
- d = new Decimal(UInt64.MinValue);\r
- Assert((ulong)d == UInt64.MinValue);\r
- }\r
-\r
- public void TestConstructSingle()\r
- {\r
- Decimal d;\r
-\r
- d = new Decimal(-1.2345678f);\r
- AssertEquals("A#01", -1.234568m, (decimal)d);\r
-\r
- d=3;\r
- AssertEquals("A#02", 3.0f, (float)d);\r
-\r
- d = new Decimal(0.0f);\r
- AssertEquals("A#03", 0m, (decimal)d);\r
- AssertEquals("A#04", 0.0f, (float)d);\r
-\r
- d = new Decimal(1.0f);\r
- AssertEquals("A#05", 1m, (decimal)d);\r
- AssertEquals("A#06", 1.0f, (float)d);\r
-\r
- d = new Decimal(-1.2345678f);\r
- AssertEquals("A#07", -1.234568m, (decimal)d);\r
- AssertEquals("A#08", -1.234568f, (float)d);\r
-\r
- d = new Decimal(1.2345673f);\r
- AssertEquals("A#09", 1.234567m, (decimal)d);\r
-\r
- d = new Decimal(1.2345673e7f);\r
- AssertEquals("A#10", 12345670m, (decimal)d);\r
-\r
- d = new Decimal(1.2345673e-17f);\r
- AssertEquals("A#11", 0.00000000000000001234567m, (decimal)d);\r
- AssertEquals("A#12", 1.234567e-17f, (float)d);\r
-\r
- // test exceptions\r
- try\r
- {\r
- d = new Decimal(Single.MaxValue);\r
- Fail();\r
- } \r
- catch (OverflowException) \r
- {\r
- }\r
-\r
- try\r
- {\r
- d = new Decimal(Single.NaN);\r
- Fail();\r
- } \r
- catch (OverflowException) \r
- {\r
- }\r
-\r
- try\r
- {\r
- d = new Decimal(Single.PositiveInfinity);\r
- Fail();\r
- } \r
- catch (OverflowException) \r
- {\r
- }\r
- }\r
-
- public void TestConstructSingleRounding_NowWorking ()\r
- {\r
- decimal d;\r
-\r
- d = new Decimal(1765.23454f);\r
- AssertEquals ("failed banker's rule rounding test 2", 1765.234m, d);\r
-
- d = new Decimal(0.00017652356f);\r
- AssertEquals ("06", 0.0001765236m, d);\r
-\r
- d = new Decimal(0.000176523554f);\r
- AssertEquals ("failed banker's rule rounding test 3", 0.0001765236m, d);\r
-\r
- d = new Decimal(0.00017652354f);\r
- AssertEquals ("08", 0.0001765235m, d);\r
-\r
- d = new Decimal(0.00017652346f);\r
- AssertEquals ("09", 0.0001765235m, d);\r
-\r
- d = new Decimal(0.000176523454f);\r
- AssertEquals ("failed banker's rule rounding test 4", 0.0001765234m, d);\r
-\r
- d = new Decimal(0.00017652344f);\r
- AssertEquals ("11", 0.0001765234m, d);\r
+// DecimalTest.cs - NUnit Test Cases for the System.Decimal struct
+//
+// Authors:
+// Martin Weindel (martin.weindel@t-online.de)
+// Sebastien Pouliot <sebastien@ximian.com>
+//
+// (C) Martin Weindel, 2001
+// Copyright (C) 2004 Novell (http://www.novell.com)
+//
+
+using NUnit.Framework;
+using System;
+
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Threading;
+
+namespace MonoTests.System {
+ internal struct ParseTest
+ {
+ public ParseTest(String str, bool exceptionFlag)
+ {
+ this.str = str;
+ this.exceptionFlag = exceptionFlag;
+ this.style = NumberStyles.Number;
+ this.d = 0;
+ }
+
+ public ParseTest(String str, Decimal d)
+ {
+ this.str = str;
+ this.exceptionFlag = false;
+ this.style = NumberStyles.Number;
+ this.d = d;
+ }
+
+ public ParseTest(String str, Decimal d, NumberStyles style)
+ {
+ this.str = str;
+ this.exceptionFlag = false;
+ this.style = style;
+ this.d = d;
+ }
+
+ public String str;
+ public Decimal d;
+ public NumberStyles style;
+ public bool exceptionFlag;
+ }
+
+ internal struct ToStringTest
+ {
+ public ToStringTest(String format, Decimal d, String str)
+ {
+ this.format = format;
+ this.d = d;
+ this.str = str;
+ }
+
+ public String format;
+ public Decimal d;
+ public String str;
+ }
+
+ [TestFixture]
+ public class DecimalTest : Assertion
+ {
+ private const int negativeBitValue = unchecked ((int)0x80000000);
+ private const int negativeScale4Value = unchecked ((int)0x80040000);
+ private int [] parts0 = {0,0,0,0}; //Positive Zero.
+ private int [] parts1 = {1,0,0,0};
+ private int [] parts2 = {0,1,0,0};
+ private int [] parts3 = {0,0,1,0};
+ private int [] parts4 = {0,0,0,negativeBitValue}; // Negative zero.
+ private int [] parts5 = {1,1,1,0};
+ private int [] partsMaxValue = {-1,-1,-1,0};
+ private int [] partsMinValue = {-1,-1,-1,negativeBitValue};
+ private int [] parts6 = {1234, 5678, 8888, negativeScale4Value};
+ private NumberFormatInfo NfiUser;
+
+ private CultureInfo old_culture;
+
+ [TestFixtureSetUp]
+ public void FixtureSetUp ()
+ {
+ old_culture = Thread.CurrentThread.CurrentCulture;
+
+ // Set culture to en-US and don't let the user override.
+ Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
+
+ NfiUser = new NumberFormatInfo();
+ NfiUser.CurrencyDecimalDigits = 3;
+ NfiUser.CurrencyDecimalSeparator = ",";
+ NfiUser.CurrencyGroupSeparator = "_";
+ NfiUser.CurrencyGroupSizes = new int[] { 2,1,0 };
+ NfiUser.CurrencyNegativePattern = 10;
+ NfiUser.CurrencyPositivePattern = 3;
+ NfiUser.CurrencySymbol = "XYZ";
+ NfiUser.NumberDecimalSeparator = "##";
+ NfiUser.NumberDecimalDigits = 4;
+ NfiUser.NumberGroupSeparator = "__";
+ NfiUser.NumberGroupSizes = new int[] { 2,1 };
+ NfiUser.PercentDecimalDigits = 1;
+ NfiUser.PercentDecimalSeparator = ";";
+ NfiUser.PercentGroupSeparator = "~";
+ NfiUser.PercentGroupSizes = new int[] {1};
+ NfiUser.PercentNegativePattern = 2;
+ NfiUser.PercentPositivePattern = 2;
+ NfiUser.PercentSymbol = "%%%";
+ }
+
+ [TestFixtureTearDown]
+ public void FixtureTearDown ()
+ {
+ Thread.CurrentThread.CurrentCulture = old_culture;
+ }
+
+ public void TestToString()
+ {
+ ToStringTest[] tab = {
+ new ToStringTest("F", 12.345678m, "12.35"),
+ new ToStringTest("F3", 12.345678m, "12.346"),
+ new ToStringTest("F0", 12.345678m, "12"),
+ new ToStringTest("F7", 12.345678m, "12.3456780"),
+ new ToStringTest("g", 12.345678m, "12.345678"),
+ new ToStringTest("E", 12.345678m, "1.234568E+001"),
+ new ToStringTest("E3", 12.345678m, "1.235E+001"),
+ new ToStringTest("E0", 12.345678m, "1E+001"),
+ new ToStringTest("e8", 12.345678m, "1.23456780e+001"),
+ new ToStringTest("F", 0.0012m, "0.00"),
+ new ToStringTest("F3", 0.0012m, "0.001"),
+ new ToStringTest("F0", 0.0012m, "0"),
+ new ToStringTest("F6", 0.0012m, "0.001200"),
+ new ToStringTest("e", 0.0012m, "1.200000e-003"),
+ new ToStringTest("E3", 0.0012m, "1.200E-003"),
+ new ToStringTest("E0", 0.0012m, "1E-003"),
+ new ToStringTest("E6", 0.0012m, "1.200000E-003"),
+ new ToStringTest("F4", -0.001234m, "-0.0012"),
+ new ToStringTest("E3", -0.001234m, "-1.234E-003"),
+#if NET_1_0
+ new ToStringTest("g", -0.000012m, "-1.2e-05"),
+#else
+ new ToStringTest("g", -0.000012m, "-0.000012"),
+#endif
+ new ToStringTest("g", -0.00012m, "-0.00012"),
+ new ToStringTest("g4", -0.00012m, "-0.00012"),
+ new ToStringTest("g7", -0.00012m, "-0.00012"),
+ new ToStringTest("g", -0.0001234m, "-0.0001234"),
+ new ToStringTest("g", -0.0012m, "-0.0012"),
+ new ToStringTest("g", -0.001234m, "-0.001234"),
+ new ToStringTest("g", -0.012m, "-0.012"),
+ new ToStringTest("g4", -0.012m, "-0.012"),
+ new ToStringTest("g", -0.12m, "-0.12"),
+ new ToStringTest("g", -1.2m, "-1.2"),
+ new ToStringTest("g4", -120m, "-120"),
+ new ToStringTest("g", -12m, "-12"),
+ new ToStringTest("g", -120m, "-120"),
+ new ToStringTest("g", -1200m, "-1200"),
+ new ToStringTest("g4", -1200m, "-1200"),
+ new ToStringTest("g", -1234m, "-1234"),
+ new ToStringTest("g", -12000m, "-12000"),
+ new ToStringTest("g4", -12000m, "-1.2e+04"),
+ new ToStringTest("g5", -12000m, "-12000"),
+ new ToStringTest("g", -12345m, "-12345"),
+ new ToStringTest("g", -120000m, "-120000"),
+ new ToStringTest("g4", -120000m, "-1.2e+05"),
+ new ToStringTest("g5", -120000m, "-1.2e+05"),
+ new ToStringTest("g6", -120000m, "-120000"),
+ new ToStringTest("g", -123456.1m, "-123456.1"),
+ new ToStringTest("g5", -123456.1m, "-1.2346e+05"),
+ new ToStringTest("g6", -123456.1m, "-123456"),
+ new ToStringTest("g", -1200000m, "-1200000"),
+ new ToStringTest("g", -123456.1m, "-123456.1"),
+ new ToStringTest("g", -123456.1m, "-123456.1"),
+ new ToStringTest("g", -1234567.1m, "-1234567.1"),
+ new ToStringTest("g", -12000000m, "-12000000"),
+ new ToStringTest("g", -12345678.1m, "-12345678.1"),
+ new ToStringTest("g", -12000000000000000000m, "-12000000000000000000"),
+ new ToStringTest("F", -123, "-123.00"),
+ new ToStringTest("F3", -123, "-123.000"),
+ new ToStringTest("F0", -123, "-123"),
+ new ToStringTest("E3", -123, "-1.230E+002"),
+ new ToStringTest("E0", -123, "-1E+002"),
+ new ToStringTest("E", -123, "-1.230000E+002"),
+ new ToStringTest("F3", Decimal.MinValue, "-79228162514264337593543950335.000"),
+ new ToStringTest("F", Decimal.MinValue, "-79228162514264337593543950335.00"),
+ new ToStringTest("F0", Decimal.MinValue, "-79228162514264337593543950335"),
+ new ToStringTest("E", Decimal.MinValue, "-7.922816E+028"),
+ new ToStringTest("E3", Decimal.MinValue, "-7.923E+028"),
+ new ToStringTest("E28", Decimal.MinValue, "-7.9228162514264337593543950335E+028"),
+ new ToStringTest("E30", Decimal.MinValue, "-7.922816251426433759354395033500E+028"),
+ new ToStringTest("E0", Decimal.MinValue, "-8E+028"),
+ new ToStringTest("N3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
+ new ToStringTest("N0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
+ new ToStringTest("N", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
+ new ToStringTest("n3", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.000"),
+ new ToStringTest("n0", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335"),
+ new ToStringTest("n", Decimal.MinValue, "-79,228,162,514,264,337,593,543,950,335.00"),
+ new ToStringTest("C", 123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79"),
+ new ToStringTest("C", -123456.7890m, "(" + NumberFormatInfo.InvariantInfo.CurrencySymbol + "123,456.79)"),
+ new ToStringTest("C3", 1123456.7890m, NumberFormatInfo.InvariantInfo.CurrencySymbol + "1,123,456.789"),
+ new ToStringTest("P", 123456.7891m, "12,345,678.91 %"),
+ new ToStringTest("P", -123456.7892m, "-12,345,678.92 %"),
+ new ToStringTest("P3", 1234.56789m, "123,456.789 %"),
+ };
+
+ NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo;
+
+ for (int i = 0; i < tab.Length; i++)
+ {
+ try
+ {
+ string s = tab[i].d.ToString(tab[i].format, nfi);
+ AssertEquals("A01 tab[" + i + "].format = '" + tab[i].format + "')", tab[i].str, s);
+ }
+ catch (OverflowException)
+ {
+ Fail(tab[i].d.ToString(tab[i].format, nfi) + " (format = '" + tab[i].format + "'): unexpected exception !");
+ }
+ catch (NUnit.Framework.AssertionException e) {
+ throw e;
+ }
+ catch (Exception e) {
+ Fail ("Unexpected Exception when i = " + i + ". e = " + e);
+ }
+ }
+ }
+
+ public void TestCurrencyPattern()
+ {
+ NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
+ Decimal d = -1234567.8976m;
+ string[] ergCurrencyNegativePattern = new String[16] {
+ "(XYZ1234_5_67,898)", "-XYZ1234_5_67,898", "XYZ-1234_5_67,898", "XYZ1234_5_67,898-",
+ "(1234_5_67,898XYZ)", "-1234_5_67,898XYZ", "1234_5_67,898-XYZ", "1234_5_67,898XYZ-",
+ "-1234_5_67,898 XYZ", "-XYZ 1234_5_67,898", "1234_5_67,898 XYZ-", "XYZ 1234_5_67,898-",
+ "XYZ -1234_5_67,898", "1234_5_67,898- XYZ", "(XYZ 1234_5_67,898)", "(1234_5_67,898 XYZ)",
+ };
+
+ for (int i = 0; i < ergCurrencyNegativePattern.Length; i++)
+ {
+ nfi2.CurrencyNegativePattern = i;
+ if (d.ToString("C", nfi2) != ergCurrencyNegativePattern[i])
+ {
+ Fail("CurrencyNegativePattern #" + i + " failed: " +
+ d.ToString("C", nfi2) + " != " + ergCurrencyNegativePattern[i]);
+ }
+ }
+
+ d = 1234567.8976m;
+ string[] ergCurrencyPositivePattern = new String[4] {
+ "XYZ1234_5_67,898", "1234_5_67,898XYZ", "XYZ 1234_5_67,898", "1234_5_67,898 XYZ",
+ };
+
+ for (int i = 0; i < ergCurrencyPositivePattern.Length; i++)
+ {
+ nfi2.CurrencyPositivePattern = i;
+ if (d.ToString("C", nfi2) != ergCurrencyPositivePattern[i])
+ {
+ Fail("CurrencyPositivePattern #" + i + " failed: " +
+ d.ToString("C", nfi2) + " != " + ergCurrencyPositivePattern[i]);
+ }
+ }
+ }
+
+ public void TestNumberNegativePattern()
+ {
+ NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
+ Decimal d = -1234.89765m;
+ string[] ergNumberNegativePattern = new String[5] {
+ "(1__2__34##8977)", "-1__2__34##8977", "- 1__2__34##8977", "1__2__34##8977-", "1__2__34##8977 -",
+ };
+
+ for (int i = 0; i < ergNumberNegativePattern.Length; i++)
+ {
+ nfi2.NumberNegativePattern = i;
+ AssertEquals ("NumberNegativePattern #" + i, ergNumberNegativePattern[i], d.ToString("N", nfi2));
+ }
+ }
+
+ public void TestPercentPattern()
+ {
+ NumberFormatInfo nfi2 = (NumberFormatInfo)NfiUser.Clone();
+ Decimal d = -1234.8976m;
+ string[] ergPercentNegativePattern = new String[3] {
+ "-1~2~3~4~8~9;8 %%%", "-1~2~3~4~8~9;8%%%", "-%%%1~2~3~4~8~9;8"
+ };
+
+ for (int i = 0; i < ergPercentNegativePattern.Length; i++)
+ {
+ nfi2.PercentNegativePattern = i;
+ if (d.ToString("P", nfi2) != ergPercentNegativePattern[i])
+ {
+ Fail("PercentNegativePattern #" + i + " failed: " +
+ d.ToString("P", nfi2) + " != " + ergPercentNegativePattern[i]);
+ }
+ }
+
+ d = 1234.8976m;
+ string[] ergPercentPositivePattern = new String[3] {
+ "1~2~3~4~8~9;8 %%%", "1~2~3~4~8~9;8%%%", "%%%1~2~3~4~8~9;8"
+ };
+
+ for (int i = 0; i < ergPercentPositivePattern.Length; i++)
+ {
+ nfi2.PercentPositivePattern = i;
+ if (d.ToString("P", nfi2) != ergPercentPositivePattern[i])
+ {
+ Fail("PercentPositivePattern #" + i + " failed: " +
+ d.ToString("P", nfi2) + " != " + ergPercentPositivePattern[i]);
+ }
+ }
+ }
+
+ public void TestParse()
+ {
+ ParseTest[] tab = {
+ new ParseTest("1.2345", 1.2345m),
+ new ParseTest("-9876543210", -9876543210m),
+ new ParseTest(NumberFormatInfo.InvariantInfo.CurrencySymbol
+ + " ( 79,228,162,514,264,337,593,543,950,335.000 ) ", Decimal.MinValue, NumberStyles.Currency),
+ new ParseTest("1.234567890e-10", (Decimal)1.234567890e-10, NumberStyles.Float),
+ new ParseTest("1.234567890e-24", 1.2346e-24m, NumberStyles.Float),
+ new ParseTest(" 47896396.457983645462346E10 ", 478963964579836454.62346m, NumberStyles.Float),
+ new ParseTest("-7922816251426433759354395033.250000000000001", -7922816251426433759354395033.3m),
+ new ParseTest("-00000000000000795033.2500000000000000", -795033.25m),
+ new ParseTest("-000000000000001922816251426433759354395033.300000000000000", -1922816251426433759354395033.3m),
+ new ParseTest("-7922816251426433759354395033.150000000000", -7922816251426433759354395033.2m),
+ new ParseTest("-7922816251426433759354395033.2400000000000", -7922816251426433759354395033.2m),
+ new ParseTest("-7922816251426433759354395033.2600000000000", -7922816251426433759354395033.3m)
+ };
+
+ Decimal d;
+ for (int i = 0; i < tab.Length; i++)
+ {
+ try
+ {
+ d = Decimal.Parse(tab[i].str, tab[i].style, NumberFormatInfo.InvariantInfo);
+ if (tab[i].exceptionFlag)
+ {
+ Fail(tab[i].str + ": missing exception !");
+ }
+ else if (d != tab[i].d)
+ {
+ Fail(tab[i].str + " != " + d);
+ }
+ }
+ catch (OverflowException)
+ {
+ if (!tab[i].exceptionFlag)
+ {
+ Fail(tab[i].str + ": unexpected exception !");
+ }
+ }
+ }
+
+ try
+ {
+ d = Decimal.Parse(null);
+ Fail("Expected ArgumentNullException");
+ }
+ catch (ArgumentNullException)
+ {
+ //ok
+ }
+
+ try
+ {
+ d = Decimal.Parse("123nx");
+ Fail("Expected FormatException");
+ }
+ catch (FormatException)
+ {
+ //ok
+ }
+
+ try
+ {
+ d = Decimal.Parse("79228162514264337593543950336");
+ Fail("Expected OverflowException" + d);
+ }
+ catch (OverflowException)
+ {
+ //ok
+ }
+ }
+
+ public void TestConstants()
+ {
+ AssertEquals ("Zero", 0m, Decimal.Zero);
+ AssertEquals ("One", 1m, Decimal.One);
+ AssertEquals ("MinusOne", -1m, Decimal.MinusOne);
+ AssertEquals ("MaxValue", 79228162514264337593543950335m, Decimal.MaxValue);
+ AssertEquals ("MinValue", -79228162514264337593543950335m, Decimal.MinValue);
+ Assert ("MinusOne 2", -1m == Decimal.MinusOne);
+ }
+
+ public void TestConstructInt32()
+ {
+ decimal[] dtab = {0m, 1m, -1m, 123456m, -1234567m};
+ int[] itab = {0, 1, -1, 123456, -1234567};
+
+ Decimal d;
+
+ for (int i = 0; i < dtab.GetLength(0); i++)
+ {
+ d = new Decimal(itab[i]);
+ if ((decimal)d != dtab[i])
+ {
+ Fail("Int32 -> Decimal: " + itab[i] + " != " + d);
+ }
+ else
+ {
+ int n = (int) d;
+ if (n != itab[i])
+ {
+ Fail("Decimal -> Int32: " + d + " != " + itab[i]);
+ }
+ }
+ }
+
+ d = new Decimal(Int32.MaxValue);
+ Assert((int)d == Int32.MaxValue);
+
+ d = new Decimal(Int32.MinValue);
+ Assert((int)d == Int32.MinValue);
+ }
+
+ public void TestConstructUInt32()
+ {
+ decimal[] dtab = {0m, 1m, 123456m, 123456789m};
+ uint[] itab = {0, 1, 123456, 123456789};
+
+ Decimal d;
+
+ for (int i = 0; i < dtab.GetLength(0); i++)
+ {
+ d = new Decimal(itab[i]);
+ if ((decimal)d != dtab[i])
+ {
+ Fail("UInt32 -> Decimal: " + itab[i] + " != " + d);
+ }
+ else
+ {
+ uint n = (uint) d;
+ if (n != itab[i])
+ {
+ Fail("Decimal -> UInt32: " + d + " != " + itab[i]);
+ }
+ }
+ }
+
+ d = new Decimal(UInt32.MaxValue);
+ Assert((uint)d == UInt32.MaxValue);
+
+ d = new Decimal(UInt32.MinValue);
+ Assert((uint)d == UInt32.MinValue);
+ }
+
+ public void TestConstructInt64()
+ {
+ decimal[] dtab = {0m, 1m, -1m, 9876543m, -9876543210m, 12345678987654321m};
+ long[] itab = {0, 1, -1, 9876543, -9876543210L, 12345678987654321L};
+
+ Decimal d;
+
+ for (int i = 0; i < dtab.GetLength(0); i++)
+ {
+ d = new Decimal(itab[i]);
+ if ((decimal)d != dtab[i])
+ {
+ Fail("Int64 -> Decimal: " + itab[i] + " != " + d);
+ }
+ else
+ {
+ long n = (long) d;
+ if (n != itab[i])
+ {
+ Fail("Decimal -> Int64: " + d + " != " + itab[i]);
+ }
+ }
+ }
+
+ d = new Decimal(Int64.MaxValue);
+ Assert((long)d == Int64.MaxValue);
+
+ d = new Decimal(Int64.MinValue);
+ Assert((long)d == Int64.MinValue);
+ }
+
+ public void TestConstructUInt64()
+ {
+ decimal[] dtab = {0m, 1m, 987654321m, 123456789876543210m};
+ ulong[] itab = {0, 1, 987654321, 123456789876543210L};
+
+ Decimal d;
+
+ for (int i = 0; i < dtab.GetLength(0); i++)
+ {
+ d = new Decimal(itab[i]);
+ if ((decimal)d != dtab[i])
+ {
+ Fail("UInt64 -> Decimal: " + itab[i] + " != " + d);
+ }
+ else
+ {
+ ulong n = (ulong) d;
+ if (n != itab[i])
+ {
+ Fail("Decimal -> UInt64: " + d + " != " + itab[i]);
+ }
+ }
+ }
+
+ d = new Decimal(UInt64.MaxValue);
+ Assert((ulong)d == UInt64.MaxValue);
+
+ d = new Decimal(UInt64.MinValue);
+ Assert((ulong)d == UInt64.MinValue);
+ }
+
+ public void TestConstructSingle()
+ {
+ Decimal d;
+
+ d = new Decimal(-1.2345678f);
+ AssertEquals("A#01", -1.234568m, (decimal)d);
+
+ d=3;
+ AssertEquals("A#02", 3.0f, (float)d);
+
+ d = new Decimal(0.0f);
+ AssertEquals("A#03", 0m, (decimal)d);
+ AssertEquals("A#04", 0.0f, (float)d);
+
+ d = new Decimal(1.0f);
+ AssertEquals("A#05", 1m, (decimal)d);
+ AssertEquals("A#06", 1.0f, (float)d);
+
+ d = new Decimal(-1.2345678f);
+ AssertEquals("A#07", -1.234568m, (decimal)d);
+ AssertEquals("A#08", -1.234568f, (float)d);
+
+ d = new Decimal(1.2345673f);
+ AssertEquals("A#09", 1.234567m, (decimal)d);
+
+ d = new Decimal(1.2345673e7f);
+ AssertEquals("A#10", 12345670m, (decimal)d);
+
+ d = new Decimal(1.2345673e-17f);
+ AssertEquals("A#11", 0.00000000000000001234567m, (decimal)d);
+ AssertEquals("A#12", 1.234567e-17f, (float)d);
+
+ // test exceptions
+ try
+ {
+ d = new Decimal(Single.MaxValue);
+ Fail();
+ }
+ catch (OverflowException)
+ {
+ }
+
+ try
+ {
+ d = new Decimal(Single.NaN);
+ Fail();
+ }
+ catch (OverflowException)
+ {
+ }
+
+ try
+ {
+ d = new Decimal(Single.PositiveInfinity);
+ Fail();
+ }
+ catch (OverflowException)
+ {
+ }
+ }
+
+ public void TestConstructSingleRounding_NowWorking ()
+ {
+ decimal d;
+
+ d = new Decimal(1765.23454f);
+ AssertEquals ("failed banker's rule rounding test 2", 1765.234m, d);
+
+ d = new Decimal(0.00017652356f);
+ AssertEquals ("06", 0.0001765236m, d);
+
+ d = new Decimal(0.000176523554f);
+ AssertEquals ("failed banker's rule rounding test 3", 0.0001765236m, d);
+
+ d = new Decimal(0.00017652354f);
+ AssertEquals ("08", 0.0001765235m, d);
+
+ d = new Decimal(0.00017652346f);
+ AssertEquals ("09", 0.0001765235m, d);
+
+ d = new Decimal(0.000176523454f);
+ AssertEquals ("failed banker's rule rounding test 4", 0.0001765234m, d);
+
+ d = new Decimal(0.00017652344f);
+ AssertEquals ("11", 0.0001765234m, d);
+ }
+
+ public void TestConstructSingleRounding()
+ {
+ decimal d;
+
+ d = new Decimal(1765.2356f);
+ Assert("01", d == 1765.236m);
+
+ d = new Decimal(1765.23554f);
+ Assert("failed banker's rule rounding test 1", d == 1765.236m);
+
+ d = new Decimal(1765.2354f);
+ Assert("03", d == 1765.235m);
+
+ d = new Decimal(1765.2346f);
+ Assert("04", d == 1765.235m);
+
+ d = new Decimal(1765.2344f);
+ Assert("05", d == 1765.234m);
+
+ d = new Decimal(3.7652356e10f);
+ Assert("12", d == 37652360000m);
+
+ d = new Decimal(3.7652356e20f);
+ Assert("13", d == 376523600000000000000m);
+
+ d = new Decimal(3.76523554e20f);
+ Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);
+
+ d = new Decimal(3.7652352e20f);
+ Assert("15", d == 376523500000000000000m);
+
+ d = new Decimal(3.7652348e20f);
+ Assert("16", d == 376523500000000000000m);
+
+ d = new Decimal(3.76523454e20f);
+ Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);
+
+ d = new Decimal(3.7652342e20f);
+ Assert("18", d == 376523400000000000000m);
+ }
+
+ public void TestConstructDouble()
+ {
+ Decimal d;
+
+ d = new Decimal(0.0);
+ Assert((decimal)d == 0m);
+
+ d = new Decimal(1.0);
+ Assert((decimal)d == 1m);
+ Assert(1.0 == (double)d);
+
+ d = new Decimal(-1.2345678901234);
+ Assert((decimal)d == -1.2345678901234m);
+ Assert(-1.2345678901234 == (double)d);
+
+ d = new Decimal(1.2345678901234);
+ Assert((decimal)d == 1.2345678901234m);
+
+ d = new Decimal(1.2345678901234e8);
+ Assert((decimal)d == 123456789.01234m);
+ Assert(1.2345678901234e8 == (double)d);
+
+ d = new Decimal(1.2345678901234e16);
+ Assert((decimal)d == 12345678901234000m);
+ Assert(1.2345678901234e16 == (double)d);
+
+ d = new Decimal(1.2345678901234e24);
+ Assert((decimal)d == 1234567890123400000000000m);
+ Assert(1.2345678901234e24 == (double)d);
+
+ d = new Decimal(1.2345678901234e28);
+ Assert((decimal)d == 1.2345678901234e28m);
+ Assert(1.2345678901234e28 == (double)d);
+
+ d = new Decimal(7.2345678901234e28);
+ Assert((decimal)d == 7.2345678901234e28m);
+ Assert(new Decimal((double)d) == d);
+
+ d = new Decimal(1.2345678901234e-8);
+ Assert((decimal)d == 1.2345678901234e-8m);
+
+ d = new Decimal(1.2345678901234e-14);
+ Assert((decimal)d == 1.2345678901234e-14m);
+ Assert(1.2345678901234e-14 == (double)d);
+
+ d = new Decimal(1.2342278901234e-25);
+ Assert((decimal)d == 1.234e-25m);
+
+ // test exceptions
+ try
+ {
+ d = new Decimal(8e28);
+ Fail();
+ }
+ catch (OverflowException)
+ {
+ }
+
+ try
+ {
+ d = new Decimal(8e48);
+ Fail();
+ }
+ catch (OverflowException)
+ {
+ }
+
+ try
+ {
+ d = new Decimal(Double.NaN);
+ Fail();
+ }
+ catch (OverflowException)
+ {
+ }
+
+ try
+ {
+ d = new Decimal(Double.PositiveInfinity);
+ Fail();
+ }
+ catch (OverflowException)
+ {
+ }
+ }
+
+ public void TestConstructDoubleRound()
+ {
+ decimal d;
+ int TestNum = 1;
+
+ try {
+ d = new Decimal(1765.231234567857);
+ AssertEquals("A01", 1765.23123456786m, d);
+
+ TestNum++;
+ d = new Decimal(1765.2312345678554);
+ AssertEquals("A02, failed banker's rule rounding test 1", 1765.23123456786m, d);
+ AssertEquals("A03", 1765.23123456786, (double)d);
+
+ TestNum++;
+ d = new Decimal(1765.231234567853);
+ Assert(d == 1765.23123456785m);
+
+ TestNum++;
+ d = new Decimal(1765.231234567847);
+ Assert(d == 1765.23123456785m);
+
+ TestNum++;
+ d = new Decimal(1765.231234567843);
+ Assert(d == 1765.23123456784m);
+
+ TestNum++;
+ d = new Decimal(1.765231234567857e-9);
+ Assert(d == 1.76523123456786e-9m);
+
+ TestNum++;
+ d = new Decimal(1.7652312345678554e-9);
+ Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);
+
+ TestNum++;
+ d = new Decimal(1.765231234567853e-9);
+ Assert(d == 1.76523123456785e-9m);
+
+ TestNum++;
+ d = new Decimal(1.765231234567857e+24);
+ Assert(d == 1.76523123456786e+24m);
+
+ TestNum++;
+ d = new Decimal(1.7652312345678554e+24);
+ Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);
+
+ TestNum++;
+ d = new Decimal(1.765231234567853e+24);
+ Assert(d == 1.76523123456785e+24m);
+
+ TestNum++;
+ d = new Decimal(1765.2312345678454);
+ Assert(d == 1765.23123456785m);
+ }
+ catch (Exception e) {
+ Fail("At TestNum = " + TestNum + " unexpected exception. e = " + e);
+ }
+ }
+
+ public void TestNegate()
+ {
+ decimal d;
+
+ d = new Decimal(12345678);
+ Assert((decimal)Decimal.Negate(d) == -12345678m);
+ }
+
+ public void TestPartConstruct()
+ {
+ decimal d;
+
+ d = new Decimal(parts0);
+ Assert(d == 0);
+
+ d = new Decimal(parts1);
+ Assert(d == 1);
+
+ d = new Decimal(parts2);
+ Assert(d == 4294967296m);
+
+ d = new Decimal(parts3);
+ Assert(d == 18446744073709551616m);
+
+ d = new Decimal(parts4);
+ Assert(d == 0m);
+
+ d = new Decimal(parts5);
+ Assert(d == 18446744078004518913m);
+
+ d = new Decimal(partsMaxValue);
+ Assert(d == Decimal.MaxValue);
+
+ d = new Decimal(partsMinValue);
+ Assert(d == Decimal.MinValue);
+
+ d = new Decimal(parts6);
+ int[] erg = Decimal.GetBits(d);
+ for (int i = 0; i < 4; i++)
+ {
+ Assert(erg[i] == parts6[i]);
+ }
+ }
+
+ public void TestFloorTruncate()
+ {
+ decimal[,] dtab = {
+ {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m},
+ {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},
+ {-123456789012345.67890m, -123456789012346m, -123456789012345m},
+ {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},
+ {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},
+ {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m},
+ {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}
+ };
+
+ decimal d;
+
+ for (int i = 0; i < dtab.GetLength(0); i++)
+ {
+ d = Decimal.Floor(dtab[i,0]);
+ if (d != dtab[i,1])
+ {
+ Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);
+ }
+ d = Decimal.Truncate(dtab[i,0]);
+ if (d != dtab[i,2])
+ {
+ Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);
+ }
+ }
+ }
+
+ [Test]
+ public void Truncate ()
+ {
+ decimal dd = 249.9m;
+ decimal dt = Decimal.Truncate (dd);
+ AssertEquals ("Original", 249.9m, dd);
+ AssertEquals ("Truncate", 249m, dt);
+ AssertEquals ("Cast-Byte", 249, (byte)dd);
+ AssertEquals ("Cast-Char", 249, (char)dd);
+ AssertEquals ("Cast-Int16", 249, (short)dd);
+ AssertEquals ("Cast-UInt16", 249, (ushort)dd);
+ AssertEquals ("Cast-Int32", 249, (int)dd);
+ AssertEquals ("Cast-UInt32", 249, (uint)dd);
+ AssertEquals ("Cast-Int64", 249, (long)dd);
+ AssertEquals ("Cast-UInt64", 249, (ulong)dd);
+ }
+
+ 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])
+ {
+ Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);
+ }
+ }
+ }
+
+ 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])
+ {
+ 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 ());
+ AssertEquals ("Int64.MaxValue", Int64.MaxValue, Decimal.ToInt64 (dmax));
+
+ long min = Int64.MinValue;
+ Decimal dmin = Decimal.Parse (min.ToString ());
+ AssertEquals ("Int64.MinValue", Int64.MinValue, Decimal.ToInt64 (dmin));
+
+ dmax += 1.1m;
+ dmax = Decimal.Parse (dmax.ToString ());
+ AssertEquals ("Int64.MaxValue+1.1", Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m));
+
+ dmin -= 1.1m;
+ dmin = Decimal.Parse (dmin.ToString ());
+ AssertEquals ("Int64.MinValue-1.1", Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m));
+ }
+
+ [Test]
+ public void ToByte ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToByte", 254, Decimal.ToByte (d));
+ AssertEquals ("Convert.ToByte", 255, Convert.ToByte (d));
+ AssertEquals ("IConvertible.ToByte", 255, (d as IConvertible).ToByte (null));
+ }
+
+ [Test]
+ public void ToSByte ()
+ {
+ Decimal d = 126.9m;
+ AssertEquals ("Decimal.ToSByte", 126, Decimal.ToSByte (d));
+ AssertEquals ("Convert.ToSByte", 127, Convert.ToSByte (d));
+ AssertEquals ("IConvertible.ToSByte", 127, (d as IConvertible).ToSByte (null));
+ d = -d;
+ AssertEquals ("-Decimal.ToSByte", -126, Decimal.ToSByte (d));
+ AssertEquals ("-Convert.ToSByte", -127, Convert.ToSByte (d));
+ AssertEquals ("-IConvertible.ToSByte", -127, (d as IConvertible).ToSByte (null));
+ }
+
+ [Test]
+ public void ToInt16 ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToInt16", 254, Decimal.ToInt16 (d));
+ AssertEquals ("Convert.ToInt16", 255, Convert.ToInt16 (d));
+ AssertEquals ("IConvertible.ToInt16", 255, (d as IConvertible).ToInt16 (null));
+ d = -d;
+ AssertEquals ("-Decimal.ToInt16", -254, Decimal.ToInt16 (d));
+ AssertEquals ("-Convert.ToInt16", -255, Convert.ToInt16 (d));
+ AssertEquals ("-IConvertible.ToInt16", -255, (d as IConvertible).ToInt16 (null));
+ }
+
+ [Test]
+ public void ToUInt16 ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToUInt16", 254, Decimal.ToUInt16 (d));
+ AssertEquals ("Convert.ToUInt16", 255, Convert.ToUInt16 (d));
+ AssertEquals ("IConvertible.ToUInt16", 255, (d as IConvertible).ToUInt16 (null));
+ }
+
+ [Test]
+ public void ToInt32 ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToInt32", 254, Decimal.ToInt32 (d));
+ AssertEquals ("Convert.ToInt32", 255, Convert.ToInt32 (d));
+ AssertEquals ("IConvertible.ToInt32", 255, (d as IConvertible).ToInt32 (null));
+ d = -d;
+ AssertEquals ("-Decimal.ToInt32", -254, Decimal.ToInt32 (d));
+ AssertEquals ("-Convert.ToInt32", -255, Convert.ToInt32 (d));
+ AssertEquals ("-IConvertible.ToInt32", -255, (d as IConvertible).ToInt32 (null));
+ }
+
+ [Test]
+ public void ToUInt32 ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToUInt32", 254, Decimal.ToUInt32 (d));
+ AssertEquals ("Convert.ToUInt32", 255, Convert.ToUInt32 (d));
+ AssertEquals ("IConvertible.ToUInt32", 255, (d as IConvertible).ToUInt32 (null));
+ }
+
+ [Test]
+ public void ToInt64 ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToInt64", 254, Decimal.ToInt64 (d));
+ AssertEquals ("Convert.ToInt64", 255, Convert.ToInt64 (d));
+ AssertEquals ("IConvertible.ToInt64", 255, (d as IConvertible).ToInt64 (null));
+ d = -d;
+ AssertEquals ("-Decimal.ToInt64", -254, Decimal.ToInt64 (d));
+ AssertEquals ("-Convert.ToInt64", -255, Convert.ToInt64 (d));
+ AssertEquals ("-IConvertible.ToInt64", -255, (d as IConvertible).ToInt64 (null));
+ }
+
+ [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;
+ AssertEquals ("Decimal.ToUInt64", 254, Decimal.ToUInt64 (d));
+ AssertEquals ("Convert.ToUInt64", 255, Convert.ToUInt64 (d));
+ AssertEquals ("IConvertible.ToUInt64", 255, (d as IConvertible).ToUInt64 (null));
+ }
+
+ [Test]
+ public void ToSingle ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToSingle", 254.9f, Decimal.ToSingle (d));
+ AssertEquals ("Convert.ToSingle", 254.9f, Convert.ToSingle (d));
+ AssertEquals ("IConvertible.ToSingle", 254.9f, (d as IConvertible).ToSingle (null));
+ d = -d;
+ AssertEquals ("-Decimal.ToSingle", -254.9f, Decimal.ToSingle (d));
+ AssertEquals ("-Convert.ToSingle", -254.9f, Convert.ToSingle (d));
+ AssertEquals ("-IConvertible.ToSingle", -254.9f, (d as IConvertible).ToSingle (null));
+ }
+
+ [Test]
+ public void ToDouble ()
+ {
+ Decimal d = 254.9m;
+ AssertEquals ("Decimal.ToDouble", 254.9d, Decimal.ToDouble (d));
+ AssertEquals ("Convert.ToDouble", 254.9d, Convert.ToDouble (d));
+ AssertEquals ("IConvertible.ToDouble", 254.9d, (d as IConvertible).ToDouble (null));
+ d = -d;
+ AssertEquals ("-Decimal.ToDouble", -254.9d, Decimal.ToDouble (d));
+ AssertEquals ("-Convert.ToDouble", -254.9d, Convert.ToDouble (d));
+ AssertEquals ("-IConvertible.ToDouble", -254.9d, (d as IConvertible).ToDouble (null));
+ }
+
+ [Test]
+ public void ToString_Defaults ()
+ {
+ Decimal d = 254.9m;
+ // everything defaults to "G"
+ string def = d.ToString ("G");
+ AssertEquals ("ToString()", def, d.ToString ());
+ AssertEquals ("ToString((IFormatProvider)null)", def, d.ToString ((IFormatProvider)null));
+ AssertEquals ("ToString((string)null)", def, d.ToString ((string)null));
+ AssertEquals ("ToString(empty)", def, d.ToString (String.Empty));
+ AssertEquals ("ToString(null,null)", def, d.ToString (null, null));
+ AssertEquals ("ToString(empty,null)", def, d.ToString (String.Empty, null));
+
+ AssertEquals ("ToString()", "254.9", def);
+ }
+
+ [Test]
+ public void CastTruncRounding ()
+ {
+ // casting truncs decimal value (not normal nor banker's rounding)
+ AssertEquals ("254.9==254", 254, (long)(254.9m));
+ AssertEquals ("-254.9=-254", -254, (long)(-254.9m));
+ AssertEquals ("255.9==256", 255, (long)(255.9m));
+ AssertEquals ("-255.9=-256", -255, (long)(-255.9m));
+ }
+
+ [Test]
+ public void ParseFractions ()
+ {
+ decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);
+ AssertEquals ("f1", 0.5234567890123454678901234568m, d1);
+ decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);
+ AssertEquals ("f2", 0.4921420654348652943463423146m, d2);
+ }
+
+ [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;
+ }
+
+ [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;
+
+ AssertEquals ("254.9 % 12.1", 0.8m, Decimal.Remainder (p1, p2));
+ AssertEquals ("-254.9 % 12.1", -0.8m, Decimal.Remainder (n1, p2));
+ AssertEquals ("254.9 % -12.1", 0.8m, Decimal.Remainder (p1, n2));
+ AssertEquals ("-254.9 % -12.1", -0.8m, Decimal.Remainder (n1, n2));
+
+ AssertEquals ("12.1 % 254.9", 12.1m, Decimal.Remainder (p2, p1));
+ AssertEquals ("-12.1 % 254.9", -12.1m, Decimal.Remainder (n2, p1));
+ AssertEquals ("12.1 % -254.9", 12.1m, Decimal.Remainder (p2, n1));
+ AssertEquals ("-12.1 % -254.9", -12.1m, Decimal.Remainder (n2, n1));
+#if NET_2_0
+ AssertEquals ("12.1 % 12.1", 0.0m, Decimal.Remainder (p1, p1));
+ AssertEquals ("-12.1 % 12.1", 0.0m, Decimal.Remainder (n1, p1));
+ AssertEquals ("12.1 % -12.1", 0.0m, Decimal.Remainder (p1, n1));
+ AssertEquals ("-12.1 % -12.1", 0.0m, Decimal.Remainder (n1, n1));
+#else
+ AssertEquals ("12.1 % 12.1", 0, Decimal.Remainder (p1, p1));
+ AssertEquals ("-12.1 % 12.1", 0, Decimal.Remainder (n1, p1));
+ AssertEquals ("12.1 % -12.1", 0, Decimal.Remainder (p1, n1));
+ AssertEquals ("-12.1 % -12.1", 0, Decimal.Remainder (n1, n1));
+#endif
}
- public void TestConstructSingleRounding()\r
- {\r
- decimal d;\r
-\r
- d = new Decimal(1765.2356f);\r
- Assert("01", d == 1765.236m);\r
-\r
- d = new Decimal(1765.23554f);\r
- Assert("failed banker's rule rounding test 1", d == 1765.236m);\r
-\r
- d = new Decimal(1765.2354f);\r
- Assert("03", d == 1765.235m);\r
-\r
- d = new Decimal(1765.2346f);\r
- Assert("04", d == 1765.235m);\r
-\r
- d = new Decimal(1765.2344f);\r
- Assert("05", d == 1765.234m);\r
-\r
- d = new Decimal(3.7652356e10f);\r
- Assert("12", d == 37652360000m);\r
-\r
- d = new Decimal(3.7652356e20f);\r
- Assert("13", d == 376523600000000000000m);\r
-\r
- d = new Decimal(3.76523554e20f);\r
- Assert("failed banker's rule rounding test 5", d == 376523600000000000000m);\r
-\r
- d = new Decimal(3.7652352e20f);\r
- Assert("15", d == 376523500000000000000m);\r
-\r
- d = new Decimal(3.7652348e20f);\r
- Assert("16", d == 376523500000000000000m);\r
-\r
- d = new Decimal(3.76523454e20f);\r
- Assert("failed banker's rule rounding test 6", d == 376523400000000000000m);\r
-\r
- d = new Decimal(3.7652342e20f);\r
- Assert("18", d == 376523400000000000000m);\r
- }\r
-\r
- public void TestConstructDouble()\r
- {\r
- Decimal d;\r
-\r
- d = new Decimal(0.0);\r
- Assert((decimal)d == 0m);\r
-\r
- d = new Decimal(1.0);\r
- Assert((decimal)d == 1m);\r
- Assert(1.0 == (double)d);\r
-\r
- d = new Decimal(-1.2345678901234);\r
- Assert((decimal)d == -1.2345678901234m);\r
- Assert(-1.2345678901234 == (double)d);\r
-\r
- d = new Decimal(1.2345678901234);\r
- Assert((decimal)d == 1.2345678901234m);\r
-\r
- d = new Decimal(1.2345678901234e8);\r
- Assert((decimal)d == 123456789.01234m);\r
- Assert(1.2345678901234e8 == (double)d);\r
-\r
- d = new Decimal(1.2345678901234e16);\r
- Assert((decimal)d == 12345678901234000m);\r
- Assert(1.2345678901234e16 == (double)d);\r
-\r
- d = new Decimal(1.2345678901234e24);\r
- Assert((decimal)d == 1234567890123400000000000m);\r
- Assert(1.2345678901234e24 == (double)d);\r
-\r
- d = new Decimal(1.2345678901234e28);\r
- Assert((decimal)d == 1.2345678901234e28m);\r
- Assert(1.2345678901234e28 == (double)d);\r
-\r
- d = new Decimal(7.2345678901234e28);\r
- Assert((decimal)d == 7.2345678901234e28m);\r
- Assert(new Decimal((double)d) == d);\r
-\r
- d = new Decimal(1.2345678901234e-8);\r
- Assert((decimal)d == 1.2345678901234e-8m);\r
-\r
- d = new Decimal(1.2345678901234e-14);\r
- Assert((decimal)d == 1.2345678901234e-14m);\r
- Assert(1.2345678901234e-14 == (double)d);\r
-\r
- d = new Decimal(1.2342278901234e-25);\r
- Assert((decimal)d == 1.234e-25m);\r
-\r
- // test exceptions\r
- try\r
- {\r
- d = new Decimal(8e28);\r
- Fail();\r
- } \r
- catch (OverflowException) \r
- {\r
- }\r
-\r
- try\r
- {\r
- d = new Decimal(8e48);\r
- Fail();\r
- } \r
- catch (OverflowException) \r
- {\r
- }\r
-\r
- try\r
- {\r
- d = new Decimal(Double.NaN);\r
- Fail();\r
- } \r
- catch (OverflowException) \r
- {\r
- }\r
-\r
- try\r
- {\r
- d = new Decimal(Double.PositiveInfinity);\r
- Fail();\r
- } \r
- catch (OverflowException) \r
- {\r
- }\r
- }\r
-\r
- public void TestConstructDoubleRound()\r
- {\r
- decimal d;\r
- int TestNum = 1;\r
- \r
- try {\r
- d = new Decimal(1765.231234567857);\r
- AssertEquals("A01", 1765.23123456786m, d);\r
-\r
- TestNum++;\r
- d = new Decimal(1765.2312345678554);\r
- AssertEquals("A02, failed banker's rule rounding test 1", 1765.23123456786m, d);\r
- AssertEquals("A03", 1765.23123456786, (double)d);\r
-\r
- TestNum++;\r
- d = new Decimal(1765.231234567853);\r
- Assert(d == 1765.23123456785m);\r
-\r
- TestNum++;\r
- d = new Decimal(1765.231234567847);\r
- Assert(d == 1765.23123456785m);\r
-\r
- TestNum++;\r
- d = new Decimal(1765.231234567843);\r
- Assert(d == 1765.23123456784m);\r
-\r
- TestNum++;\r
- d = new Decimal(1.765231234567857e-9);\r
- Assert(d == 1.76523123456786e-9m);\r
-\r
- TestNum++;\r
- d = new Decimal(1.7652312345678554e-9);\r
- Assert("failed banker's rule rounding test 3", d == 1.76523123456786e-9m);\r
-\r
- TestNum++;\r
- d = new Decimal(1.765231234567853e-9);\r
- Assert(d == 1.76523123456785e-9m);\r
-\r
- TestNum++;\r
- d = new Decimal(1.765231234567857e+24);\r
- Assert(d == 1.76523123456786e+24m);\r
-\r
- TestNum++;\r
- d = new Decimal(1.7652312345678554e+24);\r
- Assert("failed banker's rule rounding test 4", d == 1.76523123456786e+24m);\r
-\r
- TestNum++;\r
- d = new Decimal(1.765231234567853e+24);\r
- Assert(d == 1.76523123456785e+24m);\r
-\r
- TestNum++;\r
- d = new Decimal(1765.2312345678454);\r
- Assert(d == 1765.23123456785m);\r
- }\r
- catch (Exception e) {\r
- Fail("At TestNum = " + TestNum + " unexpected exception. e = " + e);\r
- }\r
- }\r
-\r
- public void TestNegate()\r
- {\r
- decimal d;\r
-\r
- d = new Decimal(12345678);\r
- Assert((decimal)Decimal.Negate(d) == -12345678m);\r
- }\r
-\r
- public void TestPartConstruct()\r
- {\r
- decimal d;\r
- \r
- d = new Decimal(parts0);\r
- Assert(d == 0);\r
-\r
- d = new Decimal(parts1);\r
- Assert(d == 1);\r
-\r
- d = new Decimal(parts2);\r
- Assert(d == 4294967296m);\r
-\r
- d = new Decimal(parts3);\r
- Assert(d == 18446744073709551616m);\r
-\r
- d = new Decimal(parts4);\r
- Assert(d == 0m);\r
-\r
- d = new Decimal(parts5);\r
- Assert(d == 18446744078004518913m);\r
- \r
- d = new Decimal(partsMaxValue);\r
- Assert(d == Decimal.MaxValue);\r
- \r
- d = new Decimal(partsMinValue);\r
- Assert(d == Decimal.MinValue);\r
-\r
- d = new Decimal(parts6);\r
- int[] erg = Decimal.GetBits(d);\r
- for (int i = 0; i < 4; i++) \r
- {\r
- Assert(erg[i] == parts6[i]); \r
- }\r
- }\r
-\r
- public void TestFloorTruncate()\r
- {\r
- decimal[,] dtab = {\r
- {0m, 0m, 0m}, {1m, 1m, 1m}, {-1m, -1m, -1m}, {1.1m, 1m, 1m}, \r
- {-1.000000000001m, -2m, -1m}, {12345.67890m,12345m,12345m},\r
- {-123456789012345.67890m, -123456789012346m, -123456789012345m},\r
- {Decimal.MaxValue, Decimal.MaxValue, Decimal.MaxValue},\r
- {Decimal.MinValue, Decimal.MinValue, Decimal.MinValue},\r
- {6.999999999m, 6m, 6m}, {-6.999999999m, -7m, -6m}, \r
- {0.00001m, 0m, 0m}, {-0.00001m, -1m, 0m}\r
- };\r
-\r
- decimal d;\r
- \r
- for (int i = 0; i < dtab.GetLength(0); i++)\r
- {\r
- d = Decimal.Floor(dtab[i,0]);\r
- if (d != dtab[i,1]) \r
- {\r
- Fail("Floor: Floor(" + dtab[i,0] + ") != " + d);\r
- }\r
- d = Decimal.Truncate(dtab[i,0]);\r
- if (d != dtab[i,2]) \r
- {\r
- Fail("Truncate: Truncate(" + dtab[i,0] + ") != " + d);\r
- }\r
- }\r
- }\r
-\r
- [Test]\r
- public void Truncate () \r
- {\r
- decimal dd = 249.9m;\r
- decimal dt = Decimal.Truncate (dd);\r
- AssertEquals ("Original", 249.9m, dd);\r
- AssertEquals ("Truncate", 249m, dt);\r
- AssertEquals ("Cast-Byte", 249, (byte)dd);\r
- AssertEquals ("Cast-Char", 249, (char)dd);\r
- AssertEquals ("Cast-Int16", 249, (short)dd);\r
- AssertEquals ("Cast-UInt16", 249, (ushort)dd);\r
- AssertEquals ("Cast-Int32", 249, (int)dd);\r
- AssertEquals ("Cast-UInt32", 249, (uint)dd);\r
- AssertEquals ("Cast-Int64", 249, (long)dd);\r
- AssertEquals ("Cast-UInt64", 249, (ulong)dd);\r
- }\r
-\r
- public void TestRound()\r
- {\r
- decimal[,] dtab = { \r
- {1m, 0, 1m}, {1.234567890m, 1, 1.2m}, \r
- {1.234567890m, 2, 1.23m}, {1.23450000001m, 3, 1.235m}, \r
- {1.2355m, 3, 1.236m}, \r
- {1.234567890m, 4, 1.2346m}, {1.23567890m, 2, 1.24m}, \r
- {47893764694.4578563236436621m, 7, 47893764694.4578563m},\r
- {-47893764694.4578563236436621m, 9, -47893764694.457856324m},\r
- {-47893764694.4578m, 5, -47893764694.4578m}\r
- };\r
-\r
- decimal d;\r
- \r
- for (int i = 0; i < dtab.GetLength(0); i++)\r
- {\r
- d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);\r
- if (d != dtab[i,2]) \r
- {\r
- Fail("Round: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);\r
- }\r
- }\r
- }\r
- \r
- public void TestRoundFailures ()\r
- {\r
- decimal[,] dtab = { \r
- {1.2345m, 3, 1.234m} \r
- };\r
-\r
- decimal d;\r
- \r
- for (int i = 0; i < dtab.GetLength(0); i++)\r
- {\r
- d = Decimal.Round(dtab[i,0], (int)dtab[i,1]);\r
- if (d != dtab[i,2]) \r
- {\r
- Fail("FailRound: Round(" + dtab[i,0] + "," + (int)dtab[i,1] + ") != " + d);\r
- }\r
- }\r
- }\r
-\r
- [Test]\r
- public void ParseInt64 () \r
- {\r
- long max = Int64.MaxValue;\r
- Decimal dmax = Decimal.Parse (max.ToString ());\r
- AssertEquals ("Int64.MaxValue", Int64.MaxValue, Decimal.ToInt64 (dmax));\r
-\r
- long min = Int64.MinValue;\r
- Decimal dmin = Decimal.Parse (min.ToString ());\r
- AssertEquals ("Int64.MinValue", Int64.MinValue, Decimal.ToInt64 (dmin));\r
-\r
- dmax += 1.1m;\r
- dmax = Decimal.Parse (dmax.ToString ());\r
- AssertEquals ("Int64.MaxValue+1.1", Int64.MaxValue, Decimal.ToInt64 (dmax - 1.1m));\r
-\r
- dmin -= 1.1m;\r
- dmin = Decimal.Parse (dmin.ToString ());\r
- AssertEquals ("Int64.MinValue-1.1", Int64.MinValue, Decimal.ToInt64 (dmin + 1.1m));\r
- }\r
-\r
- [Test]\r
- public void ToByte () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToByte", 254, Decimal.ToByte (d));\r
- AssertEquals ("Convert.ToByte", 255, Convert.ToByte (d));\r
- AssertEquals ("IConvertible.ToByte", 255, (d as IConvertible).ToByte (null));\r
- }\r
-\r
- [Test]\r
- public void ToSByte () \r
- {\r
- Decimal d = 126.9m;\r
- AssertEquals ("Decimal.ToSByte", 126, Decimal.ToSByte (d));\r
- AssertEquals ("Convert.ToSByte", 127, Convert.ToSByte (d));\r
- AssertEquals ("IConvertible.ToSByte", 127, (d as IConvertible).ToSByte (null));\r
- d = -d;\r
- AssertEquals ("-Decimal.ToSByte", -126, Decimal.ToSByte (d));\r
- AssertEquals ("-Convert.ToSByte", -127, Convert.ToSByte (d));\r
- AssertEquals ("-IConvertible.ToSByte", -127, (d as IConvertible).ToSByte (null));\r
- }\r
-\r
- [Test]\r
- public void ToInt16 () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToInt16", 254, Decimal.ToInt16 (d));\r
- AssertEquals ("Convert.ToInt16", 255, Convert.ToInt16 (d));\r
- AssertEquals ("IConvertible.ToInt16", 255, (d as IConvertible).ToInt16 (null));\r
- d = -d;\r
- AssertEquals ("-Decimal.ToInt16", -254, Decimal.ToInt16 (d));\r
- AssertEquals ("-Convert.ToInt16", -255, Convert.ToInt16 (d));\r
- AssertEquals ("-IConvertible.ToInt16", -255, (d as IConvertible).ToInt16 (null));\r
- }\r
-\r
- [Test]\r
- public void ToUInt16 () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToUInt16", 254, Decimal.ToUInt16 (d));\r
- AssertEquals ("Convert.ToUInt16", 255, Convert.ToUInt16 (d));\r
- AssertEquals ("IConvertible.ToUInt16", 255, (d as IConvertible).ToUInt16 (null));\r
- }\r
-\r
- [Test]\r
- public void ToInt32 () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToInt32", 254, Decimal.ToInt32 (d));\r
- AssertEquals ("Convert.ToInt32", 255, Convert.ToInt32 (d));\r
- AssertEquals ("IConvertible.ToInt32", 255, (d as IConvertible).ToInt32 (null));\r
- d = -d;\r
- AssertEquals ("-Decimal.ToInt32", -254, Decimal.ToInt32 (d));\r
- AssertEquals ("-Convert.ToInt32", -255, Convert.ToInt32 (d));\r
- AssertEquals ("-IConvertible.ToInt32", -255, (d as IConvertible).ToInt32 (null));\r
- }\r
-\r
- [Test]\r
- public void ToUInt32 () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToUInt32", 254, Decimal.ToUInt32 (d));\r
- AssertEquals ("Convert.ToUInt32", 255, Convert.ToUInt32 (d));\r
- AssertEquals ("IConvertible.ToUInt32", 255, (d as IConvertible).ToUInt32 (null));\r
- }\r
-\r
- [Test]\r
- public void ToInt64 () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToInt64", 254, Decimal.ToInt64 (d));\r
- AssertEquals ("Convert.ToInt64", 255, Convert.ToInt64 (d));\r
- AssertEquals ("IConvertible.ToInt64", 255, (d as IConvertible).ToInt64 (null));\r
- d = -d;\r
- AssertEquals ("-Decimal.ToInt64", -254, Decimal.ToInt64 (d));\r
- AssertEquals ("-Convert.ToInt64", -255, Convert.ToInt64 (d));\r
- AssertEquals ("-IConvertible.ToInt64", -255, (d as IConvertible).ToInt64 (null));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof(OverflowException))]\r
- public void ToInt64_TooBig () \r
- {\r
- Decimal d = (Decimal) Int64.MaxValue;\r
- d += 1.1m;\r
- long value = Decimal.ToInt64 (d);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof(OverflowException))]\r
- public void ToInt64_TooSmall () \r
- {\r
- Decimal d = (Decimal) Int64.MinValue;\r
- d -= 1.1m;\r
- long value = Decimal.ToInt64 (d);\r
- }\r
-\r
- [Test]\r
- public void ToUInt64 () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToUInt64", 254, Decimal.ToUInt64 (d));\r
- AssertEquals ("Convert.ToUInt64", 255, Convert.ToUInt64 (d));\r
- AssertEquals ("IConvertible.ToUInt64", 255, (d as IConvertible).ToUInt64 (null));\r
- }\r
-\r
- [Test]\r
- public void ToSingle () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToSingle", 254.9f, Decimal.ToSingle (d));\r
- AssertEquals ("Convert.ToSingle", 254.9f, Convert.ToSingle (d));\r
- AssertEquals ("IConvertible.ToSingle", 254.9f, (d as IConvertible).ToSingle (null));\r
- d = -d;\r
- AssertEquals ("-Decimal.ToSingle", -254.9f, Decimal.ToSingle (d));\r
- AssertEquals ("-Convert.ToSingle", -254.9f, Convert.ToSingle (d));\r
- AssertEquals ("-IConvertible.ToSingle", -254.9f, (d as IConvertible).ToSingle (null));\r
- }\r
-\r
- [Test]\r
- public void ToDouble () \r
- {\r
- Decimal d = 254.9m;\r
- AssertEquals ("Decimal.ToDouble", 254.9d, Decimal.ToDouble (d));\r
- AssertEquals ("Convert.ToDouble", 254.9d, Convert.ToDouble (d));\r
- AssertEquals ("IConvertible.ToDouble", 254.9d, (d as IConvertible).ToDouble (null));\r
- d = -d;\r
- AssertEquals ("-Decimal.ToDouble", -254.9d, Decimal.ToDouble (d));\r
- AssertEquals ("-Convert.ToDouble", -254.9d, Convert.ToDouble (d));\r
- AssertEquals ("-IConvertible.ToDouble", -254.9d, (d as IConvertible).ToDouble (null));\r
- }\r
-\r
- [Test]\r
- public void ToString_Defaults () \r
- {\r
- Decimal d = 254.9m;\r
- // everything defaults to "G"\r
- string def = d.ToString ("G");\r
- AssertEquals ("ToString()", def, d.ToString ());\r
- AssertEquals ("ToString((IFormatProvider)null)", def, d.ToString ((IFormatProvider)null));\r
- AssertEquals ("ToString((string)null)", def, d.ToString ((string)null));\r
- AssertEquals ("ToString(empty)", def, d.ToString (String.Empty));\r
- AssertEquals ("ToString(null,null)", def, d.ToString (null, null));\r
- AssertEquals ("ToString(empty,null)", def, d.ToString (String.Empty, null));\r
-\r
- AssertEquals ("ToString()", "254.9", def);\r
- }\r
-\r
- [Test]\r
- public void CastTruncRounding ()\r
- {\r
- // casting truncs decimal value (not normal nor banker's rounding)\r
- AssertEquals ("254.9==254", 254, (long)(254.9m));\r
- AssertEquals ("-254.9=-254", -254, (long)(-254.9m));\r
- AssertEquals ("255.9==256", 255, (long)(255.9m));\r
- AssertEquals ("-255.9=-256", -255, (long)(-255.9m));\r
- }\r
-\r
- [Test]\r
- public void ParseFractions ()\r
- {\r
- decimal d1 = Decimal.Parse ("0.523456789012345467890123456789", CultureInfo.InvariantCulture);\r
- AssertEquals ("f1", 0.5234567890123454678901234568m, d1);\r
- decimal d2 = Decimal.Parse ("0.49214206543486529434634231456", CultureInfo.InvariantCulture);\r
- AssertEquals ("f2", 0.4921420654348652943463423146m, d2);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (OverflowException))]\r
- public void Parse_Int64_Overflow ()\r
- {\r
- // Int64.MaxValue + 1 + small fraction to allow 30 digits\r
- // 123456789012345678901234567890\r
- decimal d = Decimal.Parse ("9223372036854775808.0000000009", CultureInfo.InvariantCulture);\r
- long l = (long) d;\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (DivideByZeroException))]\r
- public void Remainder_ByZero () \r
- {\r
- Decimal.Remainder (254.9m, 0m);\r
- }\r
-\r
- [Test]\r
- public void Remainder () \r
- {\r
- decimal p1 = 254.9m;\r
- decimal p2 = 12.1m;\r
- decimal n1 = -254.9m;\r
- decimal n2 = -12.1m;\r
-\r
- AssertEquals ("254.9 % 12.1", 0.8m, Decimal.Remainder (p1, p2));\r
- AssertEquals ("-254.9 % 12.1", -0.8m, Decimal.Remainder (n1, p2));\r
- AssertEquals ("254.9 % -12.1", 0.8m, Decimal.Remainder (p1, n2));\r
- AssertEquals ("-254.9 % -12.1", -0.8m, Decimal.Remainder (n1, n2));\r
-\r
- AssertEquals ("12.1 % 254.9", 12.1m, Decimal.Remainder (p2, p1));\r
- AssertEquals ("-12.1 % 254.9", -12.1m, Decimal.Remainder (n2, p1));\r
- AssertEquals ("12.1 % -254.9", 12.1m, Decimal.Remainder (p2, n1));\r
- AssertEquals ("-12.1 % -254.9", -12.1m, Decimal.Remainder (n2, n1));\r
-#if NET_2_0\r
- AssertEquals ("12.1 % 12.1", 0.0m, Decimal.Remainder (p1, p1));\r
- AssertEquals ("-12.1 % 12.1", 0.0m, Decimal.Remainder (n1, p1));\r
- AssertEquals ("12.1 % -12.1", 0.0m, Decimal.Remainder (p1, n1));\r
- AssertEquals ("-12.1 % -12.1", 0.0m, Decimal.Remainder (n1, n1));\r
-#else\r
- AssertEquals ("12.1 % 12.1", 0, Decimal.Remainder (p1, p1));\r
- AssertEquals ("-12.1 % 12.1", 0, Decimal.Remainder (n1, p1));\r
- AssertEquals ("12.1 % -12.1", 0, Decimal.Remainder (p1, n1));\r
- AssertEquals ("-12.1 % -12.1", 0, Decimal.Remainder (n1, n1));\r
-#endif\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (DivideByZeroException))]\r
- public void Divide_ByZero () \r
- {\r
- Decimal.Divide (254.9m, 0m);\r
- }\r
-\r
- [Test]\r
- public void Divide () \r
- {\r
- decimal p1 = 254.9m;\r
- decimal p2 = 12.1m;\r
- decimal n1 = -254.9m;\r
- decimal n2 = -12.1m;\r
-\r
- decimal c1 = 21.066115702479338842975206612m;\r
- decimal c2 = 0.0474695959199686151431934092m;\r
-\r
- AssertEquals ("254.9 / 12.1", c1, Decimal.Divide (p1, p2));\r
- AssertEquals ("-254.9 / 12.1", -c1, Decimal.Divide (n1, p2));\r
- AssertEquals ("254.9 / -12.1", -c1, Decimal.Divide (p1, n2));\r
- AssertEquals ("-254.9 / -12.1", c1, Decimal.Divide (n1, n2));\r
-\r
- AssertEquals ("12.1 / 254.9", c2, Decimal.Divide (p2, p1));\r
- AssertEquals ("-12.1 / 254.9", -c2, Decimal.Divide (n2, p1));\r
- AssertEquals ("12.1 / -254.9", -c2, Decimal.Divide (p2, n1));\r
- AssertEquals ("-12.1 / -254.9", c2, Decimal.Divide (n2, n1));\r
-\r
- AssertEquals ("12.1 / 12.1", 1, Decimal.Divide (p1, p1));\r
- AssertEquals ("-12.1 / 12.1", -1, Decimal.Divide (n1, p1));\r
- AssertEquals ("12.1 / -12.1", -1, Decimal.Divide (p1, n1));\r
- AssertEquals ("-12.1 / -12.1", 1, Decimal.Divide (n1, n1));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void Round_InvalidDecimals_Negative () \r
- {\r
- Decimal.Round (254.9m, -1);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentOutOfRangeException))]\r
- public void Round_InvalidDecimals_TooHigh () \r
- {\r
- Decimal.Round (254.9m, 29);\r
- }\r
-\r
- [Test]\r
- public void Round_OddValue () \r
- {\r
- decimal five = 5.5555555555555555555555555555m;\r
- AssertEquals ("5,5_,00", 6, Decimal.Round (five, 0));\r
- AssertEquals ("5,5_,01", 5.6m, Decimal.Round (five, 1));\r
- AssertEquals ("5,5_,02", 5.56m, Decimal.Round (five, 2));\r
- AssertEquals ("5,5_,03", 5.556m, Decimal.Round (five, 3));\r
- AssertEquals ("5,5_,04", 5.5556m, Decimal.Round (five, 4));\r
- AssertEquals ("5,5_,05", 5.55556m, Decimal.Round (five, 5));\r
- AssertEquals ("5,5_,06", 5.555556m, Decimal.Round (five, 6));\r
- AssertEquals ("5,5_,07", 5.5555556m, Decimal.Round (five, 7));\r
- AssertEquals ("5,5_,08", 5.55555556m, Decimal.Round (five, 8));\r
- AssertEquals ("5,5_,09", 5.555555556m, Decimal.Round (five, 9));\r
- AssertEquals ("5,5_,10", 5.5555555556m, Decimal.Round (five, 10));\r
- AssertEquals ("5,5_,11", 5.55555555556m, Decimal.Round (five, 11));\r
- AssertEquals ("5,5_,12", 5.555555555556m, Decimal.Round (five, 12));\r
- AssertEquals ("5,5_,13", 5.5555555555556m, Decimal.Round (five, 13));\r
- AssertEquals ("5,5_,14", 5.55555555555556m, Decimal.Round (five, 14));\r
- AssertEquals ("5,5_,15", 5.555555555555556m, Decimal.Round (five, 15));\r
- AssertEquals ("5,5_,16", 5.5555555555555556m, Decimal.Round (five, 16));\r
- AssertEquals ("5,5_,17", 5.55555555555555556m, Decimal.Round (five, 17));\r
- AssertEquals ("5,5_,18", 5.555555555555555556m, Decimal.Round (five, 18));\r
- AssertEquals ("5,5_,19", 5.5555555555555555556m, Decimal.Round (five, 19));\r
- AssertEquals ("5,5_,20", 5.55555555555555555556m, Decimal.Round (five, 20));\r
- AssertEquals ("5,5_,21", 5.555555555555555555556m, Decimal.Round (five, 21));\r
- AssertEquals ("5,5_,22", 5.5555555555555555555556m, Decimal.Round (five, 22));\r
- AssertEquals ("5,5_,23", 5.55555555555555555555556m, Decimal.Round (five, 23));\r
- AssertEquals ("5,5_,24", 5.555555555555555555555556m, Decimal.Round (five, 24));\r
- AssertEquals ("5,5_,25", 5.5555555555555555555555556m, Decimal.Round (five, 25));\r
- AssertEquals ("5,5_,26", 5.55555555555555555555555556m, Decimal.Round (five, 26));\r
- AssertEquals ("5,5_,27", 5.555555555555555555555555556m, Decimal.Round (five, 27));\r
- AssertEquals ("5.5_,28", 5.5555555555555555555555555555m, Decimal.Round (five, 28));\r
- }\r
-\r
- [Test]\r
- public void Round_EvenValue () \r
- {\r
- AssertEquals ("2,2_5,00", 2, Decimal.Round (2.5m, 0));\r
- AssertEquals ("2,2_5,01", 2.2m, Decimal.Round (2.25m, 1));\r
- AssertEquals ("2,2_5,02", 2.22m, Decimal.Round (2.225m, 2));\r
- AssertEquals ("2,2_5,03", 2.222m, Decimal.Round (2.2225m, 3));\r
- AssertEquals ("2,2_5,04", 2.2222m, Decimal.Round (2.22225m, 4));\r
- AssertEquals ("2,2_5,05", 2.22222m, Decimal.Round (2.222225m, 5));\r
- AssertEquals ("2,2_5,06", 2.222222m, Decimal.Round (2.2222225m, 6));\r
- AssertEquals ("2,2_5,07", 2.2222222m, Decimal.Round (2.22222225m, 7));\r
- AssertEquals ("2,2_5,08", 2.22222222m, Decimal.Round (2.222222225m, 8));\r
- AssertEquals ("2,2_5,09", 2.222222222m, Decimal.Round (2.2222222225m, 9));\r
- AssertEquals ("2,2_5,10", 2.2222222222m, Decimal.Round (2.22222222225m, 10));\r
- AssertEquals ("2,2_5,11", 2.22222222222m, Decimal.Round (2.222222222225m, 11));\r
- AssertEquals ("2,2_5,12", 2.222222222222m, Decimal.Round (2.2222222222225m, 12));\r
- AssertEquals ("2,2_5,13", 2.2222222222222m, Decimal.Round (2.22222222222225m, 13));\r
- AssertEquals ("2,2_5,14", 2.22222222222222m, Decimal.Round (2.222222222222225m, 14));\r
- AssertEquals ("2,2_5,15", 2.222222222222222m, Decimal.Round (2.2222222222222225m, 15));\r
- AssertEquals ("2,2_5,16", 2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16));\r
- AssertEquals ("2,2_5,17", 2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17));\r
- AssertEquals ("2,2_5,18", 2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18));\r
- AssertEquals ("2,2_5,19", 2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19));\r
- AssertEquals ("2,2_5,20", 2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20));\r
- AssertEquals ("2,2_5,21", 2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21));\r
- AssertEquals ("2,2_5,22", 2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22));\r
- AssertEquals ("2,2_5,23", 2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23));\r
- AssertEquals ("2,2_5,24", 2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24));\r
- AssertEquals ("2,2_5,25", 2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25));\r
- AssertEquals ("2,2_5,26", 2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26));\r
- AssertEquals ("2,2_5,27", 2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27));\r
- AssertEquals ("2,2_5,28", 2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28));\r
- }\r
-\r
- [Test]\r
- public void Round_OddValue_Negative () \r
- {\r
- decimal five = -5.5555555555555555555555555555m;\r
- AssertEquals ("-5,5_,00", -6, Decimal.Round (five, 0));\r
- AssertEquals ("-5,5_,01", -5.6m, Decimal.Round (five, 1));\r
- AssertEquals ("-5,5_,02", -5.56m, Decimal.Round (five, 2));\r
- AssertEquals ("-5,5_,03", -5.556m, Decimal.Round (five, 3));\r
- AssertEquals ("-5,5_,04", -5.5556m, Decimal.Round (five, 4));\r
- AssertEquals ("-5,5_,05", -5.55556m, Decimal.Round (five, 5));\r
- AssertEquals ("-5,5_,06", -5.555556m, Decimal.Round (five, 6));\r
- AssertEquals ("-5,5_,07", -5.5555556m, Decimal.Round (five, 7));\r
- AssertEquals ("-5,5_,08", -5.55555556m, Decimal.Round (five, 8));\r
- AssertEquals ("-5,5_,09", -5.555555556m, Decimal.Round (five, 9));\r
- AssertEquals ("-5,5_,10", -5.5555555556m, Decimal.Round (five, 10));\r
- AssertEquals ("-5,5_,11", -5.55555555556m, Decimal.Round (five, 11));\r
- AssertEquals ("-5,5_,12", -5.555555555556m, Decimal.Round (five, 12));\r
- AssertEquals ("-5,5_,13", -5.5555555555556m, Decimal.Round (five, 13));\r
- AssertEquals ("-5,5_,14", -5.55555555555556m, Decimal.Round (five, 14));\r
- AssertEquals ("-5,5_,15", -5.555555555555556m, Decimal.Round (five, 15));\r
- AssertEquals ("-5,5_,16", -5.5555555555555556m, Decimal.Round (five, 16));\r
- AssertEquals ("-5,5_,17", -5.55555555555555556m, Decimal.Round (five, 17));\r
- AssertEquals ("-5,5_,18", -5.555555555555555556m, Decimal.Round (five, 18));\r
- AssertEquals ("-5,5_,19", -5.5555555555555555556m, Decimal.Round (five, 19));\r
- AssertEquals ("-5,5_,20", -5.55555555555555555556m, Decimal.Round (five, 20));\r
- AssertEquals ("-5,5_,21", -5.555555555555555555556m, Decimal.Round (five, 21));\r
- AssertEquals ("-5,5_,22", -5.5555555555555555555556m, Decimal.Round (five, 22));\r
- AssertEquals ("-5,5_,23", -5.55555555555555555555556m, Decimal.Round (five, 23));\r
- AssertEquals ("-5,5_,24", -5.555555555555555555555556m, Decimal.Round (five, 24));\r
- AssertEquals ("-5,5_,25", -5.5555555555555555555555556m, Decimal.Round (five, 25));\r
- AssertEquals ("-5,5_,26", -5.55555555555555555555555556m, Decimal.Round (five, 26));\r
- AssertEquals ("-5,5_,27", -5.555555555555555555555555556m, Decimal.Round (five, 27));\r
- AssertEquals ("-5.5_,28", -5.5555555555555555555555555555m, Decimal.Round (five, 28));\r
- }\r
-\r
- [Test]\r
- public void Round_EvenValue_Negative () \r
- {\r
- AssertEquals ("-2,2_5,00", -2, Decimal.Round (-2.5m, 0));\r
- AssertEquals ("-2,2_5,01", -2.2m, Decimal.Round (-2.25m, 1));\r
- AssertEquals ("-2,2_5,02", -2.22m, Decimal.Round (-2.225m, 2));\r
- AssertEquals ("-2,2_5,03", -2.222m, Decimal.Round (-2.2225m, 3));\r
- AssertEquals ("-2,2_5,04", -2.2222m, Decimal.Round (-2.22225m, 4));\r
- AssertEquals ("-2,2_5,05", -2.22222m, Decimal.Round (-2.222225m, 5));\r
- AssertEquals ("-2,2_5,06", -2.222222m, Decimal.Round (-2.2222225m, 6));\r
- AssertEquals ("-2,2_5,07", -2.2222222m, Decimal.Round (-2.22222225m, 7));\r
- AssertEquals ("-2,2_5,08", -2.22222222m, Decimal.Round (-2.222222225m, 8));\r
- AssertEquals ("-2,2_5,09", -2.222222222m, Decimal.Round (-2.2222222225m, 9));\r
- AssertEquals ("-2,2_5,10", -2.2222222222m, Decimal.Round (-2.22222222225m, 10));\r
- AssertEquals ("-2,2_5,11", -2.22222222222m, Decimal.Round (-2.222222222225m, 11));\r
- AssertEquals ("-2,2_5,12", -2.222222222222m, Decimal.Round (-2.2222222222225m, 12));\r
- AssertEquals ("-2,2_5,13", -2.2222222222222m, Decimal.Round (-2.22222222222225m, 13));\r
- AssertEquals ("-2,2_5,14", -2.22222222222222m, Decimal.Round (-2.222222222222225m, 14));\r
- AssertEquals ("-2,2_5,15", -2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15));\r
- AssertEquals ("-2,2_5,16", -2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16));\r
- AssertEquals ("-2,2_5,17", -2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17));\r
- AssertEquals ("-2,2_5,18", -2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18));\r
- AssertEquals ("-2,2_5,19", -2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19));\r
- AssertEquals ("-2,2_5,20", -2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20));\r
- AssertEquals ("-2,2_5,21", -2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21));\r
- AssertEquals ("-2,2_5,22", -2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22));\r
- AssertEquals ("-2,2_5,23", -2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23));\r
- AssertEquals ("-2,2_5,24", -2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24));\r
- AssertEquals ("-2,2_5,25", -2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25));\r
- AssertEquals ("-2,2_5,26", -2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26));\r
- AssertEquals ("-2,2_5,27", -2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27));\r
- AssertEquals ("-2,2_5,28", -2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28));\r
+ [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;
+
+ AssertEquals ("254.9 / 12.1", c1, Decimal.Divide (p1, p2));
+ AssertEquals ("-254.9 / 12.1", -c1, Decimal.Divide (n1, p2));
+ AssertEquals ("254.9 / -12.1", -c1, Decimal.Divide (p1, n2));
+ AssertEquals ("-254.9 / -12.1", c1, Decimal.Divide (n1, n2));
+
+ AssertEquals ("12.1 / 254.9", c2, Decimal.Divide (p2, p1));
+ AssertEquals ("-12.1 / 254.9", -c2, Decimal.Divide (n2, p1));
+ AssertEquals ("12.1 / -254.9", -c2, Decimal.Divide (p2, n1));
+ AssertEquals ("-12.1 / -254.9", c2, Decimal.Divide (n2, n1));
+
+ AssertEquals ("12.1 / 12.1", 1, Decimal.Divide (p1, p1));
+ AssertEquals ("-12.1 / 12.1", -1, Decimal.Divide (n1, p1));
+ AssertEquals ("12.1 / -12.1", -1, Decimal.Divide (p1, n1));
+ AssertEquals ("-12.1 / -12.1", 1, Decimal.Divide (n1, n1));
+ }
+
+ [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;
+ AssertEquals ("5,5_,00", 6, Decimal.Round (five, 0));
+ AssertEquals ("5,5_,01", 5.6m, Decimal.Round (five, 1));
+ AssertEquals ("5,5_,02", 5.56m, Decimal.Round (five, 2));
+ AssertEquals ("5,5_,03", 5.556m, Decimal.Round (five, 3));
+ AssertEquals ("5,5_,04", 5.5556m, Decimal.Round (five, 4));
+ AssertEquals ("5,5_,05", 5.55556m, Decimal.Round (five, 5));
+ AssertEquals ("5,5_,06", 5.555556m, Decimal.Round (five, 6));
+ AssertEquals ("5,5_,07", 5.5555556m, Decimal.Round (five, 7));
+ AssertEquals ("5,5_,08", 5.55555556m, Decimal.Round (five, 8));
+ AssertEquals ("5,5_,09", 5.555555556m, Decimal.Round (five, 9));
+ AssertEquals ("5,5_,10", 5.5555555556m, Decimal.Round (five, 10));
+ AssertEquals ("5,5_,11", 5.55555555556m, Decimal.Round (five, 11));
+ AssertEquals ("5,5_,12", 5.555555555556m, Decimal.Round (five, 12));
+ AssertEquals ("5,5_,13", 5.5555555555556m, Decimal.Round (five, 13));
+ AssertEquals ("5,5_,14", 5.55555555555556m, Decimal.Round (five, 14));
+ AssertEquals ("5,5_,15", 5.555555555555556m, Decimal.Round (five, 15));
+ AssertEquals ("5,5_,16", 5.5555555555555556m, Decimal.Round (five, 16));
+ AssertEquals ("5,5_,17", 5.55555555555555556m, Decimal.Round (five, 17));
+ AssertEquals ("5,5_,18", 5.555555555555555556m, Decimal.Round (five, 18));
+ AssertEquals ("5,5_,19", 5.5555555555555555556m, Decimal.Round (five, 19));
+ AssertEquals ("5,5_,20", 5.55555555555555555556m, Decimal.Round (five, 20));
+ AssertEquals ("5,5_,21", 5.555555555555555555556m, Decimal.Round (five, 21));
+ AssertEquals ("5,5_,22", 5.5555555555555555555556m, Decimal.Round (five, 22));
+ AssertEquals ("5,5_,23", 5.55555555555555555555556m, Decimal.Round (five, 23));
+ AssertEquals ("5,5_,24", 5.555555555555555555555556m, Decimal.Round (five, 24));
+ AssertEquals ("5,5_,25", 5.5555555555555555555555556m, Decimal.Round (five, 25));
+ AssertEquals ("5,5_,26", 5.55555555555555555555555556m, Decimal.Round (five, 26));
+ AssertEquals ("5,5_,27", 5.555555555555555555555555556m, Decimal.Round (five, 27));
+ AssertEquals ("5.5_,28", 5.5555555555555555555555555555m, Decimal.Round (five, 28));
+ }
+
+ [Test]
+ public void Round_EvenValue ()
+ {
+ AssertEquals ("2,2_5,00", 2, Decimal.Round (2.5m, 0));
+ AssertEquals ("2,2_5,01", 2.2m, Decimal.Round (2.25m, 1));
+ AssertEquals ("2,2_5,02", 2.22m, Decimal.Round (2.225m, 2));
+ AssertEquals ("2,2_5,03", 2.222m, Decimal.Round (2.2225m, 3));
+ AssertEquals ("2,2_5,04", 2.2222m, Decimal.Round (2.22225m, 4));
+ AssertEquals ("2,2_5,05", 2.22222m, Decimal.Round (2.222225m, 5));
+ AssertEquals ("2,2_5,06", 2.222222m, Decimal.Round (2.2222225m, 6));
+ AssertEquals ("2,2_5,07", 2.2222222m, Decimal.Round (2.22222225m, 7));
+ AssertEquals ("2,2_5,08", 2.22222222m, Decimal.Round (2.222222225m, 8));
+ AssertEquals ("2,2_5,09", 2.222222222m, Decimal.Round (2.2222222225m, 9));
+ AssertEquals ("2,2_5,10", 2.2222222222m, Decimal.Round (2.22222222225m, 10));
+ AssertEquals ("2,2_5,11", 2.22222222222m, Decimal.Round (2.222222222225m, 11));
+ AssertEquals ("2,2_5,12", 2.222222222222m, Decimal.Round (2.2222222222225m, 12));
+ AssertEquals ("2,2_5,13", 2.2222222222222m, Decimal.Round (2.22222222222225m, 13));
+ AssertEquals ("2,2_5,14", 2.22222222222222m, Decimal.Round (2.222222222222225m, 14));
+ AssertEquals ("2,2_5,15", 2.222222222222222m, Decimal.Round (2.2222222222222225m, 15));
+ AssertEquals ("2,2_5,16", 2.2222222222222222m, Decimal.Round (2.22222222222222225m, 16));
+ AssertEquals ("2,2_5,17", 2.22222222222222222m, Decimal.Round (2.222222222222222225m, 17));
+ AssertEquals ("2,2_5,18", 2.222222222222222222m, Decimal.Round (2.2222222222222222225m, 18));
+ AssertEquals ("2,2_5,19", 2.2222222222222222222m, Decimal.Round (2.22222222222222222225m, 19));
+ AssertEquals ("2,2_5,20", 2.22222222222222222222m, Decimal.Round (2.222222222222222222225m, 20));
+ AssertEquals ("2,2_5,21", 2.222222222222222222222m, Decimal.Round (2.2222222222222222222225m, 21));
+ AssertEquals ("2,2_5,22", 2.2222222222222222222222m, Decimal.Round (2.22222222222222222222225m, 22));
+ AssertEquals ("2,2_5,23", 2.22222222222222222222222m, Decimal.Round (2.222222222222222222222225m, 23));
+ AssertEquals ("2,2_5,24", 2.222222222222222222222222m, Decimal.Round (2.2222222222222222222222225m, 24));
+ AssertEquals ("2,2_5,25", 2.2222222222222222222222222m, Decimal.Round (2.22222222222222222222222225m, 25));
+ AssertEquals ("2,2_5,26", 2.22222222222222222222222222m, Decimal.Round (2.222222222222222222222222225m, 26));
+ AssertEquals ("2,2_5,27", 2.222222222222222222222222222m, Decimal.Round (2.2222222222222222222222222225m, 27));
+ AssertEquals ("2,2_5,28", 2.2222222222222222222222222222m, Decimal.Round (2.22222222222222222222222222225m, 28));
+ }
+
+ [Test]
+ public void Round_OddValue_Negative ()
+ {
+ decimal five = -5.5555555555555555555555555555m;
+ AssertEquals ("-5,5_,00", -6, Decimal.Round (five, 0));
+ AssertEquals ("-5,5_,01", -5.6m, Decimal.Round (five, 1));
+ AssertEquals ("-5,5_,02", -5.56m, Decimal.Round (five, 2));
+ AssertEquals ("-5,5_,03", -5.556m, Decimal.Round (five, 3));
+ AssertEquals ("-5,5_,04", -5.5556m, Decimal.Round (five, 4));
+ AssertEquals ("-5,5_,05", -5.55556m, Decimal.Round (five, 5));
+ AssertEquals ("-5,5_,06", -5.555556m, Decimal.Round (five, 6));
+ AssertEquals ("-5,5_,07", -5.5555556m, Decimal.Round (five, 7));
+ AssertEquals ("-5,5_,08", -5.55555556m, Decimal.Round (five, 8));
+ AssertEquals ("-5,5_,09", -5.555555556m, Decimal.Round (five, 9));
+ AssertEquals ("-5,5_,10", -5.5555555556m, Decimal.Round (five, 10));
+ AssertEquals ("-5,5_,11", -5.55555555556m, Decimal.Round (five, 11));
+ AssertEquals ("-5,5_,12", -5.555555555556m, Decimal.Round (five, 12));
+ AssertEquals ("-5,5_,13", -5.5555555555556m, Decimal.Round (five, 13));
+ AssertEquals ("-5,5_,14", -5.55555555555556m, Decimal.Round (five, 14));
+ AssertEquals ("-5,5_,15", -5.555555555555556m, Decimal.Round (five, 15));
+ AssertEquals ("-5,5_,16", -5.5555555555555556m, Decimal.Round (five, 16));
+ AssertEquals ("-5,5_,17", -5.55555555555555556m, Decimal.Round (five, 17));
+ AssertEquals ("-5,5_,18", -5.555555555555555556m, Decimal.Round (five, 18));
+ AssertEquals ("-5,5_,19", -5.5555555555555555556m, Decimal.Round (five, 19));
+ AssertEquals ("-5,5_,20", -5.55555555555555555556m, Decimal.Round (five, 20));
+ AssertEquals ("-5,5_,21", -5.555555555555555555556m, Decimal.Round (five, 21));
+ AssertEquals ("-5,5_,22", -5.5555555555555555555556m, Decimal.Round (five, 22));
+ AssertEquals ("-5,5_,23", -5.55555555555555555555556m, Decimal.Round (five, 23));
+ AssertEquals ("-5,5_,24", -5.555555555555555555555556m, Decimal.Round (five, 24));
+ AssertEquals ("-5,5_,25", -5.5555555555555555555555556m, Decimal.Round (five, 25));
+ AssertEquals ("-5,5_,26", -5.55555555555555555555555556m, Decimal.Round (five, 26));
+ AssertEquals ("-5,5_,27", -5.555555555555555555555555556m, Decimal.Round (five, 27));
+ AssertEquals ("-5.5_,28", -5.5555555555555555555555555555m, Decimal.Round (five, 28));
+ }
+
+ [Test]
+ public void Round_EvenValue_Negative ()
+ {
+ AssertEquals ("-2,2_5,00", -2, Decimal.Round (-2.5m, 0));
+ AssertEquals ("-2,2_5,01", -2.2m, Decimal.Round (-2.25m, 1));
+ AssertEquals ("-2,2_5,02", -2.22m, Decimal.Round (-2.225m, 2));
+ AssertEquals ("-2,2_5,03", -2.222m, Decimal.Round (-2.2225m, 3));
+ AssertEquals ("-2,2_5,04", -2.2222m, Decimal.Round (-2.22225m, 4));
+ AssertEquals ("-2,2_5,05", -2.22222m, Decimal.Round (-2.222225m, 5));
+ AssertEquals ("-2,2_5,06", -2.222222m, Decimal.Round (-2.2222225m, 6));
+ AssertEquals ("-2,2_5,07", -2.2222222m, Decimal.Round (-2.22222225m, 7));
+ AssertEquals ("-2,2_5,08", -2.22222222m, Decimal.Round (-2.222222225m, 8));
+ AssertEquals ("-2,2_5,09", -2.222222222m, Decimal.Round (-2.2222222225m, 9));
+ AssertEquals ("-2,2_5,10", -2.2222222222m, Decimal.Round (-2.22222222225m, 10));
+ AssertEquals ("-2,2_5,11", -2.22222222222m, Decimal.Round (-2.222222222225m, 11));
+ AssertEquals ("-2,2_5,12", -2.222222222222m, Decimal.Round (-2.2222222222225m, 12));
+ AssertEquals ("-2,2_5,13", -2.2222222222222m, Decimal.Round (-2.22222222222225m, 13));
+ AssertEquals ("-2,2_5,14", -2.22222222222222m, Decimal.Round (-2.222222222222225m, 14));
+ AssertEquals ("-2,2_5,15", -2.222222222222222m, Decimal.Round (-2.2222222222222225m, 15));
+ AssertEquals ("-2,2_5,16", -2.2222222222222222m, Decimal.Round (-2.22222222222222225m, 16));
+ AssertEquals ("-2,2_5,17", -2.22222222222222222m, Decimal.Round (-2.222222222222222225m, 17));
+ AssertEquals ("-2,2_5,18", -2.222222222222222222m, Decimal.Round (-2.2222222222222222225m, 18));
+ AssertEquals ("-2,2_5,19", -2.2222222222222222222m, Decimal.Round (-2.22222222222222222225m, 19));
+ AssertEquals ("-2,2_5,20", -2.22222222222222222222m, Decimal.Round (-2.222222222222222222225m, 20));
+ AssertEquals ("-2,2_5,21", -2.222222222222222222222m, Decimal.Round (-2.2222222222222222222225m, 21));
+ AssertEquals ("-2,2_5,22", -2.2222222222222222222222m, Decimal.Round (-2.22222222222222222222225m, 22));
+ AssertEquals ("-2,2_5,23", -2.22222222222222222222222m, Decimal.Round (-2.222222222222222222222225m, 23));
+ AssertEquals ("-2,2_5,24", -2.222222222222222222222222m, Decimal.Round (-2.2222222222222222222222225m, 24));
+ AssertEquals ("-2,2_5,25", -2.2222222222222222222222222m, Decimal.Round (-2.22222222222222222222222225m, 25));
+ AssertEquals ("-2,2_5,26", -2.22222222222222222222222222m, Decimal.Round (-2.222222222222222222222222225m, 26));
+ AssertEquals ("-2,2_5,27", -2.222222222222222222222222222m, Decimal.Round (-2.2222222222222222222222222225m, 27));
+ AssertEquals ("-2,2_5,28", -2.2222222222222222222222222222m, Decimal.Round (-2.22222222222222222222222222225m, 28));
}
[Test]
AssertEquals ("26", "0.00000000000000000000000001", (0.00000000000000000000000001m).ToString ());
AssertEquals ("27", "0.000000000000000000000000001", (0.000000000000000000000000001m).ToString ());
AssertEquals ("28", "0.0000000000000000000000000001", (0.0000000000000000000000000001m).ToString ());
- }\r
- }\r
-}\r
+ }
+ }
+}
projects / mono.git / commitdiff