-//\r
-// MonoTests.System.NumberFormatterTest\r
-//\r
-// Authors: \r
-// akiramei (mei@work.email.ne.jp)\r
-//\r
-// (C) 2005 akiramei\r
-//\r
-\r
-using System;\r
-using System.Globalization;\r
-using NUnit.Framework;\r
-\r
-namespace MonoTests.System {\r
- \r
- public class NumberFormatterTest : TestCase {\r
-\r
- NumberFormatInfo _nfi;\r
- [SetUp]\r
- protected override void SetUp () {\r
- _nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;\r
- }\r
-\r
- // Test00000- Int32 and D\r
- [Test]\r
- public void Test00000 () {\r
- AssertEquals ("#01", "0", 0.ToString ("D", _nfi));\r
- AssertEquals ("#02", "0", 0.ToString ("d", _nfi));\r
- AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("D", _nfi));\r
- AssertEquals ("#04", "-2147483648", Int32.MinValue.ToString ("d", _nfi));\r
- AssertEquals ("#05", "2147483647", Int32.MaxValue.ToString ("D", _nfi));\r
- AssertEquals ("#06", "2147483647", Int32.MaxValue.ToString ("d", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00001 () {\r
- AssertEquals ("#01", "D ", 0.ToString ("D ", _nfi));\r
- AssertEquals ("#02", " D", 0.ToString (" D", _nfi));\r
- AssertEquals ("#03", " D ", 0.ToString (" D ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00002 () {\r
- AssertEquals ("#01", "-D ", (-1).ToString ("D ", _nfi));\r
- AssertEquals ("#02", "- D", (-1).ToString (" D", _nfi));\r
- AssertEquals ("#03", "- D ", (-1).ToString (" D ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00003 () {\r
- AssertEquals ("#01", "0", 0.ToString ("D0", _nfi));\r
- AssertEquals ("#02", "0000000000", 0.ToString ("D10", _nfi));\r
- AssertEquals ("#03", "00000000000", 0.ToString ("D11", _nfi));\r
- AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("D99", _nfi));\r
- AssertEquals ("#05", "D100", 0.ToString ("D100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00004 () {\r
- AssertEquals ("#01", "2147483647", Int32.MaxValue.ToString ("D0", _nfi));\r
- AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("D10", _nfi));\r
- AssertEquals ("#03", "02147483647", Int32.MaxValue.ToString ("D11", _nfi));\r
- AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483647", Int32.MaxValue.ToString ("D99", _nfi));\r
- AssertEquals ("#05", "D12147483647", Int32.MaxValue.ToString ("D100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00005 () {\r
- AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString ("D0", _nfi));\r
- AssertEquals ("#02", "-2147483648", Int32.MinValue.ToString ("D10", _nfi));\r
- AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("D11", _nfi));\r
- AssertEquals ("#04", "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483648", Int32.MinValue.ToString ("D99", _nfi));\r
- AssertEquals ("#05", "-D12147483648", Int32.MinValue.ToString ("D100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00006 () {\r
- AssertEquals ("#01", "DF", 0.ToString ("DF", _nfi));\r
- AssertEquals ("#02", "D0F", 0.ToString ("D0F", _nfi));\r
- AssertEquals ("#03", "D0xF", 0.ToString ("D0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00007 () {\r
- AssertEquals ("#01", "DF", Int32.MaxValue.ToString ("DF", _nfi));\r
- AssertEquals ("#02", "D2147483647F", Int32.MaxValue.ToString ("D0F", _nfi));\r
- AssertEquals ("#03", "D2147483647xF", Int32.MaxValue.ToString ("D0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00008 () {\r
- AssertEquals ("#01", "-DF", Int32.MinValue.ToString ("DF", _nfi));\r
- AssertEquals ("#02", "-D2147483648F", Int32.MinValue.ToString ("D0F", _nfi));\r
- AssertEquals ("#03", "-D2147483648xF", Int32.MinValue.ToString ("D0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00009 () {\r
- AssertEquals ("#01", "00000000000", 0.ToString ("D0000000000000000000000000000000000000011", _nfi));\r
- AssertEquals ("#02", "02147483647", Int32.MaxValue.ToString ("D0000000000000000000000000000000000000011", _nfi));\r
- AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("D0000000000000000000000000000000000000011", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00010 () {\r
- AssertEquals ("#01", "+D", 0.ToString ("+D", _nfi));\r
- AssertEquals ("#02", "D+", 0.ToString ("D+", _nfi));\r
- AssertEquals ("#03", "+D+", 0.ToString ("+D+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test00011 () {\r
- AssertEquals ("#01", "+D", Int32.MaxValue.ToString ("+D", _nfi));\r
- AssertEquals ("#02", "D+", Int32.MaxValue.ToString ("D+", _nfi));\r
- AssertEquals ("#03", "+D+", Int32.MaxValue.ToString ("+D+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00012 () {\r
- AssertEquals ("#01", "-+D", Int32.MinValue.ToString ("+D", _nfi));\r
- AssertEquals ("#02", "-D+", Int32.MinValue.ToString ("D+", _nfi));\r
- AssertEquals ("#03", "-+D+", Int32.MinValue.ToString ("+D+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00013 () {\r
- AssertEquals ("#01", "-D", 0.ToString ("-D", _nfi));\r
- AssertEquals ("#02", "D-", 0.ToString ("D-", _nfi));\r
- AssertEquals ("#03", "-D-", 0.ToString ("-D-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test00014 () {\r
- AssertEquals ("#01", "-D", Int32.MaxValue.ToString ("-D", _nfi));\r
- AssertEquals ("#02", "D-", Int32.MaxValue.ToString ("D-", _nfi));\r
- AssertEquals ("#03", "-D-", Int32.MaxValue.ToString ("-D-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00015 () {\r
- AssertEquals ("#01", "--D", Int32.MinValue.ToString ("-D", _nfi));\r
- AssertEquals ("#02", "-D-", Int32.MinValue.ToString ("D-", _nfi));\r
- AssertEquals ("#03", "--D-", Int32.MinValue.ToString ("-D-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00016 () {\r
- AssertEquals ("#01", "D+0", 0.ToString ("D+0", _nfi));\r
- AssertEquals ("#02", "D+2147483647", Int32.MaxValue.ToString ("D+0", _nfi));\r
- AssertEquals ("#03", "-D+2147483648", Int32.MinValue.ToString ("D+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00017 () {\r
- AssertEquals ("#01", "D+9", 0.ToString ("D+9", _nfi));\r
- AssertEquals ("#02", "D+9", Int32.MaxValue.ToString ("D+9", _nfi));\r
- AssertEquals ("#03", "-D+9", Int32.MinValue.ToString ("D+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00018 () {\r
- AssertEquals ("#01", "D-9", 0.ToString ("D-9", _nfi));\r
- AssertEquals ("#02", "D-9", Int32.MaxValue.ToString ("D-9", _nfi));\r
- AssertEquals ("#03", "-D-9", Int32.MinValue.ToString ("D-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00019 () {\r
- AssertEquals ("#01", "D0", 0.ToString ("D0,", _nfi));\r
- AssertEquals ("#02", "D2147484", Int32.MaxValue.ToString ("D0,", _nfi));\r
- AssertEquals ("#03", "-D2147484", Int32.MinValue.ToString ("D0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00020 () {\r
- AssertEquals ("#01", "D0", 0.ToString ("D0.", _nfi));\r
- AssertEquals ("#02", "D2147483647", Int32.MaxValue.ToString ("D0.", _nfi));\r
- AssertEquals ("#03", "-D2147483648", Int32.MinValue.ToString ("D0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00021 () {\r
- AssertEquals ("#01", "D0.0", 0.ToString ("D0.0", _nfi));\r
- AssertEquals ("#02", "D2147483647.0", Int32.MaxValue.ToString ("D0.0", _nfi));\r
- AssertEquals ("#03", "-D2147483648.0", Int32.MinValue.ToString ("D0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test00022 () {\r
- AssertEquals ("#01", "D09", 0.ToString ("D0.9", _nfi));\r
- AssertEquals ("#02", "D21474836479", Int32.MaxValue.ToString ("D0.9", _nfi));\r
- AssertEquals ("#03", "-D21474836489", Int32.MinValue.ToString ("D0.9", _nfi));\r
- }\r
-\r
- // Test01000- Int32 and E\r
- [Test]\r
- public void Test01000 () {\r
- AssertEquals ("#01", "0.000000E+000", 0.ToString ("E", _nfi));\r
- AssertEquals ("#02", "0.000000e+000", 0.ToString ("e", _nfi));\r
- AssertEquals ("#03", "-2.147484E+009", Int32.MinValue.ToString ("E", _nfi));\r
- AssertEquals ("#04", "-2.147484e+009", Int32.MinValue.ToString ("e", _nfi));\r
- AssertEquals ("#05", "2.147484E+009", Int32.MaxValue.ToString ("E", _nfi));\r
- AssertEquals ("#06", "2.147484e+009", Int32.MaxValue.ToString ("e", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01001 () {\r
- AssertEquals ("#01", "E ", 0.ToString ("E ", _nfi));\r
- AssertEquals ("#02", " E", 0.ToString (" E", _nfi));\r
- AssertEquals ("#03", " E ", 0.ToString (" E ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01002 () {\r
- AssertEquals ("#01", "-E ", (-1).ToString ("E ", _nfi));\r
- AssertEquals ("#02", "- E", (-1).ToString (" E", _nfi));\r
- AssertEquals ("#03", "- E ", (-1).ToString (" E ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01003 () {\r
- AssertEquals ("#01", "0E+000", 0.ToString ("E0", _nfi));\r
- AssertEquals ("#02", "0.000000000E+000", 0.ToString ("E9", _nfi));\r
- AssertEquals ("#03", "0.0000000000E+000", 0.ToString ("E10", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.ToString ("E99", _nfi));\r
- AssertEquals ("#05", "E100", 0.ToString ("E100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01004 () {\r
- AssertEquals ("#01", "2E+009", Int32.MaxValue.ToString ("E0", _nfi));\r
- AssertEquals ("#02", "2.147483647E+009", Int32.MaxValue.ToString ("E9", _nfi));\r
- AssertEquals ("#03", "2.1474836470E+009", Int32.MaxValue.ToString ("E10", _nfi));\r
- AssertEquals ("#04", "2.147483647000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MaxValue.ToString ("E99", _nfi));\r
- AssertEquals ("#05", "E12147483647", Int32.MaxValue.ToString ("E100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01005 () {\r
- AssertEquals ("#01", "-2E+009", Int32.MinValue.ToString ("E0", _nfi));\r
- AssertEquals ("#02", "-2.147483648E+009", Int32.MinValue.ToString ("E9", _nfi));\r
- AssertEquals ("#03", "-2.1474836480E+009", Int32.MinValue.ToString ("E10", _nfi));\r
- AssertEquals ("#04", "-2.147483648000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MinValue.ToString ("E99", _nfi));\r
- AssertEquals ("#05", "-E12147483648", Int32.MinValue.ToString ("E100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01006 () {\r
- AssertEquals ("#01", "EF", 0.ToString ("EF", _nfi));\r
- AssertEquals ("#02", "E0F", 0.ToString ("E0F", _nfi));\r
- AssertEquals ("#03", "E0xF", 0.ToString ("E0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01007 () {\r
- AssertEquals ("#01", "EF", Int32.MaxValue.ToString ("EF", _nfi));\r
- AssertEquals ("#02", "E0F", Int32.MaxValue.ToString ("E0F", _nfi));\r
- AssertEquals ("#03", "E0xF", Int32.MaxValue.ToString ("E0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01008 () {\r
- AssertEquals ("#01", "-EF", Int32.MinValue.ToString ("EF", _nfi));\r
- AssertEquals ("#02", "E0F", Int32.MinValue.ToString ("E0F", _nfi));\r
- AssertEquals ("#03", "E0xF", Int32.MinValue.ToString ("E0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01009 () {\r
- AssertEquals ("#01", "0.0000000000E+000", 0.ToString ("E0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#02", "2.1474836470E+009", Int32.MaxValue.ToString ("E0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#03", "-2.1474836480E+009", Int32.MinValue.ToString ("E0000000000000000000000000000000000000010", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01010 () {\r
- AssertEquals ("#01", "+E", 0.ToString ("+E", _nfi));\r
- AssertEquals ("#02", "E+", 0.ToString ("E+", _nfi));\r
- AssertEquals ("#03", "+E+", 0.ToString ("+E+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test01011 () {\r
- AssertEquals ("#01", "+E", Int32.MaxValue.ToString ("+E", _nfi));\r
- AssertEquals ("#02", "E+", Int32.MaxValue.ToString ("E+", _nfi));\r
- AssertEquals ("#03", "+E+", Int32.MaxValue.ToString ("+E+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01012 () {\r
- AssertEquals ("#01", "-+E", Int32.MinValue.ToString ("+E", _nfi));\r
- AssertEquals ("#02", "-E+", Int32.MinValue.ToString ("E+", _nfi));\r
- AssertEquals ("#03", "-+E+", Int32.MinValue.ToString ("+E+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01013 () {\r
- AssertEquals ("#01", "-E", 0.ToString ("-E", _nfi));\r
- AssertEquals ("#02", "E-", 0.ToString ("E-", _nfi));\r
- AssertEquals ("#03", "-E-", 0.ToString ("-E-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test01014 () {\r
- AssertEquals ("#01", "-E", Int32.MaxValue.ToString ("-E", _nfi));\r
- AssertEquals ("#02", "E-", Int32.MaxValue.ToString ("E-", _nfi));\r
- AssertEquals ("#03", "-E-", Int32.MaxValue.ToString ("-E-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01015 () {\r
- AssertEquals ("#01", "--E", Int32.MinValue.ToString ("-E", _nfi));\r
- AssertEquals ("#02", "-E-", Int32.MinValue.ToString ("E-", _nfi));\r
- AssertEquals ("#03", "--E-", Int32.MinValue.ToString ("-E-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01016 () {\r
- AssertEquals ("#01", "E+0", 0.ToString ("E+0", _nfi));\r
- AssertEquals ("#02", "E+0", Int32.MaxValue.ToString ("E+0", _nfi));\r
- AssertEquals ("#03", "E+0", Int32.MinValue.ToString ("E+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01017 () {\r
- AssertEquals ("#01", "E+9", 0.ToString ("E+9", _nfi));\r
- AssertEquals ("#02", "E+9", Int32.MaxValue.ToString ("E+9", _nfi));\r
- AssertEquals ("#03", "-E+9", Int32.MinValue.ToString ("E+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01018 () {\r
- AssertEquals ("#01", "E-9", 0.ToString ("E-9", _nfi));\r
- AssertEquals ("#02", "E-9", Int32.MaxValue.ToString ("E-9", _nfi));\r
- AssertEquals ("#03", "-E-9", Int32.MinValue.ToString ("E-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01019 () {\r
- AssertEquals ("#01", "E0", 0.ToString ("E0,", _nfi));\r
- AssertEquals ("#02", "E0", Int32.MaxValue.ToString ("E0,", _nfi));\r
- AssertEquals ("#03", "E0", Int32.MinValue.ToString ("E0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01020 () {\r
- AssertEquals ("#01", "E0", 0.ToString ("E0.", _nfi));\r
- AssertEquals ("#02", "E0", Int32.MaxValue.ToString ("E0.", _nfi));\r
- AssertEquals ("#03", "E0", Int32.MinValue.ToString ("E0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01021 () {\r
- AssertEquals ("#01", "E0.0", 0.ToString ("E0.0", _nfi));\r
- AssertEquals ("#02", "E10.2", Int32.MaxValue.ToString ("E0.0", _nfi));\r
- AssertEquals ("#03", "-E10.2", Int32.MinValue.ToString ("E0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01022 () {\r
- AssertEquals ("#01", "E09", 0.ToString ("E0.9", _nfi));\r
- AssertEquals ("#02", "E09", Int32.MaxValue.ToString ("E0.9", _nfi));\r
- AssertEquals ("#03", "E09", Int32.MinValue.ToString ("E0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01023 () {\r
- AssertEquals ("#01", "9.999999E+007", 99999990.ToString ("E", _nfi));\r
- AssertEquals ("#02", "9.999999E+007", 99999991.ToString ("E", _nfi));\r
- AssertEquals ("#03", "9.999999E+007", 99999992.ToString ("E", _nfi));\r
- AssertEquals ("#04", "9.999999E+007", 99999993.ToString ("E", _nfi));\r
- AssertEquals ("#05", "9.999999E+007", 99999994.ToString ("E", _nfi));\r
- AssertEquals ("#06", "1.000000E+008", 99999995.ToString ("E", _nfi));\r
- AssertEquals ("#07", "1.000000E+008", 99999996.ToString ("E", _nfi));\r
- AssertEquals ("#08", "1.000000E+008", 99999997.ToString ("E", _nfi));\r
- AssertEquals ("#09", "1.000000E+008", 99999998.ToString ("E", _nfi));\r
- AssertEquals ("#10", "1.000000E+008", 99999999.ToString ("E", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01024 () {\r
- AssertEquals ("#01", "-9.999999E+007", (-99999990).ToString ("E", _nfi));\r
- AssertEquals ("#02", "-9.999999E+007", (-99999991).ToString ("E", _nfi));\r
- AssertEquals ("#03", "-9.999999E+007", (-99999992).ToString ("E", _nfi));\r
- AssertEquals ("#04", "-9.999999E+007", (-99999993).ToString ("E", _nfi));\r
- AssertEquals ("#05", "-9.999999E+007", (-99999994).ToString ("E", _nfi));\r
- AssertEquals ("#06", "-1.000000E+008", (-99999995).ToString ("E", _nfi));\r
- AssertEquals ("#07", "-1.000000E+008", (-99999996).ToString ("E", _nfi));\r
- AssertEquals ("#08", "-1.000000E+008", (-99999997).ToString ("E", _nfi));\r
- AssertEquals ("#09", "-1.000000E+008", (-99999998).ToString ("E", _nfi));\r
- AssertEquals ("#10", "-1.000000E+008", (-99999999).ToString ("E", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01025 () {\r
- AssertEquals ("#01", "9.999998E+007", 99999980.ToString ("E", _nfi));\r
- AssertEquals ("#02", "9.999998E+007", 99999981.ToString ("E", _nfi));\r
- AssertEquals ("#03", "9.999998E+007", 99999982.ToString ("E", _nfi));\r
- AssertEquals ("#04", "9.999998E+007", 99999983.ToString ("E", _nfi));\r
- AssertEquals ("#05", "9.999998E+007", 99999984.ToString ("E", _nfi));\r
- AssertEquals ("#06", "9.999999E+007", 99999985.ToString ("E", _nfi));\r
- AssertEquals ("#07", "9.999999E+007", 99999986.ToString ("E", _nfi));\r
- AssertEquals ("#08", "9.999999E+007", 99999987.ToString ("E", _nfi));\r
- AssertEquals ("#09", "9.999999E+007", 99999988.ToString ("E", _nfi));\r
- AssertEquals ("#10", "9.999999E+007", 99999989.ToString ("E", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01026 () {\r
- AssertEquals ("#01", "-9.999998E+007", (-99999980).ToString ("E", _nfi));\r
- AssertEquals ("#02", "-9.999998E+007", (-99999981).ToString ("E", _nfi));\r
- AssertEquals ("#03", "-9.999998E+007", (-99999982).ToString ("E", _nfi));\r
- AssertEquals ("#04", "-9.999998E+007", (-99999983).ToString ("E", _nfi));\r
- AssertEquals ("#05", "-9.999998E+007", (-99999984).ToString ("E", _nfi));\r
- AssertEquals ("#06", "-9.999999E+007", (-99999985).ToString ("E", _nfi));\r
- AssertEquals ("#07", "-9.999999E+007", (-99999986).ToString ("E", _nfi));\r
- AssertEquals ("#08", "-9.999999E+007", (-99999987).ToString ("E", _nfi));\r
- AssertEquals ("#09", "-9.999999E+007", (-99999988).ToString ("E", _nfi));\r
- AssertEquals ("#10", "-9.999999E+007", (-99999989).ToString ("E", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01027 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "-1#000000E+008", (-99999999).ToString ("E", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test01028 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
-\r
- AssertEquals ("#01", "1.000000E-000", 1.ToString ("E", nfi));\r
- AssertEquals ("#02", "0.000000E-000", 0.ToString ("E", nfi));\r
- AssertEquals ("#03", "+1.000000E-000", (-1).ToString ("E", nfi));\r
- }\r
-\r
- // Test02000- Int32 and F\r
- [Test]\r
- public void Test02000 () {\r
- AssertEquals ("#01", "0.00", 0.ToString ("F", _nfi));\r
- AssertEquals ("#02", "0.00", 0.ToString ("f", _nfi));\r
- AssertEquals ("#03", "-2147483648.00", Int32.MinValue.ToString ("F", _nfi));\r
- AssertEquals ("#04", "-2147483648.00", Int32.MinValue.ToString ("f", _nfi));\r
- AssertEquals ("#05", "2147483647.00", Int32.MaxValue.ToString ("F", _nfi));\r
- AssertEquals ("#06", "2147483647.00", Int32.MaxValue.ToString ("f", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02001 () {\r
- AssertEquals ("#01", "F ", 0.ToString ("F ", _nfi));\r
- AssertEquals ("#02", " F", 0.ToString (" F", _nfi));\r
- AssertEquals ("#03", " F ", 0.ToString (" F ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02002 () {\r
- AssertEquals ("#01", "-F ", (-1).ToString ("F ", _nfi));\r
- AssertEquals ("#02", "- F", (-1).ToString (" F", _nfi));\r
- AssertEquals ("#03", "- F ", (-1).ToString (" F ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02003 () {\r
- AssertEquals ("#01", "0", 0.ToString ("F0", _nfi));\r
- AssertEquals ("#02", "0.000000000", 0.ToString ("F9", _nfi));\r
- AssertEquals ("#03", "0.0000000000", 0.ToString ("F10", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F99", _nfi));\r
- AssertEquals ("#05", "F100", 0.ToString ("F100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02004 () {\r
- AssertEquals ("#01", "2147483647", Int32.MaxValue.ToString ("F0", _nfi));\r
- AssertEquals ("#02", "2147483647.000000000", Int32.MaxValue.ToString ("F9", _nfi));\r
- AssertEquals ("#03", "2147483647.0000000000", Int32.MaxValue.ToString ("F10", _nfi));\r
- AssertEquals ("#04", "2147483647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("F99", _nfi));\r
- AssertEquals ("#05", "F12147483647", Int32.MaxValue.ToString ("F100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02005 () {\r
- AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString ("F0", _nfi));\r
- AssertEquals ("#02", "-2147483648.000000000", Int32.MinValue.ToString ("F9", _nfi));\r
- AssertEquals ("#03", "-2147483648.0000000000", Int32.MinValue.ToString ("F10", _nfi));\r
- AssertEquals ("#04", "-2147483648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("F99", _nfi));\r
- AssertEquals ("#05", "-F12147483648", Int32.MinValue.ToString ("F100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02006 () {\r
- AssertEquals ("#01", "FF", 0.ToString ("FF", _nfi));\r
- AssertEquals ("#02", "F0F", 0.ToString ("F0F", _nfi));\r
- AssertEquals ("#03", "F0xF", 0.ToString ("F0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02007 () {\r
- AssertEquals ("#01", "FF", Int32.MaxValue.ToString ("FF", _nfi));\r
- AssertEquals ("#02", "F2147483647F", Int32.MaxValue.ToString ("F0F", _nfi));\r
- AssertEquals ("#03", "F2147483647xF", Int32.MaxValue.ToString ("F0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02008 () {\r
- AssertEquals ("#01", "-FF", Int32.MinValue.ToString ("FF", _nfi));\r
- AssertEquals ("#02", "-F2147483648F", Int32.MinValue.ToString ("F0F", _nfi));\r
- AssertEquals ("#03", "-F2147483648xF", Int32.MinValue.ToString ("F0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02009 () {\r
- AssertEquals ("#01", "0.0000000000", 0.ToString ("F0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#02", "2147483647.0000000000", Int32.MaxValue.ToString ("F0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#03", "-2147483648.0000000000", Int32.MinValue.ToString ("F0000000000000000000000000000000000000010", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02010 () {\r
- AssertEquals ("#01", "+F", 0.ToString ("+F", _nfi));\r
- AssertEquals ("#02", "F+", 0.ToString ("F+", _nfi));\r
- AssertEquals ("#03", "+F+", 0.ToString ("+F+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test02011 () {\r
- AssertEquals ("#01", "+F", Int32.MaxValue.ToString ("+F", _nfi));\r
- AssertEquals ("#02", "F+", Int32.MaxValue.ToString ("F+", _nfi));\r
- AssertEquals ("#03", "+F+", Int32.MaxValue.ToString ("+F+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02012 () {\r
- AssertEquals ("#01", "-+F", Int32.MinValue.ToString ("+F", _nfi));\r
- AssertEquals ("#02", "-F+", Int32.MinValue.ToString ("F+", _nfi));\r
- AssertEquals ("#03", "-+F+", Int32.MinValue.ToString ("+F+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02013 () {\r
- AssertEquals ("#01", "-F", 0.ToString ("-F", _nfi));\r
- AssertEquals ("#02", "F-", 0.ToString ("F-", _nfi));\r
- AssertEquals ("#03", "-F-", 0.ToString ("-F-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test02014 () {\r
- AssertEquals ("#01", "-F", Int32.MaxValue.ToString ("-F", _nfi));\r
- AssertEquals ("#02", "F-", Int32.MaxValue.ToString ("F-", _nfi));\r
- AssertEquals ("#03", "-F-", Int32.MaxValue.ToString ("-F-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02015 () {\r
- AssertEquals ("#01", "--F", Int32.MinValue.ToString ("-F", _nfi));\r
- AssertEquals ("#02", "-F-", Int32.MinValue.ToString ("F-", _nfi));\r
- AssertEquals ("#03", "--F-", Int32.MinValue.ToString ("-F-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02016 () {\r
- AssertEquals ("#01", "F+0", 0.ToString ("F+0", _nfi));\r
- AssertEquals ("#02", "F+2147483647", Int32.MaxValue.ToString ("F+0", _nfi));\r
- AssertEquals ("#03", "-F+2147483648", Int32.MinValue.ToString ("F+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02017 () {\r
- AssertEquals ("#01", "F+9", 0.ToString ("F+9", _nfi));\r
- AssertEquals ("#02", "F+9", Int32.MaxValue.ToString ("F+9", _nfi));\r
- AssertEquals ("#03", "-F+9", Int32.MinValue.ToString ("F+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02018 () {\r
- AssertEquals ("#01", "F-9", 0.ToString ("F-9", _nfi));\r
- AssertEquals ("#02", "F-9", Int32.MaxValue.ToString ("F-9", _nfi));\r
- AssertEquals ("#03", "-F-9", Int32.MinValue.ToString ("F-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02019 () {\r
- AssertEquals ("#01", "F0", 0.ToString ("F0,", _nfi));\r
- AssertEquals ("#02", "F2147484", Int32.MaxValue.ToString ("F0,", _nfi));\r
- AssertEquals ("#03", "-F2147484", Int32.MinValue.ToString ("F0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02020 () {\r
- AssertEquals ("#01", "F0", 0.ToString ("F0.", _nfi));\r
- AssertEquals ("#02", "F2147483647", Int32.MaxValue.ToString ("F0.", _nfi));\r
- AssertEquals ("#03", "-F2147483648", Int32.MinValue.ToString ("F0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02021 () {\r
- AssertEquals ("#01", "F0.0", 0.ToString ("F0.0", _nfi));\r
- AssertEquals ("#02", "F2147483647.0", Int32.MaxValue.ToString ("F0.0", _nfi));\r
- AssertEquals ("#03", "-F2147483648.0", Int32.MinValue.ToString ("F0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02022 () {\r
- AssertEquals ("#01", "F09", 0.ToString ("F0.9", _nfi));\r
- AssertEquals ("#02", "F21474836479", Int32.MaxValue.ToString ("F0.9", _nfi));\r
- AssertEquals ("#03", "-F21474836489", Int32.MinValue.ToString ("F0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02023 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalDigits = 0;\r
- AssertEquals ("#01", "0", 0.ToString ("F", nfi));\r
- nfi.NumberDecimalDigits = 1;\r
- AssertEquals ("#02", "0.0", 0.ToString ("F", nfi));\r
- nfi.NumberDecimalDigits = 99;\r
- AssertEquals ("#03", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02024 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "";\r
- AssertEquals ("#01", "2147483648.00", Int32.MinValue.ToString ("F", nfi));\r
- nfi.NegativeSign = "-";\r
- AssertEquals ("#02", "-2147483648.00", Int32.MinValue.ToString ("F", nfi));\r
- nfi.NegativeSign = "+";\r
- AssertEquals ("#03", "+2147483648.00", Int32.MinValue.ToString ("F", nfi));\r
- nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";\r
- AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648.00", Int32.MinValue.ToString ("F", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02025 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "-";\r
- nfi.PositiveSign = "+";\r
- AssertEquals ("#01", "-1.00", (-1).ToString ("F", nfi));\r
- AssertEquals ("#02", "0.00", 0.ToString ("F", nfi));\r
- AssertEquals ("#03", "1.00",1.ToString ("F", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02026 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
- AssertEquals ("#01", "+1.00", (-1).ToString ("F", nfi));\r
- AssertEquals ("#02", "0.00", 0.ToString ("F", nfi));\r
- AssertEquals ("#03", "1.00",1.ToString ("F", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test02027 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "1#00",1.ToString ("F", nfi));\r
- }\r
-\r
- // Test03000 - Int32 and G\r
- [Test]\r
- public void Test03000 () {\r
- AssertEquals ("#01", "0", 0.ToString ("G", _nfi));\r
- AssertEquals ("#02", "0", 0.ToString ("g", _nfi));\r
- AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("G", _nfi));\r
- AssertEquals ("#04", "-2147483648", Int32.MinValue.ToString ("g", _nfi));\r
- AssertEquals ("#05", "2147483647", Int32.MaxValue.ToString ("G", _nfi));\r
- AssertEquals ("#06", "2147483647", Int32.MaxValue.ToString ("g", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03001 () {\r
- AssertEquals ("#01", "G ", 0.ToString ("G ", _nfi));\r
- AssertEquals ("#02", " G", 0.ToString (" G", _nfi));\r
- AssertEquals ("#03", " G ", 0.ToString (" G ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03002 () {\r
- AssertEquals ("#01", "-G ", (-1).ToString ("G ", _nfi));\r
- AssertEquals ("#02", "- G", (-1).ToString (" G", _nfi));\r
- AssertEquals ("#03", "- G ", (-1).ToString (" G ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03003 () {\r
- AssertEquals ("#01", "0", 0.ToString ("G0", _nfi));\r
- AssertEquals ("#02", "0", 0.ToString ("G9", _nfi));\r
- AssertEquals ("#03", "0", 0.ToString ("G10", _nfi));\r
- AssertEquals ("#04", "0", 0.ToString ("G99", _nfi));\r
- AssertEquals ("#05", "G100", 0.ToString ("G100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03004 () {\r
- AssertEquals ("#01", "2147483647", Int32.MaxValue.ToString ("G0", _nfi));\r
- AssertEquals ("#02", "2.14748365E+09", Int32.MaxValue.ToString ("G9", _nfi));\r
- AssertEquals ("#03", "2147483647", Int32.MaxValue.ToString ("G10", _nfi));\r
- AssertEquals ("#04", "2147483647", Int32.MaxValue.ToString ("G99", _nfi));\r
- AssertEquals ("#05", "G12147483647", Int32.MaxValue.ToString ("G100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03005 () {\r
- AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString ("G0", _nfi));\r
- AssertEquals ("#02", "-2.14748365E+09", Int32.MinValue.ToString ("G9", _nfi));\r
- AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("G10", _nfi));\r
- AssertEquals ("#04", "-2147483648", Int32.MinValue.ToString ("G99", _nfi));\r
- AssertEquals ("#05", "-G12147483648", Int32.MinValue.ToString ("G100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03006 () {\r
- AssertEquals ("#01", "GF", 0.ToString ("GF", _nfi));\r
- AssertEquals ("#02", "G0F", 0.ToString ("G0F", _nfi));\r
- AssertEquals ("#03", "G0xF", 0.ToString ("G0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03007 () {\r
- AssertEquals ("#01", "GF", Int32.MaxValue.ToString ("GF", _nfi));\r
- AssertEquals ("#02", "G2147483647F", Int32.MaxValue.ToString ("G0F", _nfi));\r
- AssertEquals ("#03", "G2147483647xF", Int32.MaxValue.ToString ("G0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03008 () {\r
- AssertEquals ("#01", "-GF", Int32.MinValue.ToString ("GF", _nfi));\r
- AssertEquals ("#02", "-G2147483648F", Int32.MinValue.ToString ("G0F", _nfi));\r
- AssertEquals ("#03", "-G2147483648xF", Int32.MinValue.ToString ("G0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03009 () {\r
- AssertEquals ("#01", "0", 0.ToString ("G0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("G0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("G0000000000000000000000000000000000000010", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03010 () {\r
- AssertEquals ("#01", "+G", 0.ToString ("+G", _nfi));\r
- AssertEquals ("#02", "G+", 0.ToString ("G+", _nfi));\r
- AssertEquals ("#03", "+G+", 0.ToString ("+G+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test03011 () {\r
- AssertEquals ("#01", "+G", Int32.MaxValue.ToString ("+G", _nfi));\r
- AssertEquals ("#02", "G+", Int32.MaxValue.ToString ("G+", _nfi));\r
- AssertEquals ("#03", "+G+", Int32.MaxValue.ToString ("+G+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03012 () {\r
- AssertEquals ("#01", "-+G", Int32.MinValue.ToString ("+G", _nfi));\r
- AssertEquals ("#02", "-G+", Int32.MinValue.ToString ("G+", _nfi));\r
- AssertEquals ("#03", "-+G+", Int32.MinValue.ToString ("+G+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03013 () {\r
- AssertEquals ("#01", "-G", 0.ToString ("-G", _nfi));\r
- AssertEquals ("#02", "G-", 0.ToString ("G-", _nfi));\r
- AssertEquals ("#03", "-G-", 0.ToString ("-G-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test03014 () {\r
- AssertEquals ("#01", "-G", Int32.MaxValue.ToString ("-G", _nfi));\r
- AssertEquals ("#02", "G-", Int32.MaxValue.ToString ("G-", _nfi));\r
- AssertEquals ("#03", "-G-", Int32.MaxValue.ToString ("-G-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03015 () {\r
- AssertEquals ("#01", "--G", Int32.MinValue.ToString ("-G", _nfi));\r
- AssertEquals ("#02", "-G-", Int32.MinValue.ToString ("G-", _nfi));\r
- AssertEquals ("#03", "--G-", Int32.MinValue.ToString ("-G-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03016 () {\r
- AssertEquals ("#01", "G+0", 0.ToString ("G+0", _nfi));\r
- AssertEquals ("#02", "G+2147483647", Int32.MaxValue.ToString ("G+0", _nfi));\r
- AssertEquals ("#03", "-G+2147483648", Int32.MinValue.ToString ("G+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03017 () {\r
- AssertEquals ("#01", "G+9", 0.ToString ("G+9", _nfi));\r
- AssertEquals ("#02", "G+9", Int32.MaxValue.ToString ("G+9", _nfi));\r
- AssertEquals ("#03", "-G+9", Int32.MinValue.ToString ("G+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03018 () {\r
- AssertEquals ("#01", "G-9", 0.ToString ("G-9", _nfi));\r
- AssertEquals ("#02", "G-9", Int32.MaxValue.ToString ("G-9", _nfi));\r
- AssertEquals ("#03", "-G-9", Int32.MinValue.ToString ("G-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03019 () {\r
- AssertEquals ("#01", "G0", 0.ToString ("G0,", _nfi));\r
- AssertEquals ("#02", "G2147484", Int32.MaxValue.ToString ("G0,", _nfi));\r
- AssertEquals ("#03", "-G2147484", Int32.MinValue.ToString ("G0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03020 () {\r
- AssertEquals ("#01", "G0", 0.ToString ("G0.", _nfi));\r
- AssertEquals ("#02", "G2147483647", Int32.MaxValue.ToString ("G0.", _nfi));\r
- AssertEquals ("#03", "-G2147483648", Int32.MinValue.ToString ("G0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03021 () {\r
- AssertEquals ("#01", "G0.0", 0.ToString ("G0.0", _nfi));\r
- AssertEquals ("#02", "G2147483647.0", Int32.MaxValue.ToString ("G0.0", _nfi));\r
- AssertEquals ("#03", "-G2147483648.0", Int32.MinValue.ToString ("G0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03022 () {\r
- AssertEquals ("#01", "G09", 0.ToString ("G0.9", _nfi));\r
- AssertEquals ("#02", "G21474836479", Int32.MaxValue.ToString ("G0.9", _nfi));\r
- AssertEquals ("#03", "-G21474836489", Int32.MinValue.ToString ("G0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03023 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalDigits = 0;\r
- AssertEquals ("#01", "0", 0.ToString ("G", nfi));\r
- nfi.NumberDecimalDigits = 1;\r
- AssertEquals ("#02", "0", 0.ToString ("G", nfi));\r
- nfi.NumberDecimalDigits = 99;\r
- AssertEquals ("#03", "0", 0.ToString ("G", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03024 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "";\r
- AssertEquals ("#01", "2147483648", Int32.MinValue.ToString ("G", nfi));\r
- nfi.NegativeSign = "-";\r
- AssertEquals ("#02", "-2147483648", Int32.MinValue.ToString ("G", nfi));\r
- nfi.NegativeSign = "+";\r
- AssertEquals ("#03", "+2147483648", Int32.MinValue.ToString ("G", nfi));\r
- nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";\r
- AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648", Int32.MinValue.ToString ("G", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03025 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "-";\r
- nfi.PositiveSign = "+";\r
- AssertEquals ("#01", "-1", (-1).ToString ("G", nfi));\r
- AssertEquals ("#02", "0", 0.ToString ("G", nfi));\r
- AssertEquals ("#03", "1",1.ToString ("G", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03026 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
- AssertEquals ("#01", "+1", (-1).ToString ("G", nfi));\r
- AssertEquals ("#02", "0", 0.ToString ("G", nfi));\r
- AssertEquals ("#03", "1",1.ToString ("G", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test03027 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "1#2E+02",123.ToString ("G2", nfi));\r
- }\r
-\r
- // Test04000 - Int32 and N\r
- [Test]\r
- public void Test04000 () {\r
- AssertEquals ("#01", "0.00", 0.ToString ("N", _nfi));\r
- AssertEquals ("#02", "0.00", 0.ToString ("n", _nfi));\r
- AssertEquals ("#03", "-2,147,483,648.00", Int32.MinValue.ToString ("N", _nfi));\r
- AssertEquals ("#04", "-2,147,483,648.00", Int32.MinValue.ToString ("n", _nfi));\r
- AssertEquals ("#05", "2,147,483,647.00", Int32.MaxValue.ToString ("N", _nfi));\r
- AssertEquals ("#06", "2,147,483,647.00", Int32.MaxValue.ToString ("n", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04001 () {\r
- AssertEquals ("#01", "N ", 0.ToString ("N ", _nfi));\r
- AssertEquals ("#02", " N", 0.ToString (" N", _nfi));\r
- AssertEquals ("#03", " N ", 0.ToString (" N ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04002 () {\r
- AssertEquals ("#01", "-N ", (-1).ToString ("N ", _nfi));\r
- AssertEquals ("#02", "- N", (-1).ToString (" N", _nfi));\r
- AssertEquals ("#03", "- N ", (-1).ToString (" N ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04003 () {\r
- AssertEquals ("#01", "0", 0.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "0.000000000", 0.ToString ("N9", _nfi));\r
- AssertEquals ("#03", "0.0000000000", 0.ToString ("N10", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N99", _nfi));\r
- AssertEquals ("#05", "N100", 0.ToString ("N100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04004 () {\r
- AssertEquals ("#01", "2,147,483,647", Int32.MaxValue.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "2,147,483,647.000000000", Int32.MaxValue.ToString ("N9", _nfi));\r
- AssertEquals ("#03", "2,147,483,647.0000000000", Int32.MaxValue.ToString ("N10", _nfi));\r
- AssertEquals ("#04", "2,147,483,647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("N99", _nfi));\r
- AssertEquals ("#05", "N12147483647", Int32.MaxValue.ToString ("N100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04005 () {\r
- AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "-2,147,483,648.000000000", Int32.MinValue.ToString ("N9", _nfi));\r
- AssertEquals ("#03", "-2,147,483,648.0000000000", Int32.MinValue.ToString ("N10", _nfi));\r
- AssertEquals ("#04", "-2,147,483,648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("N99", _nfi));\r
- AssertEquals ("#05", "-N12147483648", Int32.MinValue.ToString ("N100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04006 () {\r
- AssertEquals ("#01", "NF", 0.ToString ("NF", _nfi));\r
- AssertEquals ("#02", "N0F", 0.ToString ("N0F", _nfi));\r
- AssertEquals ("#03", "N0xF", 0.ToString ("N0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04007 () {\r
- AssertEquals ("#01", "NF", Int32.MaxValue.ToString ("NF", _nfi));\r
- AssertEquals ("#02", "N2147483647F", Int32.MaxValue.ToString ("N0F", _nfi));\r
- AssertEquals ("#03", "N2147483647xF", Int32.MaxValue.ToString ("N0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04008 () {\r
- AssertEquals ("#01", "-NF", Int32.MinValue.ToString ("NF", _nfi));\r
- AssertEquals ("#02", "-N2147483648F", Int32.MinValue.ToString ("N0F", _nfi));\r
- AssertEquals ("#03", "-N2147483648xF", Int32.MinValue.ToString ("N0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04009 () {\r
- AssertEquals ("#01", "0.0000000000", 0.ToString ("N0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#02", "2,147,483,647.0000000000", Int32.MaxValue.ToString ("N0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#03", "-2,147,483,648.0000000000", Int32.MinValue.ToString ("N0000000000000000000000000000000000000010", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04010 () {\r
- AssertEquals ("#01", "+N", 0.ToString ("+N", _nfi));\r
- AssertEquals ("#02", "N+", 0.ToString ("N+", _nfi));\r
- AssertEquals ("#03", "+N+", 0.ToString ("+N+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test04011 () {\r
- AssertEquals ("#01", "+N", Int32.MaxValue.ToString ("+N", _nfi));\r
- AssertEquals ("#02", "N+", Int32.MaxValue.ToString ("N+", _nfi));\r
- AssertEquals ("#03", "+N+", Int32.MaxValue.ToString ("+N+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04012 () {\r
- AssertEquals ("#01", "-+N", Int32.MinValue.ToString ("+N", _nfi));\r
- AssertEquals ("#02", "-N+", Int32.MinValue.ToString ("N+", _nfi));\r
- AssertEquals ("#03", "-+N+", Int32.MinValue.ToString ("+N+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04013 () {\r
- AssertEquals ("#01", "-N", 0.ToString ("-N", _nfi));\r
- AssertEquals ("#02", "N-", 0.ToString ("N-", _nfi));\r
- AssertEquals ("#03", "-N-", 0.ToString ("-N-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test04014 () {\r
- AssertEquals ("#01", "-N", Int32.MaxValue.ToString ("-N", _nfi));\r
- AssertEquals ("#02", "N-", Int32.MaxValue.ToString ("N-", _nfi));\r
- AssertEquals ("#03", "-N-", Int32.MaxValue.ToString ("-N-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04015 () {\r
- AssertEquals ("#01", "--N", Int32.MinValue.ToString ("-N", _nfi));\r
- AssertEquals ("#02", "-N-", Int32.MinValue.ToString ("N-", _nfi));\r
- AssertEquals ("#03", "--N-", Int32.MinValue.ToString ("-N-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04016 () {\r
- AssertEquals ("#01", "N+0", 0.ToString ("N+0", _nfi));\r
- AssertEquals ("#02", "N+2147483647", Int32.MaxValue.ToString ("N+0", _nfi));\r
- AssertEquals ("#03", "-N+2147483648", Int32.MinValue.ToString ("N+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04017 () {\r
- AssertEquals ("#01", "N+9", 0.ToString ("N+9", _nfi));\r
- AssertEquals ("#02", "N+9", Int32.MaxValue.ToString ("N+9", _nfi));\r
- AssertEquals ("#03", "-N+9", Int32.MinValue.ToString ("N+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04018 () {\r
- AssertEquals ("#01", "N-9", 0.ToString ("N-9", _nfi));\r
- AssertEquals ("#02", "N-9", Int32.MaxValue.ToString ("N-9", _nfi));\r
- AssertEquals ("#03", "-N-9", Int32.MinValue.ToString ("N-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04019 () {\r
- AssertEquals ("#01", "N0", 0.ToString ("N0,", _nfi));\r
- AssertEquals ("#02", "N2147484", Int32.MaxValue.ToString ("N0,", _nfi));\r
- AssertEquals ("#03", "-N2147484", Int32.MinValue.ToString ("N0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04020 () {\r
- AssertEquals ("#01", "N0", 0.ToString ("N0.", _nfi));\r
- AssertEquals ("#02", "N2147483647", Int32.MaxValue.ToString ("N0.", _nfi));\r
- AssertEquals ("#03", "-N2147483648", Int32.MinValue.ToString ("N0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04021 () {\r
- AssertEquals ("#01", "N0.0", 0.ToString ("N0.0", _nfi));\r
- AssertEquals ("#02", "N2147483647.0", Int32.MaxValue.ToString ("N0.0", _nfi));\r
- AssertEquals ("#03", "-N2147483648.0", Int32.MinValue.ToString ("N0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04022 () {\r
- AssertEquals ("#01", "N09", 0.ToString ("N0.9", _nfi));\r
- AssertEquals ("#02", "N21474836479", Int32.MaxValue.ToString ("N0.9", _nfi));\r
- AssertEquals ("#03", "-N21474836489", Int32.MinValue.ToString ("N0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04023 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalDigits = 0;\r
- AssertEquals ("#01", "0", 0.ToString ("N", nfi));\r
- nfi.NumberDecimalDigits = 1;\r
- AssertEquals ("#02", "0.0", 0.ToString ("N", nfi));\r
- nfi.NumberDecimalDigits = 99;\r
- AssertEquals ("#03", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04024 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "";\r
- AssertEquals ("#01", "2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));\r
- nfi.NegativeSign = "-";\r
- AssertEquals ("#02", "-2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));\r
- nfi.NegativeSign = "+";\r
- AssertEquals ("#03", "+2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));\r
- nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";\r
- AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04025 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "-";\r
- nfi.PositiveSign = "+";\r
- AssertEquals ("#01", "-1.00", (-1).ToString ("N", nfi));\r
- AssertEquals ("#02", "0.00", 0.ToString ("N", nfi));\r
- AssertEquals ("#03", "1.00",1.ToString ("N", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04026 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
- AssertEquals ("#01", "+1.00", (-1).ToString ("N", nfi));\r
- AssertEquals ("#02", "0.00", 0.ToString ("N", nfi));\r
- AssertEquals ("#03", "1.00",1.ToString ("N", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04027 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "123#0",123.ToString ("N1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04028 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberGroupSeparator = "-";\r
- AssertEquals ("#01", "-2-147-483-648.0",Int32.MinValue.ToString ("N1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04029 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberGroupSizes = new int [] {};\r
- AssertEquals ("#01", "-2147483648.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {0};\r
- AssertEquals ("#02", "-2147483648.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1};\r
- AssertEquals ("#03", "-2,1,4,7,4,8,3,6,4,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {3};\r
- AssertEquals ("#04", "-2,147,483,648.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {9};\r
- AssertEquals ("#05", "-2,147483648.0",Int32.MinValue.ToString ("N1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04030 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberGroupSizes = new int [] {1,2};\r
- AssertEquals ("#01", "-2,14,74,83,64,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1,2,3};\r
- AssertEquals ("#02", "-2,147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1,2,3,4};\r
- AssertEquals ("#03", "-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1,2,1,2,1,2,1};\r
- AssertEquals ("#04", "-2,14,7,48,3,64,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1,0};\r
- AssertEquals ("#05", "-214748364,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1,2,0};\r
- AssertEquals ("#06", "-2147483,64,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1,2,3,0};\r
- AssertEquals ("#07", "-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- nfi.NumberGroupSizes = new int [] {1,2,3,4,0};\r
- AssertEquals ("#08", "-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test04031 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "1234567890";\r
- AssertEquals ("#01", "12345678902,147,483,648.00", Int32.MinValue.ToString ("N", nfi));\r
- }\r
-\r
- // Test05000 - Int32 and P\r
- [Test]\r
- public void Test05000 () {\r
- AssertEquals ("#01", "0.00 %", 0.ToString ("P", _nfi));\r
- AssertEquals ("#02", "0.00 %", 0.ToString ("p", _nfi));\r
- AssertEquals ("#03", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", _nfi));\r
- AssertEquals ("#04", "-214,748,364,800.00 %", Int32.MinValue.ToString ("p", _nfi));\r
- AssertEquals ("#05", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", _nfi));\r
- AssertEquals ("#06", "214,748,364,700.00 %", Int32.MaxValue.ToString ("p", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05001 () {\r
- AssertEquals ("#01", "P ", 0.ToString ("P ", _nfi));\r
- AssertEquals ("#02", " P", 0.ToString (" P", _nfi));\r
- AssertEquals ("#03", " P ", 0.ToString (" P ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05002 () {\r
- AssertEquals ("#01", "-P ", (-1).ToString ("P ", _nfi));\r
- AssertEquals ("#02", "- P", (-1).ToString (" P", _nfi));\r
- AssertEquals ("#03", "- P ", (-1).ToString (" P ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05003 () {\r
- AssertEquals ("#01", "0 %", 0.ToString ("P0", _nfi));\r
- AssertEquals ("#02", "0.000000000 %", 0.ToString ("P9", _nfi));\r
- AssertEquals ("#03", "0.0000000000 %", 0.ToString ("P10", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P99", _nfi));\r
- AssertEquals ("#05", "P100", 0.ToString ("P100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05004 () {\r
- AssertEquals ("#01", "214,748,364,700 %", Int32.MaxValue.ToString ("P0", _nfi));\r
- AssertEquals ("#02", "214,748,364,700.000000000 %", Int32.MaxValue.ToString ("P9", _nfi));\r
- AssertEquals ("#03", "214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P10", _nfi));\r
- AssertEquals ("#04", "214,748,364,700.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MaxValue.ToString ("P99", _nfi));\r
- AssertEquals ("#05", "P12147483647", Int32.MaxValue.ToString ("P100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05005 () {\r
- AssertEquals ("#01", "-214,748,364,800 %", Int32.MinValue.ToString ("P0", _nfi));\r
- AssertEquals ("#02", "-214,748,364,800.000000000 %", Int32.MinValue.ToString ("P9", _nfi));\r
- AssertEquals ("#03", "-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P10", _nfi));\r
- AssertEquals ("#04", "-214,748,364,800.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MinValue.ToString ("P99", _nfi));\r
- AssertEquals ("#05", "-P12147483648", Int32.MinValue.ToString ("P100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05006 () {\r
- AssertEquals ("#01", "PF", 0.ToString ("PF", _nfi));\r
- AssertEquals ("#02", "P0F", 0.ToString ("P0F", _nfi));\r
- AssertEquals ("#03", "P0xF", 0.ToString ("P0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05007 () {\r
- AssertEquals ("#01", "PF", Int32.MaxValue.ToString ("PF", _nfi));\r
- AssertEquals ("#02", "P2147483647F", Int32.MaxValue.ToString ("P0F", _nfi));\r
- AssertEquals ("#03", "P2147483647xF", Int32.MaxValue.ToString ("P0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05008 () {\r
- AssertEquals ("#01", "-PF", Int32.MinValue.ToString ("PF", _nfi));\r
- AssertEquals ("#02", "-P2147483648F", Int32.MinValue.ToString ("P0F", _nfi));\r
- AssertEquals ("#03", "-P2147483648xF", Int32.MinValue.ToString ("P0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05009 () {\r
- AssertEquals ("#01", "0.0000000000 %", 0.ToString ("P0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#02", "214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P0000000000000000000000000000000000000010", _nfi));\r
- AssertEquals ("#03", "-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P0000000000000000000000000000000000000010", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05010 () {\r
- AssertEquals ("#01", "+P", 0.ToString ("+P", _nfi));\r
- AssertEquals ("#02", "P+", 0.ToString ("P+", _nfi));\r
- AssertEquals ("#03", "+P+", 0.ToString ("+P+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test05011 () {\r
- AssertEquals ("#01", "+P", Int32.MaxValue.ToString ("+P", _nfi));\r
- AssertEquals ("#02", "P+", Int32.MaxValue.ToString ("P+", _nfi));\r
- AssertEquals ("#03", "+P+", Int32.MaxValue.ToString ("+P+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05012 () {\r
- AssertEquals ("#01", "-+P", Int32.MinValue.ToString ("+P", _nfi));\r
- AssertEquals ("#02", "-P+", Int32.MinValue.ToString ("P+", _nfi));\r
- AssertEquals ("#03", "-+P+", Int32.MinValue.ToString ("+P+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05013 () {\r
- AssertEquals ("#01", "-P", 0.ToString ("-P", _nfi));\r
- AssertEquals ("#02", "P-", 0.ToString ("P-", _nfi));\r
- AssertEquals ("#03", "-P-", 0.ToString ("-P-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test05014 () {\r
- AssertEquals ("#01", "-P", Int32.MaxValue.ToString ("-P", _nfi));\r
- AssertEquals ("#02", "P-", Int32.MaxValue.ToString ("P-", _nfi));\r
- AssertEquals ("#03", "-P-", Int32.MaxValue.ToString ("-P-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05015 () {\r
- AssertEquals ("#01", "--P", Int32.MinValue.ToString ("-P", _nfi));\r
- AssertEquals ("#02", "-P-", Int32.MinValue.ToString ("P-", _nfi));\r
- AssertEquals ("#03", "--P-", Int32.MinValue.ToString ("-P-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05016 () {\r
- AssertEquals ("#01", "P+0", 0.ToString ("P+0", _nfi));\r
- AssertEquals ("#02", "P+2147483647", Int32.MaxValue.ToString ("P+0", _nfi));\r
- AssertEquals ("#03", "-P+2147483648", Int32.MinValue.ToString ("P+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05017 () {\r
- AssertEquals ("#01", "P+9", 0.ToString ("P+9", _nfi));\r
- AssertEquals ("#02", "P+9", Int32.MaxValue.ToString ("P+9", _nfi));\r
- AssertEquals ("#03", "-P+9", Int32.MinValue.ToString ("P+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05018 () {\r
- AssertEquals ("#01", "P-9", 0.ToString ("P-9", _nfi));\r
- AssertEquals ("#02", "P-9", Int32.MaxValue.ToString ("P-9", _nfi));\r
- AssertEquals ("#03", "-P-9", Int32.MinValue.ToString ("P-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05019 () {\r
- AssertEquals ("#01", "P0", 0.ToString ("P0,", _nfi));\r
- AssertEquals ("#02", "P2147484", Int32.MaxValue.ToString ("P0,", _nfi));\r
- AssertEquals ("#03", "-P2147484", Int32.MinValue.ToString ("P0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05020 () {\r
- AssertEquals ("#01", "P0", 0.ToString ("P0.", _nfi));\r
- AssertEquals ("#02", "P2147483647", Int32.MaxValue.ToString ("P0.", _nfi));\r
- AssertEquals ("#03", "-P2147483648", Int32.MinValue.ToString ("P0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05021 () {\r
- AssertEquals ("#01", "P0.0", 0.ToString ("P0.0", _nfi));\r
- AssertEquals ("#02", "P2147483647.0", Int32.MaxValue.ToString ("P0.0", _nfi));\r
- AssertEquals ("#03", "-P2147483648.0", Int32.MinValue.ToString ("P0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05022 () {\r
- AssertEquals ("#01", "P09", 0.ToString ("P0.9", _nfi));\r
- AssertEquals ("#02", "P21474836479", Int32.MaxValue.ToString ("P0.9", _nfi));\r
- AssertEquals ("#03", "-P21474836489", Int32.MinValue.ToString ("P0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05023 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentDecimalDigits = 0;\r
- AssertEquals ("#01", "0 %", 0.ToString ("P", nfi));\r
- nfi.PercentDecimalDigits = 1;\r
- AssertEquals ("#02", "0.0 %", 0.ToString ("P", nfi));\r
- nfi.PercentDecimalDigits = 99;\r
- AssertEquals ("#03", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05024 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "";\r
- AssertEquals ("#01", "214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- nfi.NegativeSign = "-";\r
- AssertEquals ("#02", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- nfi.NegativeSign = "+";\r
- AssertEquals ("#03", "+214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ";\r
- AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05025 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "-";\r
- nfi.PositiveSign = "+";\r
- AssertEquals ("#01", "-100.00 %", (-1).ToString ("P", nfi));\r
- AssertEquals ("#02", "0.00 %", 0.ToString ("P", nfi));\r
- AssertEquals ("#03", "100.00 %",1.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05026 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
- AssertEquals ("#01", "+100.00 %", (-1).ToString ("P", nfi));\r
- AssertEquals ("#02", "0.00 %", 0.ToString ("P", nfi));\r
- AssertEquals ("#03", "100.00 %",1.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05027 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentDecimalSeparator = "#";\r
- AssertEquals ("#01", "12,300#0 %",123.ToString ("P1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05028 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentGroupSeparator = "-";\r
- AssertEquals ("#01", "-214-748-364-800.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05029 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentGroupSizes = new int [] {};\r
- AssertEquals ("#01", "-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {0};\r
- AssertEquals ("#02", "-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1};\r
- AssertEquals ("#03", "-2,1,4,7,4,8,3,6,4,8,0,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {3};\r
- AssertEquals ("#04", "-214,748,364,800.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {9};\r
- AssertEquals ("#05", "-214,748364800.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05030 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentGroupSizes = new int [] {1,2};\r
- AssertEquals ("#01", "-2,14,74,83,64,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1,2,3};\r
- AssertEquals ("#02", "-214,748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1,2,3,4};\r
- AssertEquals ("#03", "-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1,2,1,2,1,2,1};\r
- AssertEquals ("#04", "-2,1,4,74,8,36,4,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1,0};\r
- AssertEquals ("#05", "-21474836480,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1,2,0};\r
- AssertEquals ("#06", "-214748364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1,2,3,0};\r
- AssertEquals ("#07", "-214748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- nfi.PercentGroupSizes = new int [] {1,2,3,4,0};\r
- AssertEquals ("#08", "-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05031 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "1234567890";\r
- AssertEquals ("#01", "1234567890214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05032 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentNegativePattern = 0;\r
- AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));\r
- AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05033 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentNegativePattern = 1;\r
- AssertEquals ("#01", "-214,748,364,800.00%", Int32.MinValue.ToString ("P", nfi));\r
- AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));\r
- AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05034 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentNegativePattern = 2;\r
- AssertEquals ("#01", "-%214,748,364,800.00", Int32.MinValue.ToString ("P", nfi));\r
- AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));\r
- AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05035 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentPositivePattern = 0;\r
- AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));\r
- AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05036 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentPositivePattern = 1;\r
- AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- AssertEquals ("#02", "214,748,364,700.00%", Int32.MaxValue.ToString ("P", nfi));\r
- AssertEquals ("#03", "0.00%", 0.ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test05037 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentPositivePattern = 2;\r
- AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));\r
- AssertEquals ("#02", "%214,748,364,700.00", Int32.MaxValue.ToString ("P", nfi));\r
- AssertEquals ("#03", "%0.00", 0.ToString ("P", nfi));\r
- }\r
-\r
- // Test06000 - Int32 and R\r
- [Test]\r
- [ExpectedException (typeof (FormatException))]\r
- public void Test06000 () {\r
- AssertEquals ("#01", "0", 0.ToString ("R", _nfi));\r
- }\r
-\r
- // Test07000- Int32 and X\r
- [Test]\r
- public void Test07000 () {\r
- AssertEquals ("#01", "0", 0.ToString ("X", _nfi));\r
- AssertEquals ("#02", "0", 0.ToString ("x", _nfi));\r
- AssertEquals ("#03", "80000000", Int32.MinValue.ToString ("X", _nfi));\r
- AssertEquals ("#04", "80000000", Int32.MinValue.ToString ("x", _nfi));\r
- AssertEquals ("#05", "7FFFFFFF", Int32.MaxValue.ToString ("X", _nfi));\r
- AssertEquals ("#06", "7fffffff", Int32.MaxValue.ToString ("x", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07001 () {\r
- AssertEquals ("#01", "X ", 0.ToString ("X ", _nfi));\r
- AssertEquals ("#02", " X", 0.ToString (" X", _nfi));\r
- AssertEquals ("#03", " X ", 0.ToString (" X ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07002 () {\r
- AssertEquals ("#01", "-X ", (-1).ToString ("X ", _nfi));\r
- AssertEquals ("#02", "- X", (-1).ToString (" X", _nfi));\r
- AssertEquals ("#03", "- X ", (-1).ToString (" X ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07003 () {\r
- AssertEquals ("#01", "0", 0.ToString ("X0", _nfi));\r
- AssertEquals ("#02", "0000000000", 0.ToString ("X10", _nfi));\r
- AssertEquals ("#03", "00000000000", 0.ToString ("X11", _nfi));\r
- AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("X99", _nfi));\r
- AssertEquals ("#05", "X100", 0.ToString ("X100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07004 () {\r
- AssertEquals ("#01", "7FFFFFFF", Int32.MaxValue.ToString ("X0", _nfi));\r
- AssertEquals ("#02", "007FFFFFFF", Int32.MaxValue.ToString ("X10", _nfi));\r
- AssertEquals ("#03", "0007FFFFFFF", Int32.MaxValue.ToString ("X11", _nfi));\r
- AssertEquals ("#04", "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FFFFFFF", Int32.MaxValue.ToString ("X99", _nfi));\r
- AssertEquals ("#05", "X12147483647", Int32.MaxValue.ToString ("X100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07005 () {\r
- AssertEquals ("#01", "80000000", Int32.MinValue.ToString ("X0", _nfi));\r
- AssertEquals ("#02", "0080000000", Int32.MinValue.ToString ("X10", _nfi));\r
- AssertEquals ("#03", "00080000000", Int32.MinValue.ToString ("X11", _nfi));\r
- AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000", Int32.MinValue.ToString ("X99", _nfi));\r
- AssertEquals ("#05", "-X12147483648", Int32.MinValue.ToString ("X100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07006 () {\r
- AssertEquals ("#01", "XF", 0.ToString ("XF", _nfi));\r
- AssertEquals ("#02", "X0F", 0.ToString ("X0F", _nfi));\r
- AssertEquals ("#03", "X0xF", 0.ToString ("X0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07007 () {\r
- AssertEquals ("#01", "XF", Int32.MaxValue.ToString ("XF", _nfi));\r
- AssertEquals ("#02", "X2147483647F", Int32.MaxValue.ToString ("X0F", _nfi));\r
- AssertEquals ("#03", "X2147483647xF", Int32.MaxValue.ToString ("X0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07008 () {\r
- AssertEquals ("#01", "-XF", Int32.MinValue.ToString ("XF", _nfi));\r
- AssertEquals ("#02", "-X2147483648F", Int32.MinValue.ToString ("X0F", _nfi));\r
- AssertEquals ("#03", "-X2147483648xF", Int32.MinValue.ToString ("X0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07009 () {\r
- AssertEquals ("#01", "00000000000", 0.ToString ("X0000000000000000000000000000000000000011", _nfi));\r
- AssertEquals ("#02", "0007FFFFFFF", Int32.MaxValue.ToString ("X0000000000000000000000000000000000000011", _nfi));\r
- AssertEquals ("#03", "00080000000", Int32.MinValue.ToString ("X0000000000000000000000000000000000000011", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07010 () {\r
- AssertEquals ("#01", "+X", 0.ToString ("+X", _nfi));\r
- AssertEquals ("#02", "X+", 0.ToString ("X+", _nfi));\r
- AssertEquals ("#03", "+X+", 0.ToString ("+X+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test07011 () {\r
- AssertEquals ("#01", "+X", Int32.MaxValue.ToString ("+X", _nfi));\r
- AssertEquals ("#02", "X+", Int32.MaxValue.ToString ("X+", _nfi));\r
- AssertEquals ("#03", "+X+", Int32.MaxValue.ToString ("+X+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07012 () {\r
- AssertEquals ("#01", "-+X", Int32.MinValue.ToString ("+X", _nfi));\r
- AssertEquals ("#02", "-X+", Int32.MinValue.ToString ("X+", _nfi));\r
- AssertEquals ("#03", "-+X+", Int32.MinValue.ToString ("+X+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07013 () {\r
- AssertEquals ("#01", "-X", 0.ToString ("-X", _nfi));\r
- AssertEquals ("#02", "X-", 0.ToString ("X-", _nfi));\r
- AssertEquals ("#03", "-X-", 0.ToString ("-X-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test07014 () {\r
- AssertEquals ("#01", "-X", Int32.MaxValue.ToString ("-X", _nfi));\r
- AssertEquals ("#02", "X-", Int32.MaxValue.ToString ("X-", _nfi));\r
- AssertEquals ("#03", "-X-", Int32.MaxValue.ToString ("-X-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07015 () {\r
- AssertEquals ("#01", "--X", Int32.MinValue.ToString ("-X", _nfi));\r
- AssertEquals ("#02", "-X-", Int32.MinValue.ToString ("X-", _nfi));\r
- AssertEquals ("#03", "--X-", Int32.MinValue.ToString ("-X-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07016 () {\r
- AssertEquals ("#01", "X+0", 0.ToString ("X+0", _nfi));\r
- AssertEquals ("#02", "X+2147483647", Int32.MaxValue.ToString ("X+0", _nfi));\r
- AssertEquals ("#03", "-X+2147483648", Int32.MinValue.ToString ("X+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07017 () {\r
- AssertEquals ("#01", "X+9", 0.ToString ("X+9", _nfi));\r
- AssertEquals ("#02", "X+9", Int32.MaxValue.ToString ("X+9", _nfi));\r
- AssertEquals ("#03", "-X+9", Int32.MinValue.ToString ("X+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07018 () {\r
- AssertEquals ("#01", "X-9", 0.ToString ("X-9", _nfi));\r
- AssertEquals ("#02", "X-9", Int32.MaxValue.ToString ("X-9", _nfi));\r
- AssertEquals ("#03", "-X-9", Int32.MinValue.ToString ("X-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07019 () {\r
- AssertEquals ("#01", "X0", 0.ToString ("X0,", _nfi));\r
- AssertEquals ("#02", "X2147484", Int32.MaxValue.ToString ("X0,", _nfi));\r
- AssertEquals ("#03", "-X2147484", Int32.MinValue.ToString ("X0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07020 () {\r
- AssertEquals ("#01", "X0", 0.ToString ("X0.", _nfi));\r
- AssertEquals ("#02", "X2147483647", Int32.MaxValue.ToString ("X0.", _nfi));\r
- AssertEquals ("#03", "-X2147483648", Int32.MinValue.ToString ("X0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07021 () {\r
- AssertEquals ("#01", "X0.0", 0.ToString ("X0.0", _nfi));\r
- AssertEquals ("#02", "X2147483647.0", Int32.MaxValue.ToString ("X0.0", _nfi));\r
- AssertEquals ("#03", "-X2147483648.0", Int32.MinValue.ToString ("X0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test07022 () {\r
- AssertEquals ("#01", "X09", 0.ToString ("X0.9", _nfi));\r
- AssertEquals ("#02", "X21474836479", Int32.MaxValue.ToString ("X0.9", _nfi));\r
- AssertEquals ("#03", "-X21474836489", Int32.MinValue.ToString ("X0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08000 () {\r
- AssertEquals ("#01", "0", 0.ToString ("0", _nfi));\r
- AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("0", _nfi));\r
- AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("0", _nfi));\r
- }\r
-\r
- // Test08000 - Int32 and Custom\r
- [Test]\r
- public void Test08001 () {\r
- AssertEquals ("#01", "00000000000", 0.ToString ("00000000000", _nfi));\r
- AssertEquals ("#02", "02147483647", Int32.MaxValue.ToString ("00000000000", _nfi));\r
- AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("00000000000", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08002 () {\r
- AssertEquals ("#01", " 00000000000 ", 0.ToString (" 00000000000 ", _nfi));\r
- AssertEquals ("#02", " 02147483647 ", Int32.MaxValue.ToString (" 00000000000 ", _nfi));\r
- AssertEquals ("#03", "- 02147483648 ", Int32.MinValue.ToString (" 00000000000 ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08003 () {\r
- AssertEquals ("#01", "", 0.ToString ("#", _nfi));\r
- AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("#", _nfi));\r
- AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("#", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08004 () {\r
- AssertEquals ("#01", "", 0.ToString ("##########", _nfi));\r
- AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("##########", _nfi));\r
- AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("##########", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08005 () {\r
- AssertEquals ("#01", " ", 0.ToString (" ########## ", _nfi));\r
- AssertEquals ("#02", " 2147483647 ", Int32.MaxValue.ToString (" ########## ", _nfi));\r
- AssertEquals ("#03", "- 2147483648 ", Int32.MinValue.ToString (" ########## ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08006 () {\r
- AssertEquals ("#01", "", 0.ToString (".", _nfi));\r
- AssertEquals ("#02", "", Int32.MaxValue.ToString (".", _nfi));\r
- AssertEquals ("#03", "-", Int32.MinValue.ToString (".", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08007 () {\r
- AssertEquals ("#01", "00000000000", 0.ToString ("00000000000.", _nfi));\r
- AssertEquals ("#02", "02147483647", Int32.MaxValue.ToString ("00000000000.", _nfi));\r
- AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("00000000000.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08008 () {\r
- AssertEquals ("#01", ".00000000000", 0.ToString (".00000000000", _nfi));\r
- AssertEquals ("#02", "2147483647.00000000000", Int32.MaxValue.ToString (".00000000000", _nfi));\r
- AssertEquals ("#03", "-2147483648.00000000000", Int32.MinValue.ToString (".00000000000", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08009 () {\r
- AssertEquals ("#01", "00000000000.00000000000", 0.ToString ("00000000000.00000000000", _nfi));\r
- AssertEquals ("#02", "02147483647.00000000000", Int32.MaxValue.ToString ("00000000000.00000000000", _nfi));\r
- AssertEquals ("#03", "-02147483648.00000000000", Int32.MinValue.ToString ("00000000000.00000000000", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08010 () {\r
- AssertEquals ("#01", "00.0000000000", 0.ToString ("00.0.00.000.0000", _nfi));\r
- AssertEquals ("#02", "01.0000000000", 1.ToString ("00.0.00.000.0000", _nfi));\r
- AssertEquals ("#03", "-01.0000000000", (-1).ToString ("00.0.00.000.0000", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test08011 () {\r
- AssertEquals ("#01", "", 0.ToString ("##.#.##.###.####", _nfi));\r
- AssertEquals ("#02", "1", 1.ToString ("##.#.##.###.####", _nfi));\r
- AssertEquals ("#03", "-1", (-1).ToString ("##.#.##.###.####", _nfi));\r
- }\r
-\r
- public void Test08012 () {\r
- AssertEquals ("#01", "00", 0.ToString ("0#.#.##.###.####", _nfi));\r
- AssertEquals ("#02", "01", 1.ToString ("0#.#.##.###.####", _nfi));\r
- AssertEquals ("#03", "-01", (-1).ToString ("0#.#.##.###.####", _nfi));\r
- }\r
-\r
- public void Test08013 () {\r
- AssertEquals ("#01", "0", 0.ToString ("#0.#.##.###.####", _nfi));\r
- AssertEquals ("#02", "1", 1.ToString ("#0.#.##.###.####", _nfi));\r
- AssertEquals ("#03", "-1", (-1).ToString ("#0.#.##.###.####", _nfi));\r
- }\r
-\r
- public void Test08014 () {\r
- AssertEquals ("#01", ".0000000000", 0.ToString ("##.#.##.###.###0", _nfi));\r
- AssertEquals ("#02", "1.0000000000", 1.ToString ("##.#.##.###.###0", _nfi));\r
- AssertEquals ("#03", "-1.0000000000", (-1).ToString ("##.#.##.###.###0", _nfi));\r
- }\r
-\r
- public void Test08015 () {\r
- AssertEquals ("#01", ".000000000", 0.ToString ("##.#.##.###.##0#", _nfi));\r
- AssertEquals ("#02", "1.000000000", 1.ToString ("##.#.##.###.##0#", _nfi));\r
- AssertEquals ("#03", "-1.000000000", (-1).ToString ("##.#.##.###.##0#", _nfi));\r
- }\r
-\r
- public void Test08016 () {\r
- AssertEquals ("#01", ".000000000", 0.ToString ("##.#.##.##0.##0#", _nfi));\r
- AssertEquals ("#02", "1.000000000", 1.ToString ("##.#.##.##0.##0#", _nfi));\r
- AssertEquals ("#03", "-1.000000000", (-1).ToString ("##.#.##.##0.##0#", _nfi));\r
- }\r
-\r
- public void Test08017 () {\r
- AssertEquals ("#01", "0.000000000", 0.ToString ("#0.#.##.##0.##0#", _nfi));\r
- AssertEquals ("#02", "1.000000000", 1.ToString ("#0.#.##.##0.##0#", _nfi));\r
- AssertEquals ("#03", "-1.000000000", (-1).ToString ("#0.#.##.##0.##0#", _nfi));\r
- }\r
-\r
- public void Test08018 () {\r
- AssertEquals ("#01", "-0002147484", Int32.MinValue.ToString ("0000000000,", _nfi));\r
- AssertEquals ("#02", "-0000002147", Int32.MinValue.ToString ("0000000000,,", _nfi));\r
- AssertEquals ("#03", "-0000000002", Int32.MinValue.ToString ("0000000000,,,", _nfi));\r
- AssertEquals ("#04", "0000000000", Int32.MinValue.ToString ("0000000000,,,,", _nfi));\r
- AssertEquals ("#05", "0000000000", Int32.MinValue.ToString ("0000000000,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", _nfi));\r
- }\r
-\r
- public void Test08019 () {\r
- AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString (",0000000000", _nfi));\r
- }\r
-\r
- public void Test08020 () {\r
- AssertEquals ("#01", "-0002147484", Int32.MinValue.ToString (",0000000000,", _nfi));\r
- }\r
-\r
- public void Test08021 () {\r
- AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString ("0,0000000000", _nfi));\r
- }\r
-\r
- public void Test08022 () {\r
- AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString ("0000000000,0", _nfi));\r
- }\r
-\r
- public void Test08023 () {\r
- AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0", _nfi));\r
- }\r
-\r
- public void Test08024 () {\r
- AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0", _nfi));\r
- }\r
-\r
- public void Test08025 () {\r
- AssertEquals ("#01", "-00,002,147,484", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0,", _nfi));\r
- }\r
-\r
- public void Test08026 () {\r
- AssertEquals ("#01", "-00,002,147,484", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0,", _nfi));\r
- }\r
-\r
- public void Test08027 () {\r
- AssertEquals ("#01", "-", Int32.MinValue.ToString (",", _nfi));\r
- }\r
-\r
- public void Test08028 () {\r
- AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString (",##########", _nfi));\r
- }\r
-\r
- public void Test08029 () {\r
- AssertEquals ("#01", "-2147484", Int32.MinValue.ToString (",##########,", _nfi));\r
- }\r
-\r
- public void Test08030 () {\r
- AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("#,##########", _nfi));\r
- }\r
-\r
- public void Test08031 () {\r
- AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("##########,#", _nfi));\r
- }\r
-\r
- public void Test08032 () {\r
- AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#", _nfi));\r
- }\r
-\r
- public void Test08033 () {\r
- AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#", _nfi));\r
- }\r
-\r
- public void Test08034 () {\r
- AssertEquals ("#01", "-2,147,484", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#,", _nfi));\r
- }\r
-\r
- public void Test08035 () {\r
- AssertEquals ("#01", "-2,147,484", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#,", _nfi));\r
- }\r
-\r
- public void Test08036 () {\r
- AssertEquals ("#01", "-1", (-1000).ToString ("##########,", _nfi));\r
- }\r
- public void Test08037 () {\r
- AssertEquals ("#01", "", (-100).ToString ("##########,", _nfi));\r
- }\r
-\r
- public void Test08038 () {\r
- AssertEquals ("#01", "-%", Int32.MinValue.ToString ("%", _nfi));\r
- }\r
-\r
- public void Test08039 () {\r
- AssertEquals ("#01", "-214748364800%", Int32.MinValue.ToString ("0%", _nfi));\r
- }\r
-\r
- public void Test08040 () {\r
- AssertEquals ("#01", "-%214748364800", Int32.MinValue.ToString ("%0", _nfi));\r
- }\r
-\r
- public void Test08041 () {\r
- AssertEquals ("#01", "-%21474836480000%", Int32.MinValue.ToString ("%0%", _nfi));\r
- }\r
-\r
- public void Test08042 () {\r
- AssertEquals ("#01", "- % 21474836480000 % ", Int32.MinValue.ToString (" % 0 % ", _nfi));\r
- }\r
-\r
- public void Test08043 () {\r
- AssertEquals ("#01", "-214748365%", Int32.MinValue.ToString ("0%,", _nfi));\r
- }\r
-\r
- public void Test08044 () {\r
- AssertEquals ("#01", "-214748365%", Int32.MinValue.ToString ("0,%", _nfi));\r
- }\r
-\r
- public void Test08045 () {\r
- AssertEquals ("#01", "-%214748364800", Int32.MinValue.ToString (",%0", _nfi));\r
- }\r
-\r
- public void Test08046 () {\r
- AssertEquals ("#01", "-%214748364800", Int32.MinValue.ToString ("%,0", _nfi));\r
- }\r
-\r
- public void Test08047 () {\r
- AssertEquals ("#01", "-2147483648%%%%%%", Int32.MinValue.ToString ("0,,,,%%%%%%", _nfi));\r
- }\r
-\r
- public void Test08048 () {\r
- AssertEquals ("#01", "-2147483648%%%%%%", Int32.MinValue.ToString ("0%%%%%%,,,,", _nfi));\r
- }\r
-\r
- public void Test08049 () {\r
- AssertEquals ("#01", "-%%%%%%2147483648", Int32.MinValue.ToString ("%%%%%%0,,,,", _nfi));\r
- }\r
-\r
- public void Test08050 () {\r
- AssertEquals ("#01", "E+0", Int32.MinValue.ToString ("E+0", _nfi));\r
- AssertEquals ("#02", "e+0", Int32.MinValue.ToString ("e+0", _nfi));\r
- AssertEquals ("#03", "E0", Int32.MinValue.ToString ("E-0", _nfi));\r
- AssertEquals ("#04", "e0", Int32.MinValue.ToString ("e-0", _nfi));\r
- }\r
-\r
- public void Test08051 () {\r
- AssertEquals ("#01", "-2E+9", Int32.MinValue.ToString ("0E+0", _nfi));\r
- AssertEquals ("#02", "-2e+9", Int32.MinValue.ToString ("0e+0", _nfi));\r
- AssertEquals ("#03", "-2E9", Int32.MinValue.ToString ("0E-0", _nfi));\r
- AssertEquals ("#04", "-2e9", Int32.MinValue.ToString ("0e-0", _nfi));\r
- AssertEquals ("#05", "-2E9", Int32.MinValue.ToString ("0E0", _nfi));\r
- AssertEquals ("#06", "-2e9", Int32.MinValue.ToString ("0e0", _nfi));\r
- }\r
-\r
- public void Test08052 () {\r
- AssertEquals ("#01", "-2E+9", Int32.MinValue.ToString ("#E+0", _nfi));\r
- AssertEquals ("#02", "-2e+9", Int32.MinValue.ToString ("#e+0", _nfi));\r
- AssertEquals ("#03", "-2E9", Int32.MinValue.ToString ("#E-0", _nfi));\r
- AssertEquals ("#04", "-2e9", Int32.MinValue.ToString ("#e-0", _nfi));\r
- AssertEquals ("#05", "-2E9", Int32.MinValue.ToString ("#E0", _nfi));\r
- AssertEquals ("#06", "-2e9", Int32.MinValue.ToString ("#e0", _nfi));\r
- }\r
-\r
- public void Test08053 () {\r
- AssertEquals ("#01", "-2147483648E+0", Int32.MinValue.ToString ("0000000000E+0", _nfi));\r
- AssertEquals ("#02", "-2147483648e+0", Int32.MinValue.ToString ("0000000000e+0", _nfi));\r
- AssertEquals ("#03", "-2147483648E0", Int32.MinValue.ToString ("0000000000E-0", _nfi));\r
- AssertEquals ("#04", "-2147483648e0", Int32.MinValue.ToString ("0000000000e-0", _nfi));\r
- AssertEquals ("#05", "-2147483648E0", Int32.MinValue.ToString ("0000000000E0", _nfi));\r
- AssertEquals ("#06", "-2147483648e0", Int32.MinValue.ToString ("0000000000e0", _nfi));\r
- }\r
-\r
- public void Test08054 () {\r
- AssertEquals ("#01", "-21474836480E-1", Int32.MinValue.ToString ("00000000000E+0", _nfi));\r
- AssertEquals ("#02", "-21474836480e-1", Int32.MinValue.ToString ("00000000000e+0", _nfi));\r
- AssertEquals ("#03", "-21474836480E-1", Int32.MinValue.ToString ("00000000000E-0", _nfi));\r
- AssertEquals ("#04", "-21474836480e-1", Int32.MinValue.ToString ("00000000000e-0", _nfi));\r
- AssertEquals ("#05", "-21474836480E-1", Int32.MinValue.ToString ("00000000000E0", _nfi));\r
- AssertEquals ("#06", "-21474836480e-1", Int32.MinValue.ToString ("00000000000e0", _nfi));\r
- }\r
-\r
- public void Test08055 () {\r
- AssertEquals ("#01", "-214748365E+1", Int32.MinValue.ToString ("000000000E+0", _nfi));\r
- AssertEquals ("#02", "-214748365e+1", Int32.MinValue.ToString ("000000000e+0", _nfi));\r
- AssertEquals ("#03", "-214748365E1", Int32.MinValue.ToString ("000000000E-0", _nfi));\r
- AssertEquals ("#04", "-214748365e1", Int32.MinValue.ToString ("000000000e-0", _nfi));\r
- AssertEquals ("#05", "-214748365E1", Int32.MinValue.ToString ("000000000E0", _nfi));\r
- AssertEquals ("#06", "-214748365e1", Int32.MinValue.ToString ("000000000e0", _nfi));\r
- }\r
-\r
- public void Test08056 () {\r
- AssertEquals ("#01", "-21474836E+2", Int32.MinValue.ToString ("00000000E+0", _nfi));\r
- AssertEquals ("#02", "-21474836e+2", Int32.MinValue.ToString ("00000000e+0", _nfi));\r
- AssertEquals ("#03", "-21474836E2", Int32.MinValue.ToString ("00000000E-0", _nfi));\r
- AssertEquals ("#04", "-21474836e2", Int32.MinValue.ToString ("00000000e-0", _nfi));\r
- AssertEquals ("#05", "-21474836E2", Int32.MinValue.ToString ("00000000E0", _nfi));\r
- AssertEquals ("#06", "-21474836e2", Int32.MinValue.ToString ("00000000e0", _nfi));\r
- }\r
-\r
- public void Test08057 () {\r
- AssertEquals ("#01", "-2147483648E+00", Int32.MinValue.ToString ("0000000000E+00", _nfi));\r
- AssertEquals ("#02", "-2147483648e+00", Int32.MinValue.ToString ("0000000000e+00", _nfi));\r
- AssertEquals ("#03", "-2147483648E00", Int32.MinValue.ToString ("0000000000E-00", _nfi));\r
- AssertEquals ("#04", "-2147483648e00", Int32.MinValue.ToString ("0000000000e-00", _nfi));\r
- AssertEquals ("#05", "-2147483648E00", Int32.MinValue.ToString ("0000000000E00", _nfi));\r
- AssertEquals ("#06", "-2147483648e00", Int32.MinValue.ToString ("0000000000e00", _nfi));\r
- }\r
-\r
- public void Test08058 () {\r
- AssertEquals ("#01", "-2147483648E+02%", Int32.MinValue.ToString ("0000000000E+00%", _nfi));\r
- AssertEquals ("#02", "-2147483648e+02%", Int32.MinValue.ToString ("0000000000e+00%", _nfi));\r
- AssertEquals ("#03", "-2147483648E02%", Int32.MinValue.ToString ("0000000000E-00%", _nfi));\r
- AssertEquals ("#04", "-2147483648e02%", Int32.MinValue.ToString ("0000000000e-00%", _nfi));\r
- AssertEquals ("#05", "-2147483648E02%", Int32.MinValue.ToString ("0000000000E00%", _nfi));\r
- AssertEquals ("#06", "-2147483648e02%", Int32.MinValue.ToString ("0000000000e00%", _nfi));\r
- }\r
-\r
- public void Test08059 () {\r
- AssertEquals ("#01", "-2147483648E+10%%%%%", Int32.MinValue.ToString ("0000000000E+00%%%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e+10%%%%%", Int32.MinValue.ToString ("0000000000e+00%%%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E-00%%%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e-00%%%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E00%%%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e00%%%%%", _nfi));\r
- }\r
-\r
- public void Test08060 () {\r
- AssertEquals ("#01", "-2147483648E-03", Int32.MinValue.ToString ("0000000000E+00,", _nfi));\r
- AssertEquals ("#02", "-2147483648e-03", Int32.MinValue.ToString ("0000000000e+00,", _nfi));\r
- AssertEquals ("#03", "-2147483648E-03", Int32.MinValue.ToString ("0000000000E-00,", _nfi));\r
- AssertEquals ("#04", "-2147483648e-03", Int32.MinValue.ToString ("0000000000e-00,", _nfi));\r
- AssertEquals ("#05", "-2147483648E-03", Int32.MinValue.ToString ("0000000000E00,", _nfi));\r
- AssertEquals ("#06", "-2147483648e-03", Int32.MinValue.ToString ("0000000000e00,", _nfi));\r
- }\r
-\r
- public void Test08061 () {\r
- AssertEquals ("#01", "-2147483648E-12", Int32.MinValue.ToString ("0000000000E+00,,,,", _nfi));\r
- AssertEquals ("#02", "-2147483648e-12", Int32.MinValue.ToString ("0000000000e+00,,,,", _nfi));\r
- AssertEquals ("#03", "-2147483648E-12", Int32.MinValue.ToString ("0000000000E-00,,,,", _nfi));\r
- AssertEquals ("#04", "-2147483648e-12", Int32.MinValue.ToString ("0000000000e-00,,,,", _nfi));\r
- AssertEquals ("#05", "-2147483648E-12", Int32.MinValue.ToString ("0000000000E00,,,,", _nfi));\r
- AssertEquals ("#06", "-2147483648e-12", Int32.MinValue.ToString ("0000000000e00,,,,", _nfi));\r
- }\r
-\r
- public void Test08062 () {\r
- AssertEquals ("#01", "-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E+00,,,,%%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e+00,,,,%%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E-00,,,,%%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e-00,,,,%%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E00,,,,%%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e00,,,,%%%%", _nfi));\r
- }\r
-\r
- public void Test08063 () {\r
- AssertEquals ("#01", "-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E+00,,,,%%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e+00,,,,%%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E-00,,,,%%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e-00,,,,%%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E00,,,,%%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e00,,,,%%%%", _nfi));\r
- }\r
-\r
- public void Test08064 () {\r
- AssertEquals ("#01", "-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E,+00,,,,%%%%", _nfi));\r
- AssertEquals ("#02", "-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e,+00,,,,%%%%", _nfi));\r
- AssertEquals ("#03", "-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E,-00,,,,%%%%", _nfi));\r
- AssertEquals ("#04", "-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e,-00,,,,%%%%", _nfi));\r
- AssertEquals ("#05", "-000,000,214,7E48%%%%", Int32.MinValue.ToString ("0000000000,E,00,,,,%%%%", _nfi));\r
- AssertEquals ("#06", "-000,000,214,7e48%%%%", Int32.MinValue.ToString ("0000000000,e,00,,,,%%%%", _nfi));\r
- }\r
-\r
- public void Test08065 () {\r
- AssertEquals ("#01", "-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E+,00,,,,%%%%", _nfi));\r
- AssertEquals ("#02", "-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e+,00,,,,%%%%", _nfi));\r
- AssertEquals ("#03", "-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E-,00,,,,%%%%", _nfi));\r
- AssertEquals ("#04", "-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e-,00,,,,%%%%", _nfi));\r
- }\r
-\r
- public void Test08066 () {\r
- AssertEquals ("#01", "-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E+0,0,,,,%%%%", _nfi));\r
- AssertEquals ("#02", "-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e+0,0,,,,%%%%", _nfi));\r
- AssertEquals ("#03", "-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E-0,0,,,,%%%%", _nfi));\r
- AssertEquals ("#04", "-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e-0,0,,,,%%%%", _nfi));\r
- AssertEquals ("#05", "-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E0,0,,,,%%%%", _nfi));\r
- AssertEquals ("#06", "-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e0,0,,,,%%%%", _nfi));\r
- }\r
-\r
- public void Test08067 () {\r
- AssertEquals ("#01", "-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,,%%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,,%%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,,%%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,,%%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,,%%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,,%%%%", _nfi));\r
- }\r
-\r
- public void Test08068 () {\r
- AssertEquals ("#01", "-2147483648E+02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,%%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e+02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,%%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,%%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,%%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,%%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,%%%%", _nfi));\r
- }\r
-\r
- public void Test08069 () {\r
- AssertEquals ("#01", "-2147483648E+00,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e+00,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%%", _nfi));\r
- }\r
-\r
- public void Test08070 () {\r
- AssertEquals ("#01", "-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%\%", _nfi));\r
- AssertEquals ("#02", "-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%\%", _nfi));\r
- AssertEquals ("#03", "-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%\%", _nfi));\r
- AssertEquals ("#04", "-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%\%", _nfi));\r
- AssertEquals ("#05", "-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%\%", _nfi));\r
- AssertEquals ("#06", "-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%\%", _nfi));\r
- }\r
-\r
- public void Test08071 () {\r
- AssertEquals ("#01", @"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,,,\\,\\%%%\\%", _nfi));\r
- AssertEquals ("#02", @"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,,,\\,\\%%%\\%", _nfi));\r
- AssertEquals ("#03", @"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,,,\\,\\%%%\\%", _nfi));\r
- AssertEquals ("#04", @"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,,,\\,\\%%%\\%", _nfi));\r
- AssertEquals ("#05", @"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,,,\\,\\%%%\\%", _nfi));\r
- AssertEquals ("#06", @"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,,,\\,\\%%%\\%", _nfi));\r
- }\r
-\r
- public void Test08072 () {\r
- AssertEquals ("#01", @"-2147483648E+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#02", @"-2147483648e+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#03", @"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#04", @"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#05", @"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#06", @"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- }\r
-\r
- public void Test08073 () {\r
- AssertEquals ("#01", @"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E+00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#02", @"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e+00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#03", @"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E-00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#04", @"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e-00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#05", @"-0021474836E48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#06", @"-0021474836e48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- }\r
-\r
- public void Test08074 () {\r
- AssertEquals ("#01", @"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\+00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#02", @"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\+00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#03", @"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\-00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- AssertEquals ("#04", @"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\-00\\,\,,\\\,\\%%%\\\%", _nfi));\r
- }\r
-\r
- public void Test08075 () {\r
- AssertEquals ("#01", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,',%'%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,',%'%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,',%'%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,',%'%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,',%'%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,',%'%%%", _nfi));\r
- }\r
-\r
- public void Test08076 () {\r
- AssertEquals ("#01", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,\",%\"%%%", _nfi));\r
- AssertEquals ("#02", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,\",%\"%%%", _nfi));\r
- AssertEquals ("#03", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,\",%\"%%%", _nfi));\r
- AssertEquals ("#04", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,\",%\"%%%", _nfi));\r
- AssertEquals ("#05", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,\",%\"%%%", _nfi));\r
- AssertEquals ("#06", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,\",%\"%%%", _nfi));\r
- }\r
-\r
- public void Test08077 () {\r
- AssertEquals ("#01", "-", Int32.MinValue.ToString (";", _nfi));\r
- AssertEquals ("#02", "", Int32.MaxValue.ToString (";", _nfi));\r
- AssertEquals ("#03", "",0.ToString (";", _nfi));\r
- }\r
-\r
- public void Test08078 () {\r
- AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("#,#;", _nfi));\r
- AssertEquals ("#02", "2,147,483,647", Int32.MaxValue.ToString ("#,#;", _nfi));\r
- AssertEquals ("#03", "", 0.ToString ("#,#;", _nfi));\r
- }\r
-\r
- public void Test08079 () {\r
- AssertEquals ("#01", "2,147,483,648", Int32.MinValue.ToString (";#,#", _nfi));\r
- AssertEquals ("#02", "", Int32.MaxValue.ToString (";#,#", _nfi));\r
- AssertEquals ("#03", "", 0.ToString (";#,#", _nfi));\r
- }\r
-\r
- public void Test08080 () {\r
- AssertEquals ("#01", "2,147,483,648", Int32.MinValue.ToString ("0000000000,.0000000000;#,#", _nfi));\r
- AssertEquals ("#02", "0002147483.6470000000", Int32.MaxValue.ToString ("0000000000,.0000000000;#,#", _nfi));\r
- AssertEquals ("#03", "0000000000.0000000000", 0.ToString ("0000000000,.0000000000;#,#", _nfi));\r
- }\r
-\r
- public void Test08081 () {\r
- AssertEquals ("#01", "-", Int32.MinValue.ToString (";;", _nfi));\r
- AssertEquals ("#02", "", Int32.MaxValue.ToString (";;", _nfi));\r
- AssertEquals ("#03", "",0.ToString (";;", _nfi));\r
- }\r
-\r
- public void Test08082 () {\r
- AssertEquals ("#01", "-", Int32.MinValue.ToString (";;0%", _nfi));\r
- AssertEquals ("#02", "", Int32.MaxValue.ToString (";;0%", _nfi));\r
- AssertEquals ("#03", "0%",0.ToString (";;0%", _nfi));\r
- }\r
-\r
- public void Test08083 () {\r
- AssertEquals ("#01", "2147484", Int32.MinValue.ToString (";0,;0%", _nfi));\r
- AssertEquals ("#02", "", Int32.MaxValue.ToString (";0,;0%", _nfi));\r
- AssertEquals ("#03", "0%",0.ToString (";0,;0%", _nfi));\r
- }\r
-\r
- public void Test08084 () {\r
- AssertEquals ("#01", "2147484", Int32.MinValue.ToString ("0E+0;0,;0%", _nfi));\r
- AssertEquals ("#02", "2E+9", Int32.MaxValue.ToString ("0E+0;0,;0%", _nfi));\r
- AssertEquals ("#03", "0%",0.ToString ("0E+0;0,;0%", _nfi));\r
- }\r
-\r
- public void Test08085 () {\r
- AssertEquals ("#01", "214,748,364,80;0%", Int32.MinValue.ToString (@"0E+0;0,\;0%", _nfi));\r
- AssertEquals ("#02", "2E+9", Int32.MaxValue.ToString (@"0E+0;0,\;0%", _nfi));\r
- AssertEquals ("#03", "0E+0",0.ToString (@"0E+0;0,\;0%", _nfi));\r
- }\r
-\r
- public void Test08086 () {\r
- AssertEquals ("#01", "214,748,364,80;0%", Int32.MinValue.ToString ("0E+0;0,\";\"0%", _nfi));\r
- AssertEquals ("#02", "2E+9", Int32.MaxValue.ToString ("0E+0;0,\";\"0%", _nfi));\r
- AssertEquals ("#03", "0E+0",0.ToString ("0E+0;0,\";\"0%", _nfi));\r
- }\r
-\r
- public void Test08087 () {\r
- // MS.NET bug?\r
- NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "$$$";\r
- AssertEquals ("#01", "-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi));\r
- }\r
-\r
- public void Test08088 () {\r
- // MS.NET bug?\r
- NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;\r
- nfi.NumberGroupSeparator = "$$$";\r
- AssertEquals ("#01", "-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi));\r
- }\r
-\r
- public void Test08089 () {\r
- NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;\r
- nfi.NumberGroupSizes = new int[] {3,2,1,0};\r
- AssertEquals ("#01", "-00000000002147,4,83,648", Int32.MinValue.ToString ("0000000000,0000000000", nfi));\r
- }\r
-\r
- public void Test08090 () {\r
- // MS.NET bug?\r
- NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;\r
- nfi.PercentSymbol = "$$$";\r
- AssertEquals ("#01", "-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi));\r
- }\r
-\r
- public void Test08091 () {\r
- // MS.NET bug?\r
- AssertEquals ("#01", "B2147", Int32.MinValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi));\r
- AssertEquals ("#02", "A2147484", Int32.MaxValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi));\r
- AssertEquals ("#03", "C0", 0.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi));\r
- }\r
-\r
- // Test10000- Double and D\r
- [Test]\r
- [ExpectedException (typeof (FormatException))]\r
- public void Test10000 () {\r
- AssertEquals ("#01", "0", 0.0.ToString ("D", _nfi));\r
- }\r
-\r
- // Test11000- Double and E\r
- [Test]\r
- public void Test11000 () {\r
- AssertEquals ("#01", "0.000000E+000", 0.0.ToString ("E", _nfi));\r
- AssertEquals ("#02", "0.000000e+000", 0.0.ToString ("e", _nfi));\r
- AssertEquals ("#03", "-1.797693E+308", Double.MinValue.ToString ("E", _nfi));\r
- AssertEquals ("#04", "-1.797693e+308", Double.MinValue.ToString ("e", _nfi));\r
- AssertEquals ("#05", "1.797693E+308", Double.MaxValue.ToString ("E", _nfi));\r
- AssertEquals ("#06", "1.797693e+308", Double.MaxValue.ToString ("e", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11001 () {\r
- AssertEquals ("#01", "E ", 0.0.ToString ("E ", _nfi));\r
- AssertEquals ("#02", " E", 0.0.ToString (" E", _nfi));\r
- AssertEquals ("#03", " E ", 0.0.ToString (" E ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11002 () {\r
- AssertEquals ("#01", "-E ", (-1.0).ToString ("E ", _nfi));\r
- AssertEquals ("#02", "- E", (-1.0).ToString (" E", _nfi));\r
- AssertEquals ("#03", "- E ", (-1.0).ToString (" E ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11003 () {\r
- AssertEquals ("#01", "0E+000", 0.0.ToString ("E0", _nfi));\r
- AssertEquals ("#02", "0.0000000000000000E+000", 0.0.ToString ("E16", _nfi));\r
- AssertEquals ("#03", "0.00000000000000000E+000", 0.0.ToString ("E17", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.0.ToString ("E99", _nfi));\r
- AssertEquals ("#05", "E100", 0.0.ToString ("E100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11004 () {\r
- AssertEquals ("#01", "2E+308", Double.MaxValue.ToString ("E0", _nfi));\r
- AssertEquals ("#02", "1.7976931348623157E+308", Double.MaxValue.ToString ("E16", _nfi));\r
- AssertEquals ("#03", "1.79769313486231570E+308", Double.MaxValue.ToString ("E17", _nfi));\r
- AssertEquals ("#04", "1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MaxValue.ToString ("E99", _nfi));\r
- AssertEquals ("#05", "E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("E100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11005 () {\r
- AssertEquals ("#01", "-2E+308", Double.MinValue.ToString ("E0", _nfi));\r
- AssertEquals ("#02", "-1.7976931348623157E+308", Double.MinValue.ToString ("E16", _nfi));\r
- AssertEquals ("#03", "-1.79769313486231570E+308", Double.MinValue.ToString ("E17", _nfi));\r
- AssertEquals ("#04", "-1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MinValue.ToString ("E99", _nfi));\r
- AssertEquals ("#05", "-E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("E100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11006 () {\r
- AssertEquals ("#01", "EF", 0.0.ToString ("EF", _nfi));\r
- AssertEquals ("#02", "E0F", 0.0.ToString ("E0F", _nfi));\r
- AssertEquals ("#03", "E0xF", 0.0.ToString ("E0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11007 () {\r
- AssertEquals ("#01", "EF", Double.MaxValue.ToString ("EF", _nfi));\r
- AssertEquals ("#02", "E0F", Double.MaxValue.ToString ("E0F", _nfi));\r
- AssertEquals ("#03", "E0xF", Double.MaxValue.ToString ("E0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11008 () {\r
- AssertEquals ("#01", "-EF", Double.MinValue.ToString ("EF", _nfi));\r
- AssertEquals ("#02", "E0F", Double.MinValue.ToString ("E0F", _nfi));\r
- AssertEquals ("#03", "E0xF", Double.MinValue.ToString ("E0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11009 () {\r
- AssertEquals ("#01", "0.00000000000000000E+000", 0.0.ToString ("E0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#02", "1.79769313486231570E+308", Double.MaxValue.ToString ("E0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#03", "-1.79769313486231570E+308", Double.MinValue.ToString ("E0000000000000000000000000000000000000017", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11010 () {\r
- AssertEquals ("#01", "+E", 0.0.ToString ("+E", _nfi));\r
- AssertEquals ("#02", "E+", 0.0.ToString ("E+", _nfi));\r
- AssertEquals ("#03", "+E+", 0.0.ToString ("+E+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test11011 () {\r
- AssertEquals ("#01", "+E", Double.MaxValue.ToString ("+E", _nfi));\r
- AssertEquals ("#02", "E+", Double.MaxValue.ToString ("E+", _nfi));\r
- AssertEquals ("#03", "+E+", Double.MaxValue.ToString ("+E+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11012 () {\r
- AssertEquals ("#01", "-+E", Double.MinValue.ToString ("+E", _nfi));\r
- AssertEquals ("#02", "-E+", Double.MinValue.ToString ("E+", _nfi));\r
- AssertEquals ("#03", "-+E+", Double.MinValue.ToString ("+E+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11013 () {\r
- AssertEquals ("#01", "-E", 0.0.ToString ("-E", _nfi));\r
- AssertEquals ("#02", "E-", 0.0.ToString ("E-", _nfi));\r
- AssertEquals ("#03", "-E-", 0.0.ToString ("-E-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test11014 () {\r
- AssertEquals ("#01", "-E", Double.MaxValue.ToString ("-E", _nfi));\r
- AssertEquals ("#02", "E-", Double.MaxValue.ToString ("E-", _nfi));\r
- AssertEquals ("#03", "-E-", Double.MaxValue.ToString ("-E-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11015 () {\r
- AssertEquals ("#01", "--E", Double.MinValue.ToString ("-E", _nfi));\r
- AssertEquals ("#02", "-E-", Double.MinValue.ToString ("E-", _nfi));\r
- AssertEquals ("#03", "--E-", Double.MinValue.ToString ("-E-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11016 () {\r
- AssertEquals ("#01", "E+0", 0.0.ToString ("E+0", _nfi));\r
- AssertEquals ("#02", "E+0", Double.MaxValue.ToString ("E+0", _nfi));\r
- AssertEquals ("#03", "E+0", Double.MinValue.ToString ("E+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11017 () {\r
- AssertEquals ("#01", "E+9", 0.0.ToString ("E+9", _nfi));\r
- AssertEquals ("#02", "E+9", Double.MaxValue.ToString ("E+9", _nfi));\r
- AssertEquals ("#03", "-E+9", Double.MinValue.ToString ("E+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11018 () {\r
- AssertEquals ("#01", "E-9", 0.0.ToString ("E-9", _nfi));\r
- AssertEquals ("#02", "E-9", Double.MaxValue.ToString ("E-9", _nfi));\r
- AssertEquals ("#03", "-E-9", Double.MinValue.ToString ("E-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11019 () {\r
- AssertEquals ("#01", "E0", 0.0.ToString ("E0,", _nfi));\r
- AssertEquals ("#02", "E0", Double.MaxValue.ToString ("E0,", _nfi));\r
- AssertEquals ("#03", "E0", Double.MinValue.ToString ("E0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11020 () {\r
- AssertEquals ("#01", "E0", 0.0.ToString ("E0.", _nfi));\r
- AssertEquals ("#02", "E0", Double.MaxValue.ToString ("E0.", _nfi));\r
- AssertEquals ("#03", "E0", Double.MinValue.ToString ("E0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11021 () {\r
- AssertEquals ("#01", "E0.0", 0.0.ToString ("E0.0", _nfi));\r
- AssertEquals ("#02", "E309.2", Double.MaxValue.ToString ("E0.0", _nfi));\r
- AssertEquals ("#03", "-E309.2", Double.MinValue.ToString ("E0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11022 () {\r
- AssertEquals ("#01", "E09", 0.0.ToString ("E0.9", _nfi));\r
- AssertEquals ("#02", "E09", Double.MaxValue.ToString ("E0.9", _nfi));\r
- AssertEquals ("#03", "E09", Double.MinValue.ToString ("E0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11023 () {\r
- AssertEquals ("#01", "1.1E+000", 1.05.ToString ("E1", _nfi));\r
- AssertEquals ("#02", "1.2E+000", 1.15.ToString ("E1", _nfi));\r
- AssertEquals ("#03", "1.3E+000", 1.25.ToString ("E1", _nfi));\r
- AssertEquals ("#04", "1.4E+000", 1.35.ToString ("E1", _nfi));\r
- AssertEquals ("#05", "1.5E+000", 1.45.ToString ("E1", _nfi));\r
- AssertEquals ("#06", "1.6E+000", 1.55.ToString ("E1", _nfi));\r
- AssertEquals ("#07", "1.7E+000", 1.65.ToString ("E1", _nfi));\r
- AssertEquals ("#08", "1.8E+000", 1.75.ToString ("E1", _nfi));\r
- AssertEquals ("#09", "1.9E+000", 1.85.ToString ("E1", _nfi));\r
- AssertEquals ("#10", "2.0E+000", 1.95.ToString ("E1", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11024 () {\r
- AssertEquals ("#01", "1.01E+000", 1.005.ToString ("E2", _nfi));\r
- AssertEquals ("#02", "1.02E+000", 1.015.ToString ("E2", _nfi));\r
- AssertEquals ("#03", "1.03E+000", 1.025.ToString ("E2", _nfi));\r
- AssertEquals ("#04", "1.04E+000", 1.035.ToString ("E2", _nfi));\r
- AssertEquals ("#05", "1.05E+000", 1.045.ToString ("E2", _nfi));\r
- AssertEquals ("#06", "1.06E+000", 1.055.ToString ("E2", _nfi));\r
- AssertEquals ("#07", "1.07E+000", 1.065.ToString ("E2", _nfi));\r
- AssertEquals ("#08", "1.08E+000", 1.075.ToString ("E2", _nfi));\r
- AssertEquals ("#09", "1.09E+000", 1.085.ToString ("E2", _nfi));\r
- AssertEquals ("#10", "1.10E+000", 1.095.ToString ("E2", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11025 () {\r
- AssertEquals ("#01", "1.00000000000001E+000", 1.000000000000005.ToString ("E14", _nfi));\r
- AssertEquals ("#02", "1.00000000000002E+000", 1.000000000000015.ToString ("E14", _nfi));\r
- AssertEquals ("#03", "1.00000000000003E+000", 1.000000000000025.ToString ("E14", _nfi));\r
- AssertEquals ("#04", "1.00000000000004E+000", 1.000000000000035.ToString ("E14", _nfi));\r
- AssertEquals ("#05", "1.00000000000005E+000", 1.000000000000045.ToString ("E14", _nfi));\r
- AssertEquals ("#06", "1.00000000000006E+000", 1.000000000000055.ToString ("E14", _nfi));\r
- AssertEquals ("#07", "1.00000000000007E+000", 1.000000000000065.ToString ("E14", _nfi));\r
- AssertEquals ("#08", "1.00000000000008E+000", 1.000000000000075.ToString ("E14", _nfi));\r
- AssertEquals ("#09", "1.00000000000009E+000", 1.000000000000085.ToString ("E14", _nfi));\r
- AssertEquals ("#10", "1.00000000000010E+000", 1.000000000000095.ToString ("E14", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11026 () {\r
- AssertEquals ("#01", "1.000000000000000E+000", 1.0000000000000005.ToString ("E15", _nfi));\r
- AssertEquals ("#02", "1.000000000000002E+000", 1.0000000000000015.ToString ("E15", _nfi));\r
- AssertEquals ("#03", "1.000000000000002E+000", 1.0000000000000025.ToString ("E15", _nfi));\r
- AssertEquals ("#04", "1.000000000000004E+000", 1.0000000000000035.ToString ("E15", _nfi));\r
- AssertEquals ("#05", "1.000000000000004E+000", 1.0000000000000045.ToString ("E15", _nfi));\r
- AssertEquals ("#06", "1.000000000000006E+000", 1.0000000000000055.ToString ("E15", _nfi));\r
- AssertEquals ("#07", "1.000000000000006E+000", 1.0000000000000065.ToString ("E15", _nfi));\r
- AssertEquals ("#08", "1.000000000000008E+000", 1.0000000000000075.ToString ("E15", _nfi));\r
- AssertEquals ("#09", "1.000000000000008E+000", 1.0000000000000085.ToString ("E15", _nfi));\r
- AssertEquals ("#10", "1.000000000000010E+000", 1.0000000000000095.ToString ("E15", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11027 () {\r
- AssertEquals ("#01", "1.0000000000000000E+000", 1.00000000000000005.ToString ("E16", _nfi));\r
- AssertEquals ("#02", "1.0000000000000002E+000", 1.00000000000000015.ToString ("E16", _nfi));\r
- AssertEquals ("#03", "1.0000000000000002E+000", 1.00000000000000025.ToString ("E16", _nfi));\r
- AssertEquals ("#04", "1.0000000000000004E+000", 1.00000000000000035.ToString ("E16", _nfi));\r
- AssertEquals ("#05", "1.0000000000000004E+000", 1.00000000000000045.ToString ("E16", _nfi));\r
- AssertEquals ("#06", "1.0000000000000004E+000", 1.00000000000000055.ToString ("E16", _nfi));\r
- AssertEquals ("#07", "1.0000000000000007E+000", 1.00000000000000065.ToString ("E16", _nfi));\r
- AssertEquals ("#08", "1.0000000000000007E+000", 1.00000000000000075.ToString ("E16", _nfi));\r
- AssertEquals ("#09", "1.0000000000000009E+000", 1.00000000000000085.ToString ("E16", _nfi));\r
- AssertEquals ("#10", "1.0000000000000009E+000", 1.00000000000000095.ToString ("E16", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11028 () {\r
- AssertEquals ("#01", "1.00000000000000000E+000", 1.000000000000000005.ToString ("E17", _nfi));\r
- AssertEquals ("#02", "1.00000000000000000E+000", 1.000000000000000015.ToString ("E17", _nfi));\r
- AssertEquals ("#03", "1.00000000000000000E+000", 1.000000000000000025.ToString ("E17", _nfi));\r
- AssertEquals ("#04", "1.00000000000000000E+000", 1.000000000000000035.ToString ("E17", _nfi));\r
- AssertEquals ("#05", "1.00000000000000000E+000", 1.000000000000000045.ToString ("E17", _nfi));\r
- AssertEquals ("#06", "1.00000000000000000E+000", 1.000000000000000055.ToString ("E17", _nfi));\r
- AssertEquals ("#07", "1.00000000000000000E+000", 1.000000000000000065.ToString ("E17", _nfi));\r
- AssertEquals ("#08", "1.00000000000000000E+000", 1.000000000000000075.ToString ("E17", _nfi));\r
- AssertEquals ("#09", "1.00000000000000000E+000", 1.000000000000000085.ToString ("E17", _nfi));\r
- AssertEquals ("#10", "1.00000000000000000E+000", 1.000000000000000095.ToString ("E17", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11029 () {\r
- AssertEquals ("#01", "1E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E0"));\r
- AssertEquals ("#02", "1.2345678901234567E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E16"));\r
- AssertEquals ("#03", "1.23456789012345670E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E17"));\r
- AssertEquals ("#04", "1.234567890123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E99"));\r
- AssertEquals ("#04", "E101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E100"));\r
- }\r
-\r
- [Test]\r
- public void Test11030 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "-1#000000E+008", (-99999999.9).ToString ("E", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11031 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
-\r
- AssertEquals ("#01", "1.000000E-000", 1.0.ToString ("E", nfi));\r
- AssertEquals ("#02", "0.000000E-000", 0.0.ToString ("E", nfi));\r
- AssertEquals ("#03", "+1.000000E-000", (-1.0).ToString ("E", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test11032 () {\r
- AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("E99", _nfi)); \r
- AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("E99", _nfi)); \r
- AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("E99", _nfi)); \r
- }\r
-\r
- // Test12000- Double and F\r
- [Test]\r
- public void Test12000 () {\r
- AssertEquals ("#01", "0.00", 0.0.ToString ("F", _nfi));\r
- AssertEquals ("#02", "0.00", 0.0.ToString ("f", _nfi));\r
- AssertEquals ("#03", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("F", _nfi));\r
- AssertEquals ("#04", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("f", _nfi));\r
- AssertEquals ("#05", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("F", _nfi));\r
- AssertEquals ("#06", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("f", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12001 () {\r
- AssertEquals ("#01", "F ", 0.0.ToString ("F ", _nfi));\r
- AssertEquals ("#02", " F", 0.0.ToString (" F", _nfi));\r
- AssertEquals ("#03", " F ", 0.0.ToString (" F ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12002 () {\r
- AssertEquals ("#01", "-F ", (-1.0).ToString ("F ", _nfi));\r
- AssertEquals ("#02", "- F", (-1.0).ToString (" F", _nfi));\r
- AssertEquals ("#03", "- F ", (-1.0).ToString (" F ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12003 () {\r
- AssertEquals ("#01", "0", 0.0.ToString ("F0", _nfi));\r
- AssertEquals ("#02", "0.0000000000000000", 0.0.ToString ("F16", _nfi));\r
- AssertEquals ("#03", "0.00000000000000000", 0.0.ToString ("F17", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("F99", _nfi));\r
- AssertEquals ("#05", "F100", 0.0.ToString ("F100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12004 () {\r
- AssertEquals ("#01", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0", _nfi));\r
- AssertEquals ("#02", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MaxValue.ToString ("F16", _nfi));\r
- AssertEquals ("#03", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F17", _nfi));\r
- AssertEquals ("#04", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F99", _nfi));\r
- AssertEquals ("#05", "F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12005 () {\r
- AssertEquals ("#01", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0", _nfi));\r
- AssertEquals ("#02", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MinValue.ToString ("F16", _nfi));\r
- AssertEquals ("#03", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F17", _nfi));\r
- AssertEquals ("#04", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F99", _nfi));\r
- AssertEquals ("#05", "-F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12006 () {\r
- AssertEquals ("#01", "FF", 0.0.ToString ("FF", _nfi));\r
- AssertEquals ("#02", "F0F", 0.0.ToString ("F0F", _nfi));\r
- AssertEquals ("#03", "F0xF", 0.0.ToString ("F0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12007 () {\r
- AssertEquals ("#01", "FF", Double.MaxValue.ToString ("FF", _nfi));\r
- AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("F0F", _nfi));\r
- AssertEquals ("#03", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("F0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12008 () {\r
- AssertEquals ("#01", "-FF", Double.MinValue.ToString ("FF", _nfi));\r
- AssertEquals ("#02", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("F0F", _nfi));\r
- AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("F0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12009 () {\r
- AssertEquals ("#01", "0.00000000000000000", 0.0.ToString ("F0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#02", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#03", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F0000000000000000000000000000000000000017", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12010 () {\r
- AssertEquals ("#01", "+F", 0.0.ToString ("+F", _nfi));\r
- AssertEquals ("#02", "F+", 0.0.ToString ("F+", _nfi));\r
- AssertEquals ("#03", "+F+", 0.0.ToString ("+F+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test12011 () {\r
- AssertEquals ("#01", "+F", Double.MaxValue.ToString ("+F", _nfi));\r
- AssertEquals ("#02", "F+", Double.MaxValue.ToString ("F+", _nfi));\r
- AssertEquals ("#03", "+F+", Double.MaxValue.ToString ("+F+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12012 () {\r
- AssertEquals ("#01", "-+F", Double.MinValue.ToString ("+F", _nfi));\r
- AssertEquals ("#02", "-F+", Double.MinValue.ToString ("F+", _nfi));\r
- AssertEquals ("#03", "-+F+", Double.MinValue.ToString ("+F+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12013 () {\r
- AssertEquals ("#01", "-F", 0.0.ToString ("-F", _nfi));\r
- AssertEquals ("#02", "F-", 0.0.ToString ("F-", _nfi));\r
- AssertEquals ("#03", "-F-", 0.0.ToString ("-F-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test12014 () {\r
- AssertEquals ("#01", "-F", Double.MaxValue.ToString ("-F", _nfi));\r
- AssertEquals ("#02", "F-", Double.MaxValue.ToString ("F-", _nfi));\r
- AssertEquals ("#03", "-F-", Double.MaxValue.ToString ("-F-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12015 () {\r
- AssertEquals ("#01", "--F", Double.MinValue.ToString ("-F", _nfi));\r
- AssertEquals ("#02", "-F-", Double.MinValue.ToString ("F-", _nfi));\r
- AssertEquals ("#03", "--F-", Double.MinValue.ToString ("-F-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12016 () {\r
- AssertEquals ("#01", "F+0", 0.0.ToString ("F+0", _nfi));\r
- AssertEquals ("#02", "F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F+0", _nfi));\r
- AssertEquals ("#03", "-F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12017 () {\r
- AssertEquals ("#01", "F+9", 0.0.ToString ("F+9", _nfi));\r
- AssertEquals ("#02", "F+9", Double.MaxValue.ToString ("F+9", _nfi));\r
- AssertEquals ("#03", "-F+9", Double.MinValue.ToString ("F+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12018 () {\r
- AssertEquals ("#01", "F-9", 0.0.ToString ("F-9", _nfi));\r
- AssertEquals ("#02", "F-9", Double.MaxValue.ToString ("F-9", _nfi));\r
- AssertEquals ("#03", "-F-9", Double.MinValue.ToString ("F-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12019 () {\r
- AssertEquals ("#01", "F0", 0.0.ToString ("F0,", _nfi));\r
- AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0,", _nfi));\r
- AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12020 () {\r
- AssertEquals ("#01", "F0", 0.0.ToString ("F0.", _nfi));\r
- AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0.", _nfi));\r
- AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12021 () {\r
- AssertEquals ("#01", "F0.0", 0.0.ToString ("F0.0", _nfi));\r
- AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("F0.0", _nfi));\r
- AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("F0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12022 () {\r
- AssertEquals ("#01", "F09", 0.0.ToString ("F0.9", _nfi));\r
- AssertEquals ("#02", "F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("F0.9", _nfi));\r
- AssertEquals ("#03", "-F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("F0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12023 () {\r
- AssertEquals ("#01", "1.1", 1.05.ToString ("F1", _nfi));\r
- AssertEquals ("#02", "1.2", 1.15.ToString ("F1", _nfi));\r
- AssertEquals ("#03", "1.3", 1.25.ToString ("F1", _nfi));\r
- AssertEquals ("#04", "1.4", 1.35.ToString ("F1", _nfi));\r
- AssertEquals ("#05", "1.5", 1.45.ToString ("F1", _nfi));\r
- AssertEquals ("#06", "1.6", 1.55.ToString ("F1", _nfi));\r
- AssertEquals ("#07", "1.7", 1.65.ToString ("F1", _nfi));\r
- AssertEquals ("#08", "1.8", 1.75.ToString ("F1", _nfi));\r
- AssertEquals ("#09", "1.9", 1.85.ToString ("F1", _nfi));\r
- AssertEquals ("#10", "2.0", 1.95.ToString ("F1", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12024 () {\r
- AssertEquals ("#01", "1.01", 1.005.ToString ("F2", _nfi));\r
- AssertEquals ("#02", "1.02", 1.015.ToString ("F2", _nfi));\r
- AssertEquals ("#03", "1.03", 1.025.ToString ("F2", _nfi));\r
- AssertEquals ("#04", "1.04", 1.035.ToString ("F2", _nfi));\r
- AssertEquals ("#05", "1.05", 1.045.ToString ("F2", _nfi));\r
- AssertEquals ("#06", "1.06", 1.055.ToString ("F2", _nfi));\r
- AssertEquals ("#07", "1.07", 1.065.ToString ("F2", _nfi));\r
- AssertEquals ("#08", "1.08", 1.075.ToString ("F2", _nfi));\r
- AssertEquals ("#09", "1.09", 1.085.ToString ("F2", _nfi));\r
- AssertEquals ("#10", "1.10", 1.095.ToString ("F2", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12025 () {\r
- AssertEquals ("#01", "1.00000000000001", 1.000000000000005.ToString ("F14", _nfi));\r
- AssertEquals ("#02", "1.00000000000002", 1.000000000000015.ToString ("F14", _nfi));\r
- AssertEquals ("#03", "1.00000000000003", 1.000000000000025.ToString ("F14", _nfi));\r
- AssertEquals ("#04", "1.00000000000004", 1.000000000000035.ToString ("F14", _nfi));\r
- AssertEquals ("#05", "1.00000000000005", 1.000000000000045.ToString ("F14", _nfi));\r
- AssertEquals ("#06", "1.00000000000006", 1.000000000000055.ToString ("F14", _nfi));\r
- AssertEquals ("#07", "1.00000000000007", 1.000000000000065.ToString ("F14", _nfi));\r
- AssertEquals ("#08", "1.00000000000008", 1.000000000000075.ToString ("F14", _nfi));\r
- AssertEquals ("#09", "1.00000000000009", 1.000000000000085.ToString ("F14", _nfi));\r
- AssertEquals ("#10", "1.00000000000010", 1.000000000000095.ToString ("F14", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12026 () {\r
- AssertEquals ("#01", "1.000000000000000", 1.0000000000000005.ToString ("F15", _nfi));\r
- AssertEquals ("#02", "1.000000000000000", 1.0000000000000015.ToString ("F15", _nfi));\r
- AssertEquals ("#03", "1.000000000000000", 1.0000000000000025.ToString ("F15", _nfi));\r
- AssertEquals ("#04", "1.000000000000000", 1.0000000000000035.ToString ("F15", _nfi));\r
- AssertEquals ("#05", "1.000000000000000", 1.0000000000000045.ToString ("F15", _nfi));\r
- AssertEquals ("#06", "1.000000000000010", 1.0000000000000055.ToString ("F15", _nfi));\r
- AssertEquals ("#07", "1.000000000000010", 1.0000000000000065.ToString ("F15", _nfi));\r
- AssertEquals ("#08", "1.000000000000010", 1.0000000000000075.ToString ("F15", _nfi));\r
- AssertEquals ("#09", "1.000000000000010", 1.0000000000000085.ToString ("F15", _nfi));\r
- AssertEquals ("#10", "1.000000000000010", 1.0000000000000095.ToString ("F15", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12027 () {\r
- AssertEquals ("#01", "1.0000000000000000", 1.00000000000000005.ToString ("F16", _nfi));\r
- AssertEquals ("#02", "1.0000000000000000", 1.00000000000000015.ToString ("F16", _nfi));\r
- AssertEquals ("#03", "1.0000000000000000", 1.00000000000000025.ToString ("F16", _nfi));\r
- AssertEquals ("#04", "1.0000000000000000", 1.00000000000000035.ToString ("F16", _nfi));\r
- AssertEquals ("#05", "1.0000000000000000", 1.00000000000000045.ToString ("F16", _nfi));\r
- AssertEquals ("#06", "1.0000000000000000", 1.00000000000000055.ToString ("F16", _nfi));\r
- AssertEquals ("#07", "1.0000000000000000", 1.00000000000000065.ToString ("F16", _nfi));\r
- AssertEquals ("#08", "1.0000000000000000", 1.00000000000000075.ToString ("F16", _nfi));\r
- AssertEquals ("#09", "1.0000000000000000", 1.00000000000000085.ToString ("F16", _nfi));\r
- AssertEquals ("#10", "1.0000000000000000", 1.00000000000000095.ToString ("F16", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12028 () {\r
- AssertEquals ("#01", "1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F0", _nfi));\r
- AssertEquals ("#02", "1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F12", _nfi));\r
- AssertEquals ("#03", "1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F13", _nfi));\r
- AssertEquals ("#04", "1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F14", _nfi));\r
- AssertEquals ("#05", "1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F15", _nfi));\r
- AssertEquals ("#06", "1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F99", _nfi));\r
- AssertEquals ("#07", "F101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12029 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "-99999999#90", (-99999999.9).ToString ("F", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12030 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
-\r
- AssertEquals ("#01", "1.00", 1.0.ToString ("F", nfi));\r
- AssertEquals ("#02", "0.00", 0.0.ToString ("F", nfi));\r
- AssertEquals ("#03", "+1.00", (-1.0).ToString ("F", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test12031 () {\r
- AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("F99", _nfi)); \r
- AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("F99", _nfi)); \r
- AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("F99", _nfi)); \r
- }\r
-\r
- // Test13000- Double and G\r
- [Test]\r
- public void Test13000 () {\r
- AssertEquals ("#01", "0", 0.0.ToString ("G", _nfi));\r
- AssertEquals ("#02", "0", 0.0.ToString ("g", _nfi));\r
- AssertEquals ("#03", "-1.79769313486232E+308", Double.MinValue.ToString ("G", _nfi));\r
- AssertEquals ("#04", "-1.79769313486232e+308", Double.MinValue.ToString ("g", _nfi));\r
- AssertEquals ("#05", "1.79769313486232E+308", Double.MaxValue.ToString ("G", _nfi));\r
- AssertEquals ("#06", "1.79769313486232e+308", Double.MaxValue.ToString ("g", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13001 () {\r
- AssertEquals ("#01", "G ", 0.0.ToString ("G ", _nfi));\r
- AssertEquals ("#02", " G", 0.0.ToString (" G", _nfi));\r
- AssertEquals ("#03", " G ", 0.0.ToString (" G ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13002 () {\r
- AssertEquals ("#01", "-G ", (-1.0).ToString ("G ", _nfi));\r
- AssertEquals ("#02", "- G", (-1.0).ToString (" G", _nfi));\r
- AssertEquals ("#03", "- G ", (-1.0).ToString (" G ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13003 () {\r
- AssertEquals ("#01", "0", 0.0.ToString ("G0", _nfi));\r
- AssertEquals ("#02", "0", 0.0.ToString ("G16", _nfi));\r
- AssertEquals ("#03", "0", 0.0.ToString ("G17", _nfi));\r
- AssertEquals ("#04", "0", 0.0.ToString ("G99", _nfi));\r
- AssertEquals ("#05", "G100", 0.0.ToString ("G100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13004 () {\r
- AssertEquals ("#01", "1.79769313486232E+308", Double.MaxValue.ToString ("G0", _nfi));\r
- AssertEquals ("#02", "1.797693134862316E+308", Double.MaxValue.ToString ("G16", _nfi));\r
- AssertEquals ("#03", "1.7976931348623157E+308", Double.MaxValue.ToString ("G17", _nfi));\r
- AssertEquals ("#04", "1.7976931348623157E+308", Double.MaxValue.ToString ("G99", _nfi));\r
- AssertEquals ("#05", "G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13005 () {\r
- AssertEquals ("#01", "-1.79769313486232E+308", Double.MinValue.ToString ("G0", _nfi));\r
- AssertEquals ("#02", "-1.797693134862316E+308", Double.MinValue.ToString ("G16", _nfi));\r
- AssertEquals ("#03", "-1.7976931348623157E+308", Double.MinValue.ToString ("G17", _nfi));\r
- AssertEquals ("#04", "-1.7976931348623157E+308", Double.MinValue.ToString ("G99", _nfi));\r
- AssertEquals ("#05", "-G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13006 () {\r
- AssertEquals ("#01", "GF", 0.0.ToString ("GF", _nfi));\r
- AssertEquals ("#02", "G0F", 0.0.ToString ("G0F", _nfi));\r
- AssertEquals ("#03", "G0xF", 0.0.ToString ("G0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13007 () {\r
- AssertEquals ("#01", "GF", Double.MaxValue.ToString ("GF", _nfi));\r
- AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("G0F", _nfi));\r
- AssertEquals ("#03", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("G0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13008 () {\r
- AssertEquals ("#01", "-GF", Double.MinValue.ToString ("GF", _nfi));\r
- AssertEquals ("#02", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("G0F", _nfi));\r
- AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("G0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13009 () {\r
- AssertEquals ("#01", "0", 0.0.ToString ("G0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#02", "1.7976931348623157E+308", Double.MaxValue.ToString ("G0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#03", "-1.7976931348623157E+308", Double.MinValue.ToString ("G0000000000000000000000000000000000000017", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13010 () {\r
- AssertEquals ("#01", "+G", 0.0.ToString ("+G", _nfi));\r
- AssertEquals ("#02", "G+", 0.0.ToString ("G+", _nfi));\r
- AssertEquals ("#03", "+G+", 0.0.ToString ("+G+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test13011 () {\r
- AssertEquals ("#01", "+G", Double.MaxValue.ToString ("+G", _nfi));\r
- AssertEquals ("#02", "G+", Double.MaxValue.ToString ("G+", _nfi));\r
- AssertEquals ("#03", "+G+", Double.MaxValue.ToString ("+G+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13012 () {\r
- AssertEquals ("#01", "-+G", Double.MinValue.ToString ("+G", _nfi));\r
- AssertEquals ("#02", "-G+", Double.MinValue.ToString ("G+", _nfi));\r
- AssertEquals ("#03", "-+G+", Double.MinValue.ToString ("+G+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13013 () {\r
- AssertEquals ("#01", "-G", 0.0.ToString ("-G", _nfi));\r
- AssertEquals ("#02", "G-", 0.0.ToString ("G-", _nfi));\r
- AssertEquals ("#03", "-G-", 0.0.ToString ("-G-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test13014 () {\r
- AssertEquals ("#01", "-G", Double.MaxValue.ToString ("-G", _nfi));\r
- AssertEquals ("#02", "G-", Double.MaxValue.ToString ("G-", _nfi));\r
- AssertEquals ("#03", "-G-", Double.MaxValue.ToString ("-G-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13015 () {\r
- AssertEquals ("#01", "--G", Double.MinValue.ToString ("-G", _nfi));\r
- AssertEquals ("#02", "-G-", Double.MinValue.ToString ("G-", _nfi));\r
- AssertEquals ("#03", "--G-", Double.MinValue.ToString ("-G-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13016 () {\r
- AssertEquals ("#01", "G+0", 0.0.ToString ("G+0", _nfi));\r
- AssertEquals ("#02", "G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G+0", _nfi));\r
- AssertEquals ("#03", "-G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13017 () {\r
- AssertEquals ("#01", "G+9", 0.0.ToString ("G+9", _nfi));\r
- AssertEquals ("#02", "G+9", Double.MaxValue.ToString ("G+9", _nfi));\r
- AssertEquals ("#03", "-G+9", Double.MinValue.ToString ("G+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13018 () {\r
- AssertEquals ("#01", "G-9", 0.0.ToString ("G-9", _nfi));\r
- AssertEquals ("#02", "G-9", Double.MaxValue.ToString ("G-9", _nfi));\r
- AssertEquals ("#03", "-G-9", Double.MinValue.ToString ("G-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13019 () {\r
- AssertEquals ("#01", "G0", 0.0.ToString ("G0,", _nfi));\r
- AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0,", _nfi));\r
- AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13020 () {\r
- AssertEquals ("#01", "G0", 0.0.ToString ("G0.", _nfi));\r
- AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0.", _nfi));\r
- AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13021 () {\r
- AssertEquals ("#01", "G0.0", 0.0.ToString ("G0.0", _nfi));\r
- AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("G0.0", _nfi));\r
- AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("G0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13022 () {\r
- AssertEquals ("#01", "G09", 0.0.ToString ("G0.9", _nfi));\r
- AssertEquals ("#02", "G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("G0.9", _nfi));\r
- AssertEquals ("#03", "-G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("G0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13023 () {\r
- AssertEquals ("#01", "0.5", 0.5.ToString ("G1", _nfi));\r
- AssertEquals ("#02", "2", 1.5.ToString ("G1", _nfi));\r
- AssertEquals ("#03", "3", 2.5.ToString ("G1", _nfi));\r
- AssertEquals ("#04", "4", 3.5.ToString ("G1", _nfi));\r
- AssertEquals ("#05", "5", 4.5.ToString ("G1", _nfi));\r
- AssertEquals ("#06", "6", 5.5.ToString ("G1", _nfi));\r
- AssertEquals ("#07", "7", 6.5.ToString ("G1", _nfi));\r
- AssertEquals ("#08", "8", 7.5.ToString ("G1", _nfi));\r
- AssertEquals ("#09", "9", 8.5.ToString ("G1", _nfi));\r
- AssertEquals ("#10", "1E+01", 9.5.ToString ("G1", _nfi));\r
- }\r
-
- [Test]\r
+//
+// MonoTests.System.NumberFormatterTest
+//
+// Authors:
+// akiramei (mei@work.email.ne.jp)
+//
+// (C) 2005 akiramei
+//
+
+using System;
+using System.Globalization;
+using System.Threading;
+
+using NUnit.Framework;
+
+namespace MonoTests.System
+{
+ [TestFixture]
+ public class NumberFormatterTest
+ {
+ CultureInfo old_culture;
+ NumberFormatInfo _nfi;
+
+ [SetUp]
+ public void SetUp ()
+ {
+ old_culture = Thread.CurrentThread.CurrentCulture;
+ Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
+ _nfi = NumberFormatInfo.InvariantInfo.Clone () as NumberFormatInfo;
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ Thread.CurrentThread.CurrentCulture = old_culture;
+ }
+
+ // Test00000- Int32 and D
+ [Test]
+ public void Test00000 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("D", _nfi), "#01");
+ Assert.AreEqual ("0", 0.ToString ("d", _nfi), "#02");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("D", _nfi), "#03");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("d", _nfi), "#04");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("D", _nfi), "#05");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("d", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test00001 ()
+ {
+ Assert.AreEqual ("D ", 0.ToString ("D ", _nfi), "#01");
+ Assert.AreEqual (" D", 0.ToString (" D", _nfi), "#02");
+ Assert.AreEqual (" D ", 0.ToString (" D ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00002 ()
+ {
+ Assert.AreEqual ("-D ", (-1).ToString ("D ", _nfi), "#01");
+ Assert.AreEqual ("- D", (-1).ToString (" D", _nfi), "#02");
+ Assert.AreEqual ("- D ", (-1).ToString (" D ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00003 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("D0", _nfi), "#01");
+ Assert.AreEqual ("0000000000", 0.ToString ("D10", _nfi), "#02");
+ Assert.AreEqual ("00000000000", 0.ToString ("D11", _nfi), "#03");
+ Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("D99", _nfi), "#04");
+ Assert.AreEqual ("D100", 0.ToString ("D100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test00004 ()
+ {
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("D0", _nfi), "#01");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("D10", _nfi), "#02");
+ Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("D11", _nfi), "#03");
+ Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483647", Int32.MaxValue.ToString ("D99", _nfi), "#04");
+ Assert.AreEqual ("D12147483647", Int32.MaxValue.ToString ("D100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test00005 ()
+ {
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("D0", _nfi), "#01");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("D10", _nfi), "#02");
+ Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("D11", _nfi), "#03");
+ Assert.AreEqual ("-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483648", Int32.MinValue.ToString ("D99", _nfi), "#04");
+ Assert.AreEqual ("-D12147483648", Int32.MinValue.ToString ("D100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test00006 ()
+ {
+ Assert.AreEqual ("DF", 0.ToString ("DF", _nfi), "#01");
+ Assert.AreEqual ("D0F", 0.ToString ("D0F", _nfi), "#02");
+ Assert.AreEqual ("D0xF", 0.ToString ("D0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00007 ()
+ {
+ Assert.AreEqual ("DF", Int32.MaxValue.ToString ("DF", _nfi), "#01");
+ Assert.AreEqual ("D2147483647F", Int32.MaxValue.ToString ("D0F", _nfi), "#02");
+ Assert.AreEqual ("D2147483647xF", Int32.MaxValue.ToString ("D0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00008 ()
+ {
+ Assert.AreEqual ("-DF", Int32.MinValue.ToString ("DF", _nfi), "#01");
+ Assert.AreEqual ("-D2147483648F", Int32.MinValue.ToString ("D0F", _nfi), "#02");
+ Assert.AreEqual ("-D2147483648xF", Int32.MinValue.ToString ("D0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00009 ()
+ {
+ Assert.AreEqual ("00000000000", 0.ToString ("D0000000000000000000000000000000000000011", _nfi), "#01");
+ Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("D0000000000000000000000000000000000000011", _nfi), "#02");
+ Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("D0000000000000000000000000000000000000011", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00010 ()
+ {
+ Assert.AreEqual ("+D", 0.ToString ("+D", _nfi), "#01");
+ Assert.AreEqual ("D+", 0.ToString ("D+", _nfi), "#02");
+ Assert.AreEqual ("+D+", 0.ToString ("+D+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00011 ()
+ {
+ Assert.AreEqual ("+D", Int32.MaxValue.ToString ("+D", _nfi), "#01");
+ Assert.AreEqual ("D+", Int32.MaxValue.ToString ("D+", _nfi), "#02");
+ Assert.AreEqual ("+D+", Int32.MaxValue.ToString ("+D+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00012 ()
+ {
+ Assert.AreEqual ("-+D", Int32.MinValue.ToString ("+D", _nfi), "#01");
+ Assert.AreEqual ("-D+", Int32.MinValue.ToString ("D+", _nfi), "#02");
+ Assert.AreEqual ("-+D+", Int32.MinValue.ToString ("+D+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00013 ()
+ {
+ Assert.AreEqual ("-D", 0.ToString ("-D", _nfi), "#01");
+ Assert.AreEqual ("D-", 0.ToString ("D-", _nfi), "#02");
+ Assert.AreEqual ("-D-", 0.ToString ("-D-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00014 ()
+ {
+ Assert.AreEqual ("-D", Int32.MaxValue.ToString ("-D", _nfi), "#01");
+ Assert.AreEqual ("D-", Int32.MaxValue.ToString ("D-", _nfi), "#02");
+ Assert.AreEqual ("-D-", Int32.MaxValue.ToString ("-D-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00015 ()
+ {
+ Assert.AreEqual ("--D", Int32.MinValue.ToString ("-D", _nfi), "#01");
+ Assert.AreEqual ("-D-", Int32.MinValue.ToString ("D-", _nfi), "#02");
+ Assert.AreEqual ("--D-", Int32.MinValue.ToString ("-D-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00016 ()
+ {
+ Assert.AreEqual ("D+0", 0.ToString ("D+0", _nfi), "#01");
+ Assert.AreEqual ("D+2147483647", Int32.MaxValue.ToString ("D+0", _nfi), "#02");
+ Assert.AreEqual ("-D+2147483648", Int32.MinValue.ToString ("D+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00017 ()
+ {
+ Assert.AreEqual ("D+9", 0.ToString ("D+9", _nfi), "#01");
+ Assert.AreEqual ("D+9", Int32.MaxValue.ToString ("D+9", _nfi), "#02");
+ Assert.AreEqual ("-D+9", Int32.MinValue.ToString ("D+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00018 ()
+ {
+ Assert.AreEqual ("D-9", 0.ToString ("D-9", _nfi), "#01");
+ Assert.AreEqual ("D-9", Int32.MaxValue.ToString ("D-9", _nfi), "#02");
+ Assert.AreEqual ("-D-9", Int32.MinValue.ToString ("D-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00019 ()
+ {
+ Assert.AreEqual ("D0", 0.ToString ("D0,", _nfi), "#01");
+ Assert.AreEqual ("D2147484", Int32.MaxValue.ToString ("D0,", _nfi), "#02");
+ Assert.AreEqual ("-D2147484", Int32.MinValue.ToString ("D0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00020 ()
+ {
+ Assert.AreEqual ("D0", 0.ToString ("D0.", _nfi), "#01");
+ Assert.AreEqual ("D2147483647", Int32.MaxValue.ToString ("D0.", _nfi), "#02");
+ Assert.AreEqual ("-D2147483648", Int32.MinValue.ToString ("D0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00021 ()
+ {
+ Assert.AreEqual ("D0.0", 0.ToString ("D0.0", _nfi), "#01");
+ Assert.AreEqual ("D2147483647.0", Int32.MaxValue.ToString ("D0.0", _nfi), "#02");
+ Assert.AreEqual ("-D2147483648.0", Int32.MinValue.ToString ("D0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test00022 ()
+ {
+ Assert.AreEqual ("D09", 0.ToString ("D0.9", _nfi), "#01");
+ Assert.AreEqual ("D21474836479", Int32.MaxValue.ToString ("D0.9", _nfi), "#02");
+ Assert.AreEqual ("-D21474836489", Int32.MinValue.ToString ("D0.9", _nfi), "#03");
+ }
+
+ // Test01000- Int32 and E
+ [Test]
+ public void Test01000 ()
+ {
+ Assert.AreEqual ("0.000000E+000", 0.ToString ("E", _nfi), "#01");
+ Assert.AreEqual ("0.000000e+000", 0.ToString ("e", _nfi), "#02");
+ Assert.AreEqual ("-2.147484E+009", Int32.MinValue.ToString ("E", _nfi), "#03");
+ Assert.AreEqual ("-2.147484e+009", Int32.MinValue.ToString ("e", _nfi), "#04");
+ Assert.AreEqual ("2.147484E+009", Int32.MaxValue.ToString ("E", _nfi), "#05");
+ Assert.AreEqual ("2.147484e+009", Int32.MaxValue.ToString ("e", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test01001 ()
+ {
+ Assert.AreEqual ("E ", 0.ToString ("E ", _nfi), "#01");
+ Assert.AreEqual (" E", 0.ToString (" E", _nfi), "#02");
+ Assert.AreEqual (" E ", 0.ToString (" E ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01002 ()
+ {
+ Assert.AreEqual ("-E ", (-1).ToString ("E ", _nfi), "#01");
+ Assert.AreEqual ("- E", (-1).ToString (" E", _nfi), "#02");
+ Assert.AreEqual ("- E ", (-1).ToString (" E ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01003 ()
+ {
+ Assert.AreEqual ("0E+000", 0.ToString ("E0", _nfi), "#01");
+ Assert.AreEqual ("0.000000000E+000", 0.ToString ("E9", _nfi), "#02");
+ Assert.AreEqual ("0.0000000000E+000", 0.ToString ("E10", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.ToString ("E99", _nfi), "#04");
+ Assert.AreEqual ("E100", 0.ToString ("E100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test01004 ()
+ {
+ Assert.AreEqual ("2E+009", Int32.MaxValue.ToString ("E0", _nfi), "#01");
+ Assert.AreEqual ("2.147483647E+009", Int32.MaxValue.ToString ("E9", _nfi), "#02");
+ Assert.AreEqual ("2.1474836470E+009", Int32.MaxValue.ToString ("E10", _nfi), "#03");
+ Assert.AreEqual ("2.147483647000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MaxValue.ToString ("E99", _nfi), "#04");
+ Assert.AreEqual ("E12147483647", Int32.MaxValue.ToString ("E100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test01005 ()
+ {
+ Assert.AreEqual ("-2E+009", Int32.MinValue.ToString ("E0", _nfi), "#01");
+ Assert.AreEqual ("-2.147483648E+009", Int32.MinValue.ToString ("E9", _nfi), "#02");
+ Assert.AreEqual ("-2.1474836480E+009", Int32.MinValue.ToString ("E10", _nfi), "#03");
+ Assert.AreEqual ("-2.147483648000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MinValue.ToString ("E99", _nfi), "#04");
+ Assert.AreEqual ("-E12147483648", Int32.MinValue.ToString ("E100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test01006 ()
+ {
+ Assert.AreEqual ("EF", 0.ToString ("EF", _nfi), "#01");
+ Assert.AreEqual ("E0F", 0.ToString ("E0F", _nfi), "#02");
+ Assert.AreEqual ("E0xF", 0.ToString ("E0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01007 ()
+ {
+ Assert.AreEqual ("EF", Int32.MaxValue.ToString ("EF", _nfi), "#01");
+ Assert.AreEqual ("E0F", Int32.MaxValue.ToString ("E0F", _nfi), "#02");
+ Assert.AreEqual ("E0xF", Int32.MaxValue.ToString ("E0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01008 ()
+ {
+ Assert.AreEqual ("-EF", Int32.MinValue.ToString ("EF", _nfi), "#01");
+ Assert.AreEqual ("E0F", Int32.MinValue.ToString ("E0F", _nfi), "#02");
+ Assert.AreEqual ("E0xF", Int32.MinValue.ToString ("E0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01009 ()
+ {
+ Assert.AreEqual ("0.0000000000E+000", 0.ToString ("E0000000000000000000000000000000000000010", _nfi), "#01");
+ Assert.AreEqual ("2.1474836470E+009", Int32.MaxValue.ToString ("E0000000000000000000000000000000000000010", _nfi), "#02");
+ Assert.AreEqual ("-2.1474836480E+009", Int32.MinValue.ToString ("E0000000000000000000000000000000000000010", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01010 ()
+ {
+ Assert.AreEqual ("+E", 0.ToString ("+E", _nfi), "#01");
+ Assert.AreEqual ("E+", 0.ToString ("E+", _nfi), "#02");
+ Assert.AreEqual ("+E+", 0.ToString ("+E+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01011 ()
+ {
+ Assert.AreEqual ("+E", Int32.MaxValue.ToString ("+E", _nfi), "#01");
+ Assert.AreEqual ("E+", Int32.MaxValue.ToString ("E+", _nfi), "#02");
+ Assert.AreEqual ("+E+", Int32.MaxValue.ToString ("+E+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01012 ()
+ {
+ Assert.AreEqual ("-+E", Int32.MinValue.ToString ("+E", _nfi), "#01");
+ Assert.AreEqual ("-E+", Int32.MinValue.ToString ("E+", _nfi), "#02");
+ Assert.AreEqual ("-+E+", Int32.MinValue.ToString ("+E+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01013 ()
+ {
+ Assert.AreEqual ("-E", 0.ToString ("-E", _nfi), "#01");
+ Assert.AreEqual ("E-", 0.ToString ("E-", _nfi), "#02");
+ Assert.AreEqual ("-E-", 0.ToString ("-E-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01014 ()
+ {
+ Assert.AreEqual ("-E", Int32.MaxValue.ToString ("-E", _nfi), "#01");
+ Assert.AreEqual ("E-", Int32.MaxValue.ToString ("E-", _nfi), "#02");
+ Assert.AreEqual ("-E-", Int32.MaxValue.ToString ("-E-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01015 ()
+ {
+ Assert.AreEqual ("--E", Int32.MinValue.ToString ("-E", _nfi), "#01");
+ Assert.AreEqual ("-E-", Int32.MinValue.ToString ("E-", _nfi), "#02");
+ Assert.AreEqual ("--E-", Int32.MinValue.ToString ("-E-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01016 ()
+ {
+ Assert.AreEqual ("E+0", 0.ToString ("E+0", _nfi), "#01");
+ Assert.AreEqual ("E+0", Int32.MaxValue.ToString ("E+0", _nfi), "#02");
+ Assert.AreEqual ("E+0", Int32.MinValue.ToString ("E+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01017 ()
+ {
+ Assert.AreEqual ("E+9", 0.ToString ("E+9", _nfi), "#01");
+ Assert.AreEqual ("E+9", Int32.MaxValue.ToString ("E+9", _nfi), "#02");
+ Assert.AreEqual ("-E+9", Int32.MinValue.ToString ("E+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01018 ()
+ {
+ Assert.AreEqual ("E-9", 0.ToString ("E-9", _nfi), "#01");
+ Assert.AreEqual ("E-9", Int32.MaxValue.ToString ("E-9", _nfi), "#02");
+ Assert.AreEqual ("-E-9", Int32.MinValue.ToString ("E-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01019 ()
+ {
+ Assert.AreEqual ("E0", 0.ToString ("E0,", _nfi), "#01");
+ Assert.AreEqual ("E0", Int32.MaxValue.ToString ("E0,", _nfi), "#02");
+ Assert.AreEqual ("E0", Int32.MinValue.ToString ("E0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01020 ()
+ {
+ Assert.AreEqual ("E0", 0.ToString ("E0.", _nfi), "#01");
+ Assert.AreEqual ("E0", Int32.MaxValue.ToString ("E0.", _nfi), "#02");
+ Assert.AreEqual ("E0", Int32.MinValue.ToString ("E0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01021 ()
+ {
+ Assert.AreEqual ("E0.0", 0.ToString ("E0.0", _nfi), "#01");
+ Assert.AreEqual ("E10.2", Int32.MaxValue.ToString ("E0.0", _nfi), "#02");
+ Assert.AreEqual ("-E10.2", Int32.MinValue.ToString ("E0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01022 ()
+ {
+ Assert.AreEqual ("E09", 0.ToString ("E0.9", _nfi), "#01");
+ Assert.AreEqual ("E09", Int32.MaxValue.ToString ("E0.9", _nfi), "#02");
+ Assert.AreEqual ("E09", Int32.MinValue.ToString ("E0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test01023 ()
+ {
+ Assert.AreEqual ("9.999999E+007", 99999990.ToString ("E", _nfi), "#01");
+ Assert.AreEqual ("9.999999E+007", 99999991.ToString ("E", _nfi), "#02");
+ Assert.AreEqual ("9.999999E+007", 99999992.ToString ("E", _nfi), "#03");
+ Assert.AreEqual ("9.999999E+007", 99999993.ToString ("E", _nfi), "#04");
+ Assert.AreEqual ("9.999999E+007", 99999994.ToString ("E", _nfi), "#05");
+ Assert.AreEqual ("1.000000E+008", 99999995.ToString ("E", _nfi), "#06");
+ Assert.AreEqual ("1.000000E+008", 99999996.ToString ("E", _nfi), "#07");
+ Assert.AreEqual ("1.000000E+008", 99999997.ToString ("E", _nfi), "#08");
+ Assert.AreEqual ("1.000000E+008", 99999998.ToString ("E", _nfi), "#09");
+ Assert.AreEqual ("1.000000E+008", 99999999.ToString ("E", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test01024 ()
+ {
+ Assert.AreEqual ("-9.999999E+007", (-99999990).ToString ("E", _nfi), "#01");
+ Assert.AreEqual ("-9.999999E+007", (-99999991).ToString ("E", _nfi), "#02");
+ Assert.AreEqual ("-9.999999E+007", (-99999992).ToString ("E", _nfi), "#03");
+ Assert.AreEqual ("-9.999999E+007", (-99999993).ToString ("E", _nfi), "#04");
+ Assert.AreEqual ("-9.999999E+007", (-99999994).ToString ("E", _nfi), "#05");
+ Assert.AreEqual ("-1.000000E+008", (-99999995).ToString ("E", _nfi), "#06");
+ Assert.AreEqual ("-1.000000E+008", (-99999996).ToString ("E", _nfi), "#07");
+ Assert.AreEqual ("-1.000000E+008", (-99999997).ToString ("E", _nfi), "#08");
+ Assert.AreEqual ("-1.000000E+008", (-99999998).ToString ("E", _nfi), "#09");
+ Assert.AreEqual ("-1.000000E+008", (-99999999).ToString ("E", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test01025 ()
+ {
+ Assert.AreEqual ("9.999998E+007", 99999980.ToString ("E", _nfi), "#01");
+ Assert.AreEqual ("9.999998E+007", 99999981.ToString ("E", _nfi), "#02");
+ Assert.AreEqual ("9.999998E+007", 99999982.ToString ("E", _nfi), "#03");
+ Assert.AreEqual ("9.999998E+007", 99999983.ToString ("E", _nfi), "#04");
+ Assert.AreEqual ("9.999998E+007", 99999984.ToString ("E", _nfi), "#05");
+ Assert.AreEqual ("9.999999E+007", 99999985.ToString ("E", _nfi), "#06");
+ Assert.AreEqual ("9.999999E+007", 99999986.ToString ("E", _nfi), "#07");
+ Assert.AreEqual ("9.999999E+007", 99999987.ToString ("E", _nfi), "#08");
+ Assert.AreEqual ("9.999999E+007", 99999988.ToString ("E", _nfi), "#09");
+ Assert.AreEqual ("9.999999E+007", 99999989.ToString ("E", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test01026 ()
+ {
+ Assert.AreEqual ("-9.999998E+007", (-99999980).ToString ("E", _nfi), "#01");
+ Assert.AreEqual ("-9.999998E+007", (-99999981).ToString ("E", _nfi), "#02");
+ Assert.AreEqual ("-9.999998E+007", (-99999982).ToString ("E", _nfi), "#03");
+ Assert.AreEqual ("-9.999998E+007", (-99999983).ToString ("E", _nfi), "#04");
+ Assert.AreEqual ("-9.999998E+007", (-99999984).ToString ("E", _nfi), "#05");
+ Assert.AreEqual ("-9.999999E+007", (-99999985).ToString ("E", _nfi), "#06");
+ Assert.AreEqual ("-9.999999E+007", (-99999986).ToString ("E", _nfi), "#07");
+ Assert.AreEqual ("-9.999999E+007", (-99999987).ToString ("E", _nfi), "#08");
+ Assert.AreEqual ("-9.999999E+007", (-99999988).ToString ("E", _nfi), "#09");
+ Assert.AreEqual ("-9.999999E+007", (-99999989).ToString ("E", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test01027 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("-1#000000E+008", (-99999999).ToString ("E", nfi), "#01");
+ }
+
+ [Test]
+ public void Test01028 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+
+ Assert.AreEqual ("1.000000E-000", 1.ToString ("E", nfi), "#01");
+ Assert.AreEqual ("0.000000E-000", 0.ToString ("E", nfi), "#02");
+ Assert.AreEqual ("+1.000000E-000", (-1).ToString ("E", nfi), "#03");
+ }
+
+ // Test02000- Int32 and F
+ [Test]
+ public void Test02000 ()
+ {
+ Assert.AreEqual ("0.00", 0.ToString ("F", _nfi), "#01");
+ Assert.AreEqual ("0.00", 0.ToString ("f", _nfi), "#02");
+ Assert.AreEqual ("-2147483648.00", Int32.MinValue.ToString ("F", _nfi), "#03");
+ Assert.AreEqual ("-2147483648.00", Int32.MinValue.ToString ("f", _nfi), "#04");
+ Assert.AreEqual ("2147483647.00", Int32.MaxValue.ToString ("F", _nfi), "#05");
+ Assert.AreEqual ("2147483647.00", Int32.MaxValue.ToString ("f", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test02001 ()
+ {
+ Assert.AreEqual ("F ", 0.ToString ("F ", _nfi), "#01");
+ Assert.AreEqual (" F", 0.ToString (" F", _nfi), "#02");
+ Assert.AreEqual (" F ", 0.ToString (" F ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02002 ()
+ {
+ Assert.AreEqual ("-F ", (-1).ToString ("F ", _nfi), "#01");
+ Assert.AreEqual ("- F", (-1).ToString (" F", _nfi), "#02");
+ Assert.AreEqual ("- F ", (-1).ToString (" F ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02003 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("F0", _nfi), "#01");
+ Assert.AreEqual ("0.000000000", 0.ToString ("F9", _nfi), "#02");
+ Assert.AreEqual ("0.0000000000", 0.ToString ("F10", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F99", _nfi), "#04");
+ Assert.AreEqual ("F100", 0.ToString ("F100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test02004 ()
+ {
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("F0", _nfi), "#01");
+ Assert.AreEqual ("2147483647.000000000", Int32.MaxValue.ToString ("F9", _nfi), "#02");
+ Assert.AreEqual ("2147483647.0000000000", Int32.MaxValue.ToString ("F10", _nfi), "#03");
+ Assert.AreEqual ("2147483647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("F99", _nfi), "#04");
+ Assert.AreEqual ("F12147483647", Int32.MaxValue.ToString ("F100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test02005 ()
+ {
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("F0", _nfi), "#01");
+ Assert.AreEqual ("-2147483648.000000000", Int32.MinValue.ToString ("F9", _nfi), "#02");
+ Assert.AreEqual ("-2147483648.0000000000", Int32.MinValue.ToString ("F10", _nfi), "#03");
+ Assert.AreEqual ("-2147483648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("F99", _nfi), "#04");
+ Assert.AreEqual ("-F12147483648", Int32.MinValue.ToString ("F100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test02006 ()
+ {
+ Assert.AreEqual ("FF", 0.ToString ("FF", _nfi), "#01");
+ Assert.AreEqual ("F0F", 0.ToString ("F0F", _nfi), "#02");
+ Assert.AreEqual ("F0xF", 0.ToString ("F0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02007 ()
+ {
+ Assert.AreEqual ("FF", Int32.MaxValue.ToString ("FF", _nfi), "#01");
+ Assert.AreEqual ("F2147483647F", Int32.MaxValue.ToString ("F0F", _nfi), "#02");
+ Assert.AreEqual ("F2147483647xF", Int32.MaxValue.ToString ("F0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02008 ()
+ {
+ Assert.AreEqual ("-FF", Int32.MinValue.ToString ("FF", _nfi), "#01");
+ Assert.AreEqual ("-F2147483648F", Int32.MinValue.ToString ("F0F", _nfi), "#02");
+ Assert.AreEqual ("-F2147483648xF", Int32.MinValue.ToString ("F0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02009 ()
+ {
+ Assert.AreEqual ("0.0000000000", 0.ToString ("F0000000000000000000000000000000000000010", _nfi), "#01");
+ Assert.AreEqual ("2147483647.0000000000", Int32.MaxValue.ToString ("F0000000000000000000000000000000000000010", _nfi), "#02");
+ Assert.AreEqual ("-2147483648.0000000000", Int32.MinValue.ToString ("F0000000000000000000000000000000000000010", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02010 ()
+ {
+ Assert.AreEqual ("+F", 0.ToString ("+F", _nfi), "#01");
+ Assert.AreEqual ("F+", 0.ToString ("F+", _nfi), "#02");
+ Assert.AreEqual ("+F+", 0.ToString ("+F+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02011 ()
+ {
+ Assert.AreEqual ("+F", Int32.MaxValue.ToString ("+F", _nfi), "#01");
+ Assert.AreEqual ("F+", Int32.MaxValue.ToString ("F+", _nfi), "#02");
+ Assert.AreEqual ("+F+", Int32.MaxValue.ToString ("+F+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02012 ()
+ {
+ Assert.AreEqual ("-+F", Int32.MinValue.ToString ("+F", _nfi), "#01");
+ Assert.AreEqual ("-F+", Int32.MinValue.ToString ("F+", _nfi), "#02");
+ Assert.AreEqual ("-+F+", Int32.MinValue.ToString ("+F+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02013 ()
+ {
+ Assert.AreEqual ("-F", 0.ToString ("-F", _nfi), "#01");
+ Assert.AreEqual ("F-", 0.ToString ("F-", _nfi), "#02");
+ Assert.AreEqual ("-F-", 0.ToString ("-F-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02014 ()
+ {
+ Assert.AreEqual ("-F", Int32.MaxValue.ToString ("-F", _nfi), "#01");
+ Assert.AreEqual ("F-", Int32.MaxValue.ToString ("F-", _nfi), "#02");
+ Assert.AreEqual ("-F-", Int32.MaxValue.ToString ("-F-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02015 ()
+ {
+ Assert.AreEqual ("--F", Int32.MinValue.ToString ("-F", _nfi), "#01");
+ Assert.AreEqual ("-F-", Int32.MinValue.ToString ("F-", _nfi), "#02");
+ Assert.AreEqual ("--F-", Int32.MinValue.ToString ("-F-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02016 ()
+ {
+ Assert.AreEqual ("F+0", 0.ToString ("F+0", _nfi), "#01");
+ Assert.AreEqual ("F+2147483647", Int32.MaxValue.ToString ("F+0", _nfi), "#02");
+ Assert.AreEqual ("-F+2147483648", Int32.MinValue.ToString ("F+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02017 ()
+ {
+ Assert.AreEqual ("F+9", 0.ToString ("F+9", _nfi), "#01");
+ Assert.AreEqual ("F+9", Int32.MaxValue.ToString ("F+9", _nfi), "#02");
+ Assert.AreEqual ("-F+9", Int32.MinValue.ToString ("F+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02018 ()
+ {
+ Assert.AreEqual ("F-9", 0.ToString ("F-9", _nfi), "#01");
+ Assert.AreEqual ("F-9", Int32.MaxValue.ToString ("F-9", _nfi), "#02");
+ Assert.AreEqual ("-F-9", Int32.MinValue.ToString ("F-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02019 ()
+ {
+ Assert.AreEqual ("F0", 0.ToString ("F0,", _nfi), "#01");
+ Assert.AreEqual ("F2147484", Int32.MaxValue.ToString ("F0,", _nfi), "#02");
+ Assert.AreEqual ("-F2147484", Int32.MinValue.ToString ("F0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02020 ()
+ {
+ Assert.AreEqual ("F0", 0.ToString ("F0.", _nfi), "#01");
+ Assert.AreEqual ("F2147483647", Int32.MaxValue.ToString ("F0.", _nfi), "#02");
+ Assert.AreEqual ("-F2147483648", Int32.MinValue.ToString ("F0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02021 ()
+ {
+ Assert.AreEqual ("F0.0", 0.ToString ("F0.0", _nfi), "#01");
+ Assert.AreEqual ("F2147483647.0", Int32.MaxValue.ToString ("F0.0", _nfi), "#02");
+ Assert.AreEqual ("-F2147483648.0", Int32.MinValue.ToString ("F0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02022 ()
+ {
+ Assert.AreEqual ("F09", 0.ToString ("F0.9", _nfi), "#01");
+ Assert.AreEqual ("F21474836479", Int32.MaxValue.ToString ("F0.9", _nfi), "#02");
+ Assert.AreEqual ("-F21474836489", Int32.MinValue.ToString ("F0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test02023 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalDigits = 0;
+ Assert.AreEqual ("0", 0.ToString ("F", nfi), "#01");
+ nfi.NumberDecimalDigits = 1;
+ Assert.AreEqual ("0.0", 0.ToString ("F", nfi), "#02");
+ nfi.NumberDecimalDigits = 99;
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F", nfi), "#03");
+ }
+
+ [Test]
+ public void Test02024 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "";
+ Assert.AreEqual ("2147483648.00", Int32.MinValue.ToString ("F", nfi), "#01");
+ nfi.NegativeSign = "-";
+ Assert.AreEqual ("-2147483648.00", Int32.MinValue.ToString ("F", nfi), "#02");
+ nfi.NegativeSign = "+";
+ Assert.AreEqual ("+2147483648.00", Int32.MinValue.ToString ("F", nfi), "#03");
+ nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648.00", Int32.MinValue.ToString ("F", nfi), "#04");
+ }
+
+ [Test]
+ public void Test02025 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "-";
+ nfi.PositiveSign = "+";
+ Assert.AreEqual ("-1.00", (-1).ToString ("F", nfi), "#01");
+ Assert.AreEqual ("0.00", 0.ToString ("F", nfi), "#02");
+ Assert.AreEqual ("1.00",1.ToString ("F", nfi), "#03");
+ }
+
+ [Test]
+ public void Test02026 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+ Assert.AreEqual ("+1.00", (-1).ToString ("F", nfi), "#01");
+ Assert.AreEqual ("0.00", 0.ToString ("F", nfi), "#02");
+ Assert.AreEqual ("1.00",1.ToString ("F", nfi), "#03");
+ }
+
+ [Test]
+ public void Test02027 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("1#00",1.ToString ("F", nfi), "#01");
+ }
+
+ // Test03000 - Int32 and G
+ [Test]
+ public void Test03000 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("G", _nfi), "#01");
+ Assert.AreEqual ("0", 0.ToString ("g", _nfi), "#02");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G", _nfi), "#03");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("g", _nfi), "#04");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G", _nfi), "#05");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("g", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test03001 ()
+ {
+ Assert.AreEqual ("G ", 0.ToString ("G ", _nfi), "#01");
+ Assert.AreEqual (" G", 0.ToString (" G", _nfi), "#02");
+ Assert.AreEqual (" G ", 0.ToString (" G ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03002 ()
+ {
+ Assert.AreEqual ("-G ", (-1).ToString ("G ", _nfi), "#01");
+ Assert.AreEqual ("- G", (-1).ToString (" G", _nfi), "#02");
+ Assert.AreEqual ("- G ", (-1).ToString (" G ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03003 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("G0", _nfi), "#01");
+ Assert.AreEqual ("0", 0.ToString ("G9", _nfi), "#02");
+ Assert.AreEqual ("0", 0.ToString ("G10", _nfi), "#03");
+ Assert.AreEqual ("0", 0.ToString ("G99", _nfi), "#04");
+ Assert.AreEqual ("G100", 0.ToString ("G100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test03004 ()
+ {
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G0", _nfi), "#01");
+ Assert.AreEqual ("2.14748365E+09", Int32.MaxValue.ToString ("G9", _nfi), "#02");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G10", _nfi), "#03");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G99", _nfi), "#04");
+ Assert.AreEqual ("G12147483647", Int32.MaxValue.ToString ("G100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test03005 ()
+ {
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G0", _nfi), "#01");
+ Assert.AreEqual ("-2.14748365E+09", Int32.MinValue.ToString ("G9", _nfi), "#02");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G10", _nfi), "#03");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G99", _nfi), "#04");
+ Assert.AreEqual ("-G12147483648", Int32.MinValue.ToString ("G100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test03006 ()
+ {
+ Assert.AreEqual ("GF", 0.ToString ("GF", _nfi), "#01");
+ Assert.AreEqual ("G0F", 0.ToString ("G0F", _nfi), "#02");
+ Assert.AreEqual ("G0xF", 0.ToString ("G0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03007 ()
+ {
+ Assert.AreEqual ("GF", Int32.MaxValue.ToString ("GF", _nfi), "#01");
+ Assert.AreEqual ("G2147483647F", Int32.MaxValue.ToString ("G0F", _nfi), "#02");
+ Assert.AreEqual ("G2147483647xF", Int32.MaxValue.ToString ("G0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03008 ()
+ {
+ Assert.AreEqual ("-GF", Int32.MinValue.ToString ("GF", _nfi), "#01");
+ Assert.AreEqual ("-G2147483648F", Int32.MinValue.ToString ("G0F", _nfi), "#02");
+ Assert.AreEqual ("-G2147483648xF", Int32.MinValue.ToString ("G0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03009 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("G0000000000000000000000000000000000000010", _nfi), "#01");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G0000000000000000000000000000000000000010", _nfi), "#02");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G0000000000000000000000000000000000000010", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03010 ()
+ {
+ Assert.AreEqual ("+G", 0.ToString ("+G", _nfi), "#01");
+ Assert.AreEqual ("G+", 0.ToString ("G+", _nfi), "#02");
+ Assert.AreEqual ("+G+", 0.ToString ("+G+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03011 ()
+ {
+ Assert.AreEqual ("+G", Int32.MaxValue.ToString ("+G", _nfi), "#01");
+ Assert.AreEqual ("G+", Int32.MaxValue.ToString ("G+", _nfi), "#02");
+ Assert.AreEqual ("+G+", Int32.MaxValue.ToString ("+G+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03012 ()
+ {
+ Assert.AreEqual ("-+G", Int32.MinValue.ToString ("+G", _nfi), "#01");
+ Assert.AreEqual ("-G+", Int32.MinValue.ToString ("G+", _nfi), "#02");
+ Assert.AreEqual ("-+G+", Int32.MinValue.ToString ("+G+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03013 ()
+ {
+ Assert.AreEqual ("-G", 0.ToString ("-G", _nfi), "#01");
+ Assert.AreEqual ("G-", 0.ToString ("G-", _nfi), "#02");
+ Assert.AreEqual ("-G-", 0.ToString ("-G-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03014 ()
+ {
+ Assert.AreEqual ("-G", Int32.MaxValue.ToString ("-G", _nfi), "#01");
+ Assert.AreEqual ("G-", Int32.MaxValue.ToString ("G-", _nfi), "#02");
+ Assert.AreEqual ("-G-", Int32.MaxValue.ToString ("-G-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03015 ()
+ {
+ Assert.AreEqual ("--G", Int32.MinValue.ToString ("-G", _nfi), "#01");
+ Assert.AreEqual ("-G-", Int32.MinValue.ToString ("G-", _nfi), "#02");
+ Assert.AreEqual ("--G-", Int32.MinValue.ToString ("-G-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03016 ()
+ {
+ Assert.AreEqual ("G+0", 0.ToString ("G+0", _nfi), "#01");
+ Assert.AreEqual ("G+2147483647", Int32.MaxValue.ToString ("G+0", _nfi), "#02");
+ Assert.AreEqual ("-G+2147483648", Int32.MinValue.ToString ("G+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03017 ()
+ {
+ Assert.AreEqual ("G+9", 0.ToString ("G+9", _nfi), "#01");
+ Assert.AreEqual ("G+9", Int32.MaxValue.ToString ("G+9", _nfi), "#02");
+ Assert.AreEqual ("-G+9", Int32.MinValue.ToString ("G+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03018 ()
+ {
+ Assert.AreEqual ("G-9", 0.ToString ("G-9", _nfi), "#01");
+ Assert.AreEqual ("G-9", Int32.MaxValue.ToString ("G-9", _nfi), "#02");
+ Assert.AreEqual ("-G-9", Int32.MinValue.ToString ("G-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03019 ()
+ {
+ Assert.AreEqual ("G0", 0.ToString ("G0,", _nfi), "#01");
+ Assert.AreEqual ("G2147484", Int32.MaxValue.ToString ("G0,", _nfi), "#02");
+ Assert.AreEqual ("-G2147484", Int32.MinValue.ToString ("G0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03020 ()
+ {
+ Assert.AreEqual ("G0", 0.ToString ("G0.", _nfi), "#01");
+ Assert.AreEqual ("G2147483647", Int32.MaxValue.ToString ("G0.", _nfi), "#02");
+ Assert.AreEqual ("-G2147483648", Int32.MinValue.ToString ("G0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03021 ()
+ {
+ Assert.AreEqual ("G0.0", 0.ToString ("G0.0", _nfi), "#01");
+ Assert.AreEqual ("G2147483647.0", Int32.MaxValue.ToString ("G0.0", _nfi), "#02");
+ Assert.AreEqual ("-G2147483648.0", Int32.MinValue.ToString ("G0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03022 ()
+ {
+ Assert.AreEqual ("G09", 0.ToString ("G0.9", _nfi), "#01");
+ Assert.AreEqual ("G21474836479", Int32.MaxValue.ToString ("G0.9", _nfi), "#02");
+ Assert.AreEqual ("-G21474836489", Int32.MinValue.ToString ("G0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test03023 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalDigits = 0;
+ Assert.AreEqual ("0", 0.ToString ("G", nfi), "#01");
+ nfi.NumberDecimalDigits = 1;
+ Assert.AreEqual ("0", 0.ToString ("G", nfi), "#02");
+ nfi.NumberDecimalDigits = 99;
+ Assert.AreEqual ("0", 0.ToString ("G", nfi), "#03");
+ }
+
+ [Test]
+ public void Test03024 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "";
+ Assert.AreEqual ("2147483648", Int32.MinValue.ToString ("G", nfi), "#01");
+ nfi.NegativeSign = "-";
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G", nfi), "#02");
+ nfi.NegativeSign = "+";
+ Assert.AreEqual ("+2147483648", Int32.MinValue.ToString ("G", nfi), "#03");
+ nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648", Int32.MinValue.ToString ("G", nfi), "#04");
+ }
+
+ [Test]
+ public void Test03025 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "-";
+ nfi.PositiveSign = "+";
+ Assert.AreEqual ("-1", (-1).ToString ("G", nfi), "#01");
+ Assert.AreEqual ("0", 0.ToString ("G", nfi), "#02");
+ Assert.AreEqual ("1",1.ToString ("G", nfi), "#03");
+ }
+
+ [Test]
+ public void Test03026 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+ Assert.AreEqual ("+1", (-1).ToString ("G", nfi), "#01");
+ Assert.AreEqual ("0", 0.ToString ("G", nfi), "#02");
+ Assert.AreEqual ("1",1.ToString ("G", nfi), "#03");
+ }
+
+ [Test]
+ public void Test03027 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("1#2E+02",123.ToString ("G2", nfi), "#01");
+ }
+
+ // Test04000 - Int32 and N
+ [Test]
+ public void Test04000 ()
+ {
+ Assert.AreEqual ("0.00", 0.ToString ("N", _nfi), "#01");
+ Assert.AreEqual ("0.00", 0.ToString ("n", _nfi), "#02");
+ Assert.AreEqual ("-2,147,483,648.00", Int32.MinValue.ToString ("N", _nfi), "#03");
+ Assert.AreEqual ("-2,147,483,648.00", Int32.MinValue.ToString ("n", _nfi), "#04");
+ Assert.AreEqual ("2,147,483,647.00", Int32.MaxValue.ToString ("N", _nfi), "#05");
+ Assert.AreEqual ("2,147,483,647.00", Int32.MaxValue.ToString ("n", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test04001 ()
+ {
+ Assert.AreEqual ("N ", 0.ToString ("N ", _nfi), "#01");
+ Assert.AreEqual (" N", 0.ToString (" N", _nfi), "#02");
+ Assert.AreEqual (" N ", 0.ToString (" N ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04002 ()
+ {
+ Assert.AreEqual ("-N ", (-1).ToString ("N ", _nfi), "#01");
+ Assert.AreEqual ("- N", (-1).ToString (" N", _nfi), "#02");
+ Assert.AreEqual ("- N ", (-1).ToString (" N ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04003 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("0.000000000", 0.ToString ("N9", _nfi), "#02");
+ Assert.AreEqual ("0.0000000000", 0.ToString ("N10", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N99", _nfi), "#04");
+ Assert.AreEqual ("N100", 0.ToString ("N100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test04004 ()
+ {
+ Assert.AreEqual ("2,147,483,647", Int32.MaxValue.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("2,147,483,647.000000000", Int32.MaxValue.ToString ("N9", _nfi), "#02");
+ Assert.AreEqual ("2,147,483,647.0000000000", Int32.MaxValue.ToString ("N10", _nfi), "#03");
+ Assert.AreEqual ("2,147,483,647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("N99", _nfi), "#04");
+ Assert.AreEqual ("N12147483647", Int32.MaxValue.ToString ("N100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test04005 ()
+ {
+ Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("-2,147,483,648.000000000", Int32.MinValue.ToString ("N9", _nfi), "#02");
+ Assert.AreEqual ("-2,147,483,648.0000000000", Int32.MinValue.ToString ("N10", _nfi), "#03");
+ Assert.AreEqual ("-2,147,483,648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("N99", _nfi), "#04");
+ Assert.AreEqual ("-N12147483648", Int32.MinValue.ToString ("N100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test04006 ()
+ {
+ Assert.AreEqual ("NF", 0.ToString ("NF", _nfi), "#01");
+ Assert.AreEqual ("N0F", 0.ToString ("N0F", _nfi), "#02");
+ Assert.AreEqual ("N0xF", 0.ToString ("N0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04007 ()
+ {
+ Assert.AreEqual ("NF", Int32.MaxValue.ToString ("NF", _nfi), "#01");
+ Assert.AreEqual ("N2147483647F", Int32.MaxValue.ToString ("N0F", _nfi), "#02");
+ Assert.AreEqual ("N2147483647xF", Int32.MaxValue.ToString ("N0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04008 ()
+ {
+ Assert.AreEqual ("-NF", Int32.MinValue.ToString ("NF", _nfi), "#01");
+ Assert.AreEqual ("-N2147483648F", Int32.MinValue.ToString ("N0F", _nfi), "#02");
+ Assert.AreEqual ("-N2147483648xF", Int32.MinValue.ToString ("N0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04009 ()
+ {
+ Assert.AreEqual ("0.0000000000", 0.ToString ("N0000000000000000000000000000000000000010", _nfi), "#01");
+ Assert.AreEqual ("2,147,483,647.0000000000", Int32.MaxValue.ToString ("N0000000000000000000000000000000000000010", _nfi), "#02");
+ Assert.AreEqual ("-2,147,483,648.0000000000", Int32.MinValue.ToString ("N0000000000000000000000000000000000000010", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04010 ()
+ {
+ Assert.AreEqual ("+N", 0.ToString ("+N", _nfi), "#01");
+ Assert.AreEqual ("N+", 0.ToString ("N+", _nfi), "#02");
+ Assert.AreEqual ("+N+", 0.ToString ("+N+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04011 ()
+ {
+ Assert.AreEqual ("+N", Int32.MaxValue.ToString ("+N", _nfi), "#01");
+ Assert.AreEqual ("N+", Int32.MaxValue.ToString ("N+", _nfi), "#02");
+ Assert.AreEqual ("+N+", Int32.MaxValue.ToString ("+N+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04012 ()
+ {
+ Assert.AreEqual ("-+N", Int32.MinValue.ToString ("+N", _nfi), "#01");
+ Assert.AreEqual ("-N+", Int32.MinValue.ToString ("N+", _nfi), "#02");
+ Assert.AreEqual ("-+N+", Int32.MinValue.ToString ("+N+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04013 ()
+ {
+ Assert.AreEqual ("-N", 0.ToString ("-N", _nfi), "#01");
+ Assert.AreEqual ("N-", 0.ToString ("N-", _nfi), "#02");
+ Assert.AreEqual ("-N-", 0.ToString ("-N-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04014 ()
+ {
+ Assert.AreEqual ("-N", Int32.MaxValue.ToString ("-N", _nfi), "#01");
+ Assert.AreEqual ("N-", Int32.MaxValue.ToString ("N-", _nfi), "#02");
+ Assert.AreEqual ("-N-", Int32.MaxValue.ToString ("-N-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04015 ()
+ {
+ Assert.AreEqual ("--N", Int32.MinValue.ToString ("-N", _nfi), "#01");
+ Assert.AreEqual ("-N-", Int32.MinValue.ToString ("N-", _nfi), "#02");
+ Assert.AreEqual ("--N-", Int32.MinValue.ToString ("-N-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04016 ()
+ {
+ Assert.AreEqual ("N+0", 0.ToString ("N+0", _nfi), "#01");
+ Assert.AreEqual ("N+2147483647", Int32.MaxValue.ToString ("N+0", _nfi), "#02");
+ Assert.AreEqual ("-N+2147483648", Int32.MinValue.ToString ("N+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04017 ()
+ {
+ Assert.AreEqual ("N+9", 0.ToString ("N+9", _nfi), "#01");
+ Assert.AreEqual ("N+9", Int32.MaxValue.ToString ("N+9", _nfi), "#02");
+ Assert.AreEqual ("-N+9", Int32.MinValue.ToString ("N+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04018 ()
+ {
+ Assert.AreEqual ("N-9", 0.ToString ("N-9", _nfi), "#01");
+ Assert.AreEqual ("N-9", Int32.MaxValue.ToString ("N-9", _nfi), "#02");
+ Assert.AreEqual ("-N-9", Int32.MinValue.ToString ("N-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04019 ()
+ {
+ Assert.AreEqual ("N0", 0.ToString ("N0,", _nfi), "#01");
+ Assert.AreEqual ("N2147484", Int32.MaxValue.ToString ("N0,", _nfi), "#02");
+ Assert.AreEqual ("-N2147484", Int32.MinValue.ToString ("N0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04020 ()
+ {
+ Assert.AreEqual ("N0", 0.ToString ("N0.", _nfi), "#01");
+ Assert.AreEqual ("N2147483647", Int32.MaxValue.ToString ("N0.", _nfi), "#02");
+ Assert.AreEqual ("-N2147483648", Int32.MinValue.ToString ("N0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04021 ()
+ {
+ Assert.AreEqual ("N0.0", 0.ToString ("N0.0", _nfi), "#01");
+ Assert.AreEqual ("N2147483647.0", Int32.MaxValue.ToString ("N0.0", _nfi), "#02");
+ Assert.AreEqual ("-N2147483648.0", Int32.MinValue.ToString ("N0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04022 ()
+ {
+ Assert.AreEqual ("N09", 0.ToString ("N0.9", _nfi), "#01");
+ Assert.AreEqual ("N21474836479", Int32.MaxValue.ToString ("N0.9", _nfi), "#02");
+ Assert.AreEqual ("-N21474836489", Int32.MinValue.ToString ("N0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test04023 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalDigits = 0;
+ Assert.AreEqual ("0", 0.ToString ("N", nfi), "#01");
+ nfi.NumberDecimalDigits = 1;
+ Assert.AreEqual ("0.0", 0.ToString ("N", nfi), "#02");
+ nfi.NumberDecimalDigits = 99;
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N", nfi), "#03");
+ }
+
+ [Test]
+ public void Test04024 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "";
+ Assert.AreEqual ("2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#01");
+ nfi.NegativeSign = "-";
+ Assert.AreEqual ("-2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#02");
+ nfi.NegativeSign = "+";
+ Assert.AreEqual ("+2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#03");
+ nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#04");
+ }
+
+ [Test]
+ public void Test04025 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "-";
+ nfi.PositiveSign = "+";
+ Assert.AreEqual ("-1.00", (-1).ToString ("N", nfi), "#01");
+ Assert.AreEqual ("0.00", 0.ToString ("N", nfi), "#02");
+ Assert.AreEqual ("1.00",1.ToString ("N", nfi), "#03");
+ }
+
+ [Test]
+ public void Test04026 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+ Assert.AreEqual ("+1.00", (-1).ToString ("N", nfi), "#01");
+ Assert.AreEqual ("0.00", 0.ToString ("N", nfi), "#02");
+ Assert.AreEqual ("1.00",1.ToString ("N", nfi), "#03");
+ }
+
+ [Test]
+ public void Test04027 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("123#0",123.ToString ("N1", nfi), "#01");
+ }
+
+ [Test]
+ public void Test04028 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberGroupSeparator = "-";
+ Assert.AreEqual ("-2-147-483-648.0",Int32.MinValue.ToString ("N1", nfi), "#01");
+ }
+
+ [Test]
+ public void Test04029 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberGroupSizes = new int [] {};
+ Assert.AreEqual ("-2147483648.0",Int32.MinValue.ToString ("N1", nfi), "#01");
+ nfi.NumberGroupSizes = new int [] {0};
+ Assert.AreEqual ("-2147483648.0",Int32.MinValue.ToString ("N1", nfi), "#02");
+ nfi.NumberGroupSizes = new int [] {1};
+ Assert.AreEqual ("-2,1,4,7,4,8,3,6,4,8.0",Int32.MinValue.ToString ("N1", nfi), "#03");
+ nfi.NumberGroupSizes = new int [] {3};
+ Assert.AreEqual ("-2,147,483,648.0",Int32.MinValue.ToString ("N1", nfi), "#04");
+ nfi.NumberGroupSizes = new int [] {9};
+ Assert.AreEqual ("-2,147483648.0",Int32.MinValue.ToString ("N1", nfi), "#05");
+ }
+
+ [Test]
+ public void Test04030 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberGroupSizes = new int [] {1,2};
+ Assert.AreEqual ("-2,14,74,83,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#01");
+ nfi.NumberGroupSizes = new int [] {1,2,3};
+ Assert.AreEqual ("-2,147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#02");
+ nfi.NumberGroupSizes = new int [] {1,2,3,4};
+ Assert.AreEqual ("-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#03");
+ nfi.NumberGroupSizes = new int [] {1,2,1,2,1,2,1};
+ Assert.AreEqual ("-2,14,7,48,3,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#04");
+ nfi.NumberGroupSizes = new int [] {1,0};
+ Assert.AreEqual ("-214748364,8.0",Int32.MinValue.ToString ("N1", nfi), "#05");
+ nfi.NumberGroupSizes = new int [] {1,2,0};
+ Assert.AreEqual ("-2147483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#06");
+ nfi.NumberGroupSizes = new int [] {1,2,3,0};
+ Assert.AreEqual ("-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#07");
+ nfi.NumberGroupSizes = new int [] {1,2,3,4,0};
+ Assert.AreEqual ("-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#08");
+ }
+
+ [Test]
+ public void Test04031 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "1234567890";
+ Assert.AreEqual ("12345678902,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#01");
+ }
+
+ // Test05000 - Int32 and P
+ [Test]
+ public void Test05000 ()
+ {
+ Assert.AreEqual ("0.00 %", 0.ToString ("P", _nfi), "#01");
+ Assert.AreEqual ("0.00 %", 0.ToString ("p", _nfi), "#02");
+ Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", _nfi), "#03");
+ Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("p", _nfi), "#04");
+ Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", _nfi), "#05");
+ Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("p", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test05001 ()
+ {
+ Assert.AreEqual ("P ", 0.ToString ("P ", _nfi), "#01");
+ Assert.AreEqual (" P", 0.ToString (" P", _nfi), "#02");
+ Assert.AreEqual (" P ", 0.ToString (" P ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05002 ()
+ {
+ Assert.AreEqual ("-P ", (-1).ToString ("P ", _nfi), "#01");
+ Assert.AreEqual ("- P", (-1).ToString (" P", _nfi), "#02");
+ Assert.AreEqual ("- P ", (-1).ToString (" P ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05003 ()
+ {
+ Assert.AreEqual ("0 %", 0.ToString ("P0", _nfi), "#01");
+ Assert.AreEqual ("0.000000000 %", 0.ToString ("P9", _nfi), "#02");
+ Assert.AreEqual ("0.0000000000 %", 0.ToString ("P10", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P99", _nfi), "#04");
+ Assert.AreEqual ("P100", 0.ToString ("P100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test05004 ()
+ {
+ Assert.AreEqual ("214,748,364,700 %", Int32.MaxValue.ToString ("P0", _nfi), "#01");
+ Assert.AreEqual ("214,748,364,700.000000000 %", Int32.MaxValue.ToString ("P9", _nfi), "#02");
+ Assert.AreEqual ("214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P10", _nfi), "#03");
+ Assert.AreEqual ("214,748,364,700.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MaxValue.ToString ("P99", _nfi), "#04");
+ Assert.AreEqual ("P12147483647", Int32.MaxValue.ToString ("P100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test05005 ()
+ {
+ Assert.AreEqual ("-214,748,364,800 %", Int32.MinValue.ToString ("P0", _nfi), "#01");
+ Assert.AreEqual ("-214,748,364,800.000000000 %", Int32.MinValue.ToString ("P9", _nfi), "#02");
+ Assert.AreEqual ("-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P10", _nfi), "#03");
+ Assert.AreEqual ("-214,748,364,800.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MinValue.ToString ("P99", _nfi), "#04");
+ Assert.AreEqual ("-P12147483648", Int32.MinValue.ToString ("P100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test05006 ()
+ {
+ Assert.AreEqual ("PF", 0.ToString ("PF", _nfi), "#01");
+ Assert.AreEqual ("P0F", 0.ToString ("P0F", _nfi), "#02");
+ Assert.AreEqual ("P0xF", 0.ToString ("P0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05007 ()
+ {
+ Assert.AreEqual ("PF", Int32.MaxValue.ToString ("PF", _nfi), "#01");
+ Assert.AreEqual ("P2147483647F", Int32.MaxValue.ToString ("P0F", _nfi), "#02");
+ Assert.AreEqual ("P2147483647xF", Int32.MaxValue.ToString ("P0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05008 ()
+ {
+ Assert.AreEqual ("-PF", Int32.MinValue.ToString ("PF", _nfi), "#01");
+ Assert.AreEqual ("-P2147483648F", Int32.MinValue.ToString ("P0F", _nfi), "#02");
+ Assert.AreEqual ("-P2147483648xF", Int32.MinValue.ToString ("P0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05009 ()
+ {
+ Assert.AreEqual ("0.0000000000 %", 0.ToString ("P0000000000000000000000000000000000000010", _nfi), "#01");
+ Assert.AreEqual ("214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P0000000000000000000000000000000000000010", _nfi), "#02");
+ Assert.AreEqual ("-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P0000000000000000000000000000000000000010", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05010 ()
+ {
+ Assert.AreEqual ("+P", 0.ToString ("+P", _nfi), "#01");
+ Assert.AreEqual ("P+", 0.ToString ("P+", _nfi), "#02");
+ Assert.AreEqual ("+P+", 0.ToString ("+P+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05011 ()
+ {
+ Assert.AreEqual ("+P", Int32.MaxValue.ToString ("+P", _nfi), "#01");
+ Assert.AreEqual ("P+", Int32.MaxValue.ToString ("P+", _nfi), "#02");
+ Assert.AreEqual ("+P+", Int32.MaxValue.ToString ("+P+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05012 ()
+ {
+ Assert.AreEqual ("-+P", Int32.MinValue.ToString ("+P", _nfi), "#01");
+ Assert.AreEqual ("-P+", Int32.MinValue.ToString ("P+", _nfi), "#02");
+ Assert.AreEqual ("-+P+", Int32.MinValue.ToString ("+P+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05013 ()
+ {
+ Assert.AreEqual ("-P", 0.ToString ("-P", _nfi), "#01");
+ Assert.AreEqual ("P-", 0.ToString ("P-", _nfi), "#02");
+ Assert.AreEqual ("-P-", 0.ToString ("-P-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05014 ()
+ {
+ Assert.AreEqual ("-P", Int32.MaxValue.ToString ("-P", _nfi), "#01");
+ Assert.AreEqual ("P-", Int32.MaxValue.ToString ("P-", _nfi), "#02");
+ Assert.AreEqual ("-P-", Int32.MaxValue.ToString ("-P-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05015 ()
+ {
+ Assert.AreEqual ("--P", Int32.MinValue.ToString ("-P", _nfi), "#01");
+ Assert.AreEqual ("-P-", Int32.MinValue.ToString ("P-", _nfi), "#02");
+ Assert.AreEqual ("--P-", Int32.MinValue.ToString ("-P-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05016 ()
+ {
+ Assert.AreEqual ("P+0", 0.ToString ("P+0", _nfi), "#01");
+ Assert.AreEqual ("P+2147483647", Int32.MaxValue.ToString ("P+0", _nfi), "#02");
+ Assert.AreEqual ("-P+2147483648", Int32.MinValue.ToString ("P+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05017 ()
+ {
+ Assert.AreEqual ("P+9", 0.ToString ("P+9", _nfi), "#01");
+ Assert.AreEqual ("P+9", Int32.MaxValue.ToString ("P+9", _nfi), "#02");
+ Assert.AreEqual ("-P+9", Int32.MinValue.ToString ("P+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05018 ()
+ {
+ Assert.AreEqual ("P-9", 0.ToString ("P-9", _nfi), "#01");
+ Assert.AreEqual ("P-9", Int32.MaxValue.ToString ("P-9", _nfi), "#02");
+ Assert.AreEqual ("-P-9", Int32.MinValue.ToString ("P-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05019 ()
+ {
+ Assert.AreEqual ("P0", 0.ToString ("P0,", _nfi), "#01");
+ Assert.AreEqual ("P2147484", Int32.MaxValue.ToString ("P0,", _nfi), "#02");
+ Assert.AreEqual ("-P2147484", Int32.MinValue.ToString ("P0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05020 ()
+ {
+ Assert.AreEqual ("P0", 0.ToString ("P0.", _nfi), "#01");
+ Assert.AreEqual ("P2147483647", Int32.MaxValue.ToString ("P0.", _nfi), "#02");
+ Assert.AreEqual ("-P2147483648", Int32.MinValue.ToString ("P0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05021 ()
+ {
+ Assert.AreEqual ("P0.0", 0.ToString ("P0.0", _nfi), "#01");
+ Assert.AreEqual ("P2147483647.0", Int32.MaxValue.ToString ("P0.0", _nfi), "#02");
+ Assert.AreEqual ("-P2147483648.0", Int32.MinValue.ToString ("P0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05022 ()
+ {
+ Assert.AreEqual ("P09", 0.ToString ("P0.9", _nfi), "#01");
+ Assert.AreEqual ("P21474836479", Int32.MaxValue.ToString ("P0.9", _nfi), "#02");
+ Assert.AreEqual ("-P21474836489", Int32.MinValue.ToString ("P0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test05023 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentDecimalDigits = 0;
+ Assert.AreEqual ("0 %", 0.ToString ("P", nfi), "#01");
+ nfi.PercentDecimalDigits = 1;
+ Assert.AreEqual ("0.0 %", 0.ToString ("P", nfi), "#02");
+ nfi.PercentDecimalDigits = 99;
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05024 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "";
+ Assert.AreEqual ("214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
+ nfi.NegativeSign = "-";
+ Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#02");
+ nfi.NegativeSign = "+";
+ Assert.AreEqual ("+214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#03");
+ nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ";
+ Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#04");
+ }
+
+ [Test]
+ public void Test05025 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "-";
+ nfi.PositiveSign = "+";
+ Assert.AreEqual ("-100.00 %", (-1).ToString ("P", nfi), "#01");
+ Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("100.00 %",1.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05026 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+ Assert.AreEqual ("+100.00 %", (-1).ToString ("P", nfi), "#01");
+ Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("100.00 %",1.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05027 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentDecimalSeparator = "#";
+ Assert.AreEqual ("12,300#0 %",123.ToString ("P1", nfi), "#01");
+ }
+
+ [Test]
+ public void Test05028 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentGroupSeparator = "-";
+ Assert.AreEqual ("-214-748-364-800.0 %",Int32.MinValue.ToString ("P1", nfi), "#01");
+ }
+
+ [Test]
+ public void Test05029 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentGroupSizes = new int [] {};
+ Assert.AreEqual ("-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi), "#01");
+ nfi.PercentGroupSizes = new int [] {0};
+ Assert.AreEqual ("-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi), "#02");
+ nfi.PercentGroupSizes = new int [] {1};
+ Assert.AreEqual ("-2,1,4,7,4,8,3,6,4,8,0,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#03");
+ nfi.PercentGroupSizes = new int [] {3};
+ Assert.AreEqual ("-214,748,364,800.0 %",Int32.MinValue.ToString ("P1", nfi), "#04");
+ nfi.PercentGroupSizes = new int [] {9};
+ Assert.AreEqual ("-214,748364800.0 %",Int32.MinValue.ToString ("P1", nfi), "#05");
+ }
+
+ [Test]
+ public void Test05030 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentGroupSizes = new int [] {1,2};
+ Assert.AreEqual ("-2,14,74,83,64,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#01");
+ nfi.PercentGroupSizes = new int [] {1,2,3};
+ Assert.AreEqual ("-214,748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#02");
+ nfi.PercentGroupSizes = new int [] {1,2,3,4};
+ Assert.AreEqual ("-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#03");
+ nfi.PercentGroupSizes = new int [] {1,2,1,2,1,2,1};
+ Assert.AreEqual ("-2,1,4,74,8,36,4,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#04");
+ nfi.PercentGroupSizes = new int [] {1,0};
+ Assert.AreEqual ("-21474836480,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#05");
+ nfi.PercentGroupSizes = new int [] {1,2,0};
+ Assert.AreEqual ("-214748364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#06");
+ nfi.PercentGroupSizes = new int [] {1,2,3,0};
+ Assert.AreEqual ("-214748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#07");
+ nfi.PercentGroupSizes = new int [] {1,2,3,4,0};
+ Assert.AreEqual ("-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#08");
+ }
+
+ [Test]
+ public void Test05031 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "1234567890";
+ Assert.AreEqual ("1234567890214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
+ }
+
+ [Test]
+ public void Test05032 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentNegativePattern = 0;
+ Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
+ Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05033 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentNegativePattern = 1;
+ Assert.AreEqual ("-214,748,364,800.00%", Int32.MinValue.ToString ("P", nfi), "#01");
+ Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05034 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentNegativePattern = 2;
+ Assert.AreEqual ("-%214,748,364,800.00", Int32.MinValue.ToString ("P", nfi), "#01");
+ Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05035 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentPositivePattern = 0;
+ Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
+ Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05036 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentPositivePattern = 1;
+ Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
+ Assert.AreEqual ("214,748,364,700.00%", Int32.MaxValue.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("0.00%", 0.ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test05037 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentPositivePattern = 2;
+ Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
+ Assert.AreEqual ("%214,748,364,700.00", Int32.MaxValue.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("%0.00", 0.ToString ("P", nfi), "#03");
+ }
+
+ // Test06000 - Int32 and R
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Test06000 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("R", _nfi), "#01");
+ }
+
+ // Test07000- Int32 and X
+ [Test]
+ public void Test07000 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("X", _nfi), "#01");
+ Assert.AreEqual ("0", 0.ToString ("x", _nfi), "#02");
+ Assert.AreEqual ("80000000", Int32.MinValue.ToString ("X", _nfi), "#03");
+ Assert.AreEqual ("80000000", Int32.MinValue.ToString ("x", _nfi), "#04");
+ Assert.AreEqual ("7FFFFFFF", Int32.MaxValue.ToString ("X", _nfi), "#05");
+ Assert.AreEqual ("7fffffff", Int32.MaxValue.ToString ("x", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test07001 ()
+ {
+ Assert.AreEqual ("X ", 0.ToString ("X ", _nfi), "#01");
+ Assert.AreEqual (" X", 0.ToString (" X", _nfi), "#02");
+ Assert.AreEqual (" X ", 0.ToString (" X ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07002 ()
+ {
+ Assert.AreEqual ("-X ", (-1).ToString ("X ", _nfi), "#01");
+ Assert.AreEqual ("- X", (-1).ToString (" X", _nfi), "#02");
+ Assert.AreEqual ("- X ", (-1).ToString (" X ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07003 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("X0", _nfi), "#01");
+ Assert.AreEqual ("0000000000", 0.ToString ("X10", _nfi), "#02");
+ Assert.AreEqual ("00000000000", 0.ToString ("X11", _nfi), "#03");
+ Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("X99", _nfi), "#04");
+ Assert.AreEqual ("X100", 0.ToString ("X100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test07004 ()
+ {
+ Assert.AreEqual ("7FFFFFFF", Int32.MaxValue.ToString ("X0", _nfi), "#01");
+ Assert.AreEqual ("007FFFFFFF", Int32.MaxValue.ToString ("X10", _nfi), "#02");
+ Assert.AreEqual ("0007FFFFFFF", Int32.MaxValue.ToString ("X11", _nfi), "#03");
+ Assert.AreEqual ("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FFFFFFF", Int32.MaxValue.ToString ("X99", _nfi), "#04");
+ Assert.AreEqual ("X12147483647", Int32.MaxValue.ToString ("X100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test07005 ()
+ {
+ Assert.AreEqual ("80000000", Int32.MinValue.ToString ("X0", _nfi), "#01");
+ Assert.AreEqual ("0080000000", Int32.MinValue.ToString ("X10", _nfi), "#02");
+ Assert.AreEqual ("00080000000", Int32.MinValue.ToString ("X11", _nfi), "#03");
+ Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000", Int32.MinValue.ToString ("X99", _nfi), "#04");
+ Assert.AreEqual ("-X12147483648", Int32.MinValue.ToString ("X100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test07006 ()
+ {
+ Assert.AreEqual ("XF", 0.ToString ("XF", _nfi), "#01");
+ Assert.AreEqual ("X0F", 0.ToString ("X0F", _nfi), "#02");
+ Assert.AreEqual ("X0xF", 0.ToString ("X0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07007 ()
+ {
+ Assert.AreEqual ("XF", Int32.MaxValue.ToString ("XF", _nfi), "#01");
+ Assert.AreEqual ("X2147483647F", Int32.MaxValue.ToString ("X0F", _nfi), "#02");
+ Assert.AreEqual ("X2147483647xF", Int32.MaxValue.ToString ("X0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07008 ()
+ {
+ Assert.AreEqual ("-XF", Int32.MinValue.ToString ("XF", _nfi), "#01");
+ Assert.AreEqual ("-X2147483648F", Int32.MinValue.ToString ("X0F", _nfi), "#02");
+ Assert.AreEqual ("-X2147483648xF", Int32.MinValue.ToString ("X0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07009 ()
+ {
+ Assert.AreEqual ("00000000000", 0.ToString ("X0000000000000000000000000000000000000011", _nfi), "#01");
+ Assert.AreEqual ("0007FFFFFFF", Int32.MaxValue.ToString ("X0000000000000000000000000000000000000011", _nfi), "#02");
+ Assert.AreEqual ("00080000000", Int32.MinValue.ToString ("X0000000000000000000000000000000000000011", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07010 ()
+ {
+ Assert.AreEqual ("+X", 0.ToString ("+X", _nfi), "#01");
+ Assert.AreEqual ("X+", 0.ToString ("X+", _nfi), "#02");
+ Assert.AreEqual ("+X+", 0.ToString ("+X+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07011 ()
+ {
+ Assert.AreEqual ("+X", Int32.MaxValue.ToString ("+X", _nfi), "#01");
+ Assert.AreEqual ("X+", Int32.MaxValue.ToString ("X+", _nfi), "#02");
+ Assert.AreEqual ("+X+", Int32.MaxValue.ToString ("+X+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07012 ()
+ {
+ Assert.AreEqual ("-+X", Int32.MinValue.ToString ("+X", _nfi), "#01");
+ Assert.AreEqual ("-X+", Int32.MinValue.ToString ("X+", _nfi), "#02");
+ Assert.AreEqual ("-+X+", Int32.MinValue.ToString ("+X+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07013 ()
+ {
+ Assert.AreEqual ("-X", 0.ToString ("-X", _nfi), "#01");
+ Assert.AreEqual ("X-", 0.ToString ("X-", _nfi), "#02");
+ Assert.AreEqual ("-X-", 0.ToString ("-X-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07014 ()
+ {
+ Assert.AreEqual ("-X", Int32.MaxValue.ToString ("-X", _nfi), "#01");
+ Assert.AreEqual ("X-", Int32.MaxValue.ToString ("X-", _nfi), "#02");
+ Assert.AreEqual ("-X-", Int32.MaxValue.ToString ("-X-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07015 ()
+ {
+ Assert.AreEqual ("--X", Int32.MinValue.ToString ("-X", _nfi), "#01");
+ Assert.AreEqual ("-X-", Int32.MinValue.ToString ("X-", _nfi), "#02");
+ Assert.AreEqual ("--X-", Int32.MinValue.ToString ("-X-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07016 ()
+ {
+ Assert.AreEqual ("X+0", 0.ToString ("X+0", _nfi), "#01");
+ Assert.AreEqual ("X+2147483647", Int32.MaxValue.ToString ("X+0", _nfi), "#02");
+ Assert.AreEqual ("-X+2147483648", Int32.MinValue.ToString ("X+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07017 ()
+ {
+ Assert.AreEqual ("X+9", 0.ToString ("X+9", _nfi), "#01");
+ Assert.AreEqual ("X+9", Int32.MaxValue.ToString ("X+9", _nfi), "#02");
+ Assert.AreEqual ("-X+9", Int32.MinValue.ToString ("X+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07018 ()
+ {
+ Assert.AreEqual ("X-9", 0.ToString ("X-9", _nfi), "#01");
+ Assert.AreEqual ("X-9", Int32.MaxValue.ToString ("X-9", _nfi), "#02");
+ Assert.AreEqual ("-X-9", Int32.MinValue.ToString ("X-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07019 ()
+ {
+ Assert.AreEqual ("X0", 0.ToString ("X0,", _nfi), "#01");
+ Assert.AreEqual ("X2147484", Int32.MaxValue.ToString ("X0,", _nfi), "#02");
+ Assert.AreEqual ("-X2147484", Int32.MinValue.ToString ("X0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07020 ()
+ {
+ Assert.AreEqual ("X0", 0.ToString ("X0.", _nfi), "#01");
+ Assert.AreEqual ("X2147483647", Int32.MaxValue.ToString ("X0.", _nfi), "#02");
+ Assert.AreEqual ("-X2147483648", Int32.MinValue.ToString ("X0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07021 ()
+ {
+ Assert.AreEqual ("X0.0", 0.ToString ("X0.0", _nfi), "#01");
+ Assert.AreEqual ("X2147483647.0", Int32.MaxValue.ToString ("X0.0", _nfi), "#02");
+ Assert.AreEqual ("-X2147483648.0", Int32.MinValue.ToString ("X0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test07022 ()
+ {
+ Assert.AreEqual ("X09", 0.ToString ("X0.9", _nfi), "#01");
+ Assert.AreEqual ("X21474836479", Int32.MaxValue.ToString ("X0.9", _nfi), "#02");
+ Assert.AreEqual ("-X21474836489", Int32.MinValue.ToString ("X0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08000 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("0", _nfi), "#01");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("0", _nfi), "#02");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("0", _nfi), "#03");
+ }
+
+ // Test08000 - Int32 and Custom
+ [Test]
+ public void Test08001 ()
+ {
+ Assert.AreEqual ("00000000000", 0.ToString ("00000000000", _nfi), "#01");
+ Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("00000000000", _nfi), "#02");
+ Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("00000000000", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08002 ()
+ {
+ Assert.AreEqual (" 00000000000 ", 0.ToString (" 00000000000 ", _nfi), "#01");
+ Assert.AreEqual (" 02147483647 ", Int32.MaxValue.ToString (" 00000000000 ", _nfi), "#02");
+ Assert.AreEqual ("- 02147483648 ", Int32.MinValue.ToString (" 00000000000 ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08003 ()
+ {
+ Assert.AreEqual ("", 0.ToString ("#", _nfi), "#01");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("#", _nfi), "#02");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("#", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08004 ()
+ {
+ Assert.AreEqual ("", 0.ToString ("##########", _nfi), "#01");
+ Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("##########", _nfi), "#02");
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("##########", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08005 ()
+ {
+ Assert.AreEqual (" ", 0.ToString (" ########## ", _nfi), "#01");
+ Assert.AreEqual (" 2147483647 ", Int32.MaxValue.ToString (" ########## ", _nfi), "#02");
+ Assert.AreEqual ("- 2147483648 ", Int32.MinValue.ToString (" ########## ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08006 ()
+ {
+ Assert.AreEqual ("", 0.ToString (".", _nfi), "#01");
+ Assert.AreEqual ("", Int32.MaxValue.ToString (".", _nfi), "#02");
+ Assert.AreEqual ("-", Int32.MinValue.ToString (".", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08007 ()
+ {
+ Assert.AreEqual ("00000000000", 0.ToString ("00000000000.", _nfi), "#01");
+ Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("00000000000.", _nfi), "#02");
+ Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("00000000000.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08008 ()
+ {
+ Assert.AreEqual (".00000000000", 0.ToString (".00000000000", _nfi), "#01");
+ Assert.AreEqual ("2147483647.00000000000", Int32.MaxValue.ToString (".00000000000", _nfi), "#02");
+ Assert.AreEqual ("-2147483648.00000000000", Int32.MinValue.ToString (".00000000000", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08009 ()
+ {
+ Assert.AreEqual ("00000000000.00000000000", 0.ToString ("00000000000.00000000000", _nfi), "#01");
+ Assert.AreEqual ("02147483647.00000000000", Int32.MaxValue.ToString ("00000000000.00000000000", _nfi), "#02");
+ Assert.AreEqual ("-02147483648.00000000000", Int32.MinValue.ToString ("00000000000.00000000000", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08010 ()
+ {
+ Assert.AreEqual ("00.0000000000", 0.ToString ("00.0.00.000.0000", _nfi), "#01");
+ Assert.AreEqual ("01.0000000000", 1.ToString ("00.0.00.000.0000", _nfi), "#02");
+ Assert.AreEqual ("-01.0000000000", (-1).ToString ("00.0.00.000.0000", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08011 ()
+ {
+ Assert.AreEqual ("", 0.ToString ("##.#.##.###.####", _nfi), "#01");
+ Assert.AreEqual ("1", 1.ToString ("##.#.##.###.####", _nfi), "#02");
+ Assert.AreEqual ("-1", (-1).ToString ("##.#.##.###.####", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08012 ()
+ {
+ Assert.AreEqual ("00", 0.ToString ("0#.#.##.###.####", _nfi), "#01");
+ Assert.AreEqual ("01", 1.ToString ("0#.#.##.###.####", _nfi), "#02");
+ Assert.AreEqual ("-01", (-1).ToString ("0#.#.##.###.####", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08013 ()
+ {
+ Assert.AreEqual ("0", 0.ToString ("#0.#.##.###.####", _nfi), "#01");
+ Assert.AreEqual ("1", 1.ToString ("#0.#.##.###.####", _nfi), "#02");
+ Assert.AreEqual ("-1", (-1).ToString ("#0.#.##.###.####", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08014 ()
+ {
+ Assert.AreEqual (".0000000000", 0.ToString ("##.#.##.###.###0", _nfi), "#01");
+ Assert.AreEqual ("1.0000000000", 1.ToString ("##.#.##.###.###0", _nfi), "#02");
+ Assert.AreEqual ("-1.0000000000", (-1).ToString ("##.#.##.###.###0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08015 ()
+ {
+ Assert.AreEqual (".000000000", 0.ToString ("##.#.##.###.##0#", _nfi), "#01");
+ Assert.AreEqual ("1.000000000", 1.ToString ("##.#.##.###.##0#", _nfi), "#02");
+ Assert.AreEqual ("-1.000000000", (-1).ToString ("##.#.##.###.##0#", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08016 ()
+ {
+ Assert.AreEqual (".000000000", 0.ToString ("##.#.##.##0.##0#", _nfi), "#01");
+ Assert.AreEqual ("1.000000000", 1.ToString ("##.#.##.##0.##0#", _nfi), "#02");
+ Assert.AreEqual ("-1.000000000", (-1).ToString ("##.#.##.##0.##0#", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08017 ()
+ {
+ Assert.AreEqual ("0.000000000", 0.ToString ("#0.#.##.##0.##0#", _nfi), "#01");
+ Assert.AreEqual ("1.000000000", 1.ToString ("#0.#.##.##0.##0#", _nfi), "#02");
+ Assert.AreEqual ("-1.000000000", (-1).ToString ("#0.#.##.##0.##0#", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08018 ()
+ {
+ Assert.AreEqual ("-0002147484", Int32.MinValue.ToString ("0000000000,", _nfi), "#01");
+ Assert.AreEqual ("-0000002147", Int32.MinValue.ToString ("0000000000,,", _nfi), "#02");
+ Assert.AreEqual ("-0000000002", Int32.MinValue.ToString ("0000000000,,,", _nfi), "#03");
+ Assert.AreEqual ("0000000000", Int32.MinValue.ToString ("0000000000,,,,", _nfi), "#04");
+ Assert.AreEqual ("0000000000", Int32.MinValue.ToString ("0000000000,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test08019 ()
+ {
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString (",0000000000", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08020 ()
+ {
+ Assert.AreEqual ("-0002147484", Int32.MinValue.ToString (",0000000000,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08021 ()
+ {
+ Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0,0000000000", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08022 ()
+ {
+ Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0000000000,0", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08023 ()
+ {
+ Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08024 ()
+ {
+ Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08025 ()
+ {
+ Assert.AreEqual ("-00,002,147,484", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08026 ()
+ {
+ Assert.AreEqual ("-00,002,147,484", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08027 ()
+ {
+ Assert.AreEqual ("-", Int32.MinValue.ToString (",", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08028 ()
+ {
+ Assert.AreEqual ("-2147483648", Int32.MinValue.ToString (",##########", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08029 ()
+ {
+ Assert.AreEqual ("-2147484", Int32.MinValue.ToString (",##########,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08030 ()
+ {
+ Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,##########", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08031 ()
+ {
+ Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("##########,#", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08032 ()
+ {
+ Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08033 ()
+ {
+ Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08034 ()
+ {
+ Assert.AreEqual ("-2,147,484", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08035 ()
+ {
+ Assert.AreEqual ("-2,147,484", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08036 ()
+ {
+ Assert.AreEqual ("-1", (-1000).ToString ("##########,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08037 ()
+ {
+ Assert.AreEqual ("", (-100).ToString ("##########,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08038 ()
+ {
+ Assert.AreEqual ("-%", Int32.MinValue.ToString ("%", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08039 ()
+ {
+ Assert.AreEqual ("-214748364800%", Int32.MinValue.ToString ("0%", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08040 ()
+ {
+ Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString ("%0", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08041 ()
+ {
+ Assert.AreEqual ("-%21474836480000%", Int32.MinValue.ToString ("%0%", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08042 ()
+ {
+ Assert.AreEqual ("- % 21474836480000 % ", Int32.MinValue.ToString (" % 0 % ", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08043 ()
+ {
+ Assert.AreEqual ("-214748365%", Int32.MinValue.ToString ("0%,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08044 ()
+ {
+ Assert.AreEqual ("-214748365%", Int32.MinValue.ToString ("0,%", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08045 ()
+ {
+ Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString (",%0", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08046 ()
+ {
+ Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString ("%,0", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08047 ()
+ {
+ Assert.AreEqual ("-2147483648%%%%%%", Int32.MinValue.ToString ("0,,,,%%%%%%", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08048 ()
+ {
+ Assert.AreEqual ("-2147483648%%%%%%", Int32.MinValue.ToString ("0%%%%%%,,,,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08049 ()
+ {
+ Assert.AreEqual ("-%%%%%%2147483648", Int32.MinValue.ToString ("%%%%%%0,,,,", _nfi), "#01");
+ }
+
+ [Test]
+ public void Test08050 ()
+ {
+ Assert.AreEqual ("E+0", Int32.MinValue.ToString ("E+0", _nfi), "#01");
+ Assert.AreEqual ("e+0", Int32.MinValue.ToString ("e+0", _nfi), "#02");
+ Assert.AreEqual ("E0", Int32.MinValue.ToString ("E-0", _nfi), "#03");
+ Assert.AreEqual ("e0", Int32.MinValue.ToString ("e-0", _nfi), "#04");
+ }
+
+ [Test]
+ public void Test08051 ()
+ {
+ Assert.AreEqual ("-2E+9", Int32.MinValue.ToString ("0E+0", _nfi), "#01");
+ Assert.AreEqual ("-2e+9", Int32.MinValue.ToString ("0e+0", _nfi), "#02");
+ Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("0E-0", _nfi), "#03");
+ Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("0e-0", _nfi), "#04");
+ Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("0E0", _nfi), "#05");
+ Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("0e0", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08052 ()
+ {
+ Assert.AreEqual ("-2E+9", Int32.MinValue.ToString ("#E+0", _nfi), "#01");
+ Assert.AreEqual ("-2e+9", Int32.MinValue.ToString ("#e+0", _nfi), "#02");
+ Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("#E-0", _nfi), "#03");
+ Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("#e-0", _nfi), "#04");
+ Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("#E0", _nfi), "#05");
+ Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("#e0", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08053 ()
+ {
+ Assert.AreEqual ("-2147483648E+0", Int32.MinValue.ToString ("0000000000E+0", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e+0", Int32.MinValue.ToString ("0000000000e+0", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E0", Int32.MinValue.ToString ("0000000000E-0", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e0", Int32.MinValue.ToString ("0000000000e-0", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E0", Int32.MinValue.ToString ("0000000000E0", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e0", Int32.MinValue.ToString ("0000000000e0", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08054 ()
+ {
+ Assert.AreEqual ("-21474836480E-1", Int32.MinValue.ToString ("00000000000E+0", _nfi), "#01");
+ Assert.AreEqual ("-21474836480e-1", Int32.MinValue.ToString ("00000000000e+0", _nfi), "#02");
+ Assert.AreEqual ("-21474836480E-1", Int32.MinValue.ToString ("00000000000E-0", _nfi), "#03");
+ Assert.AreEqual ("-21474836480e-1", Int32.MinValue.ToString ("00000000000e-0", _nfi), "#04");
+ Assert.AreEqual ("-21474836480E-1", Int32.MinValue.ToString ("00000000000E0", _nfi), "#05");
+ Assert.AreEqual ("-21474836480e-1", Int32.MinValue.ToString ("00000000000e0", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08055 ()
+ {
+ Assert.AreEqual ("-214748365E+1", Int32.MinValue.ToString ("000000000E+0", _nfi), "#01");
+ Assert.AreEqual ("-214748365e+1", Int32.MinValue.ToString ("000000000e+0", _nfi), "#02");
+ Assert.AreEqual ("-214748365E1", Int32.MinValue.ToString ("000000000E-0", _nfi), "#03");
+ Assert.AreEqual ("-214748365e1", Int32.MinValue.ToString ("000000000e-0", _nfi), "#04");
+ Assert.AreEqual ("-214748365E1", Int32.MinValue.ToString ("000000000E0", _nfi), "#05");
+ Assert.AreEqual ("-214748365e1", Int32.MinValue.ToString ("000000000e0", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08056 ()
+ {
+ Assert.AreEqual ("-21474836E+2", Int32.MinValue.ToString ("00000000E+0", _nfi), "#01");
+ Assert.AreEqual ("-21474836e+2", Int32.MinValue.ToString ("00000000e+0", _nfi), "#02");
+ Assert.AreEqual ("-21474836E2", Int32.MinValue.ToString ("00000000E-0", _nfi), "#03");
+ Assert.AreEqual ("-21474836e2", Int32.MinValue.ToString ("00000000e-0", _nfi), "#04");
+ Assert.AreEqual ("-21474836E2", Int32.MinValue.ToString ("00000000E0", _nfi), "#05");
+ Assert.AreEqual ("-21474836e2", Int32.MinValue.ToString ("00000000e0", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08057 ()
+ {
+ Assert.AreEqual ("-2147483648E+00", Int32.MinValue.ToString ("0000000000E+00", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e+00", Int32.MinValue.ToString ("0000000000e+00", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E00", Int32.MinValue.ToString ("0000000000E-00", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e00", Int32.MinValue.ToString ("0000000000e-00", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E00", Int32.MinValue.ToString ("0000000000E00", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e00", Int32.MinValue.ToString ("0000000000e00", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08058 ()
+ {
+ Assert.AreEqual ("-2147483648E+02%", Int32.MinValue.ToString ("0000000000E+00%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e+02%", Int32.MinValue.ToString ("0000000000e+00%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E02%", Int32.MinValue.ToString ("0000000000E-00%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e02%", Int32.MinValue.ToString ("0000000000e-00%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E02%", Int32.MinValue.ToString ("0000000000E00%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e02%", Int32.MinValue.ToString ("0000000000e00%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08059 ()
+ {
+ Assert.AreEqual ("-2147483648E+10%%%%%", Int32.MinValue.ToString ("0000000000E+00%%%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e+10%%%%%", Int32.MinValue.ToString ("0000000000e+00%%%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E-00%%%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e-00%%%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E00%%%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e00%%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08060 ()
+ {
+ Assert.AreEqual ("-2147483648E-03", Int32.MinValue.ToString ("0000000000E+00,", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-03", Int32.MinValue.ToString ("0000000000e+00,", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-03", Int32.MinValue.ToString ("0000000000E-00,", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-03", Int32.MinValue.ToString ("0000000000e-00,", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-03", Int32.MinValue.ToString ("0000000000E00,", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-03", Int32.MinValue.ToString ("0000000000e00,", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08061 ()
+ {
+ Assert.AreEqual ("-2147483648E-12", Int32.MinValue.ToString ("0000000000E+00,,,,", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-12", Int32.MinValue.ToString ("0000000000e+00,,,,", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-12", Int32.MinValue.ToString ("0000000000E-00,,,,", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-12", Int32.MinValue.ToString ("0000000000e-00,,,,", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-12", Int32.MinValue.ToString ("0000000000E00,,,,", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-12", Int32.MinValue.ToString ("0000000000e00,,,,", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08062 ()
+ {
+ Assert.AreEqual ("-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E+00,,,,%%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e+00,,,,%%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E-00,,,,%%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e-00,,,,%%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E00,,,,%%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e00,,,,%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08063 ()
+ {
+ Assert.AreEqual ("-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E+00,,,,%%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e+00,,,,%%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E-00,,,,%%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e-00,,,,%%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E00,,,,%%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e00,,,,%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08064 ()
+ {
+ Assert.AreEqual ("-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E,+00,,,,%%%%", _nfi), "#01");
+ Assert.AreEqual ("-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e,+00,,,,%%%%", _nfi), "#02");
+ Assert.AreEqual ("-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E,-00,,,,%%%%", _nfi), "#03");
+ Assert.AreEqual ("-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e,-00,,,,%%%%", _nfi), "#04");
+ Assert.AreEqual ("-000,000,214,7E48%%%%", Int32.MinValue.ToString ("0000000000,E,00,,,,%%%%", _nfi), "#05");
+ Assert.AreEqual ("-000,000,214,7e48%%%%", Int32.MinValue.ToString ("0000000000,e,00,,,,%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08065 ()
+ {
+ Assert.AreEqual ("-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E+,00,,,,%%%%", _nfi), "#01");
+ Assert.AreEqual ("-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e+,00,,,,%%%%", _nfi), "#02");
+ Assert.AreEqual ("-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E-,00,,,,%%%%", _nfi), "#03");
+ Assert.AreEqual ("-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e-,00,,,,%%%%", _nfi), "#04");
+ }
+
+ [Test]
+ public void Test08066 ()
+ {
+ Assert.AreEqual ("-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E+0,0,,,,%%%%", _nfi), "#01");
+ Assert.AreEqual ("-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e+0,0,,,,%%%%", _nfi), "#02");
+ Assert.AreEqual ("-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E-0,0,,,,%%%%", _nfi), "#03");
+ Assert.AreEqual ("-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e-0,0,,,,%%%%", _nfi), "#04");
+ Assert.AreEqual ("-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E0,0,,,,%%%%", _nfi), "#05");
+ Assert.AreEqual ("-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e0,0,,,,%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08067 ()
+ {
+ Assert.AreEqual ("-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,,%%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,,%%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,,%%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,,%%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,,%%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,,%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08068 ()
+ {
+ Assert.AreEqual ("-2147483648E+02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,%%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e+02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,%%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,%%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,%%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,%%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08069 ()
+ {
+ Assert.AreEqual ("-2147483648E+00,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e+00,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08070 ()
+ {
+ Assert.AreEqual ("-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%\%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%\%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%\%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%\%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%\%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%\%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08071 ()
+ {
+ Assert.AreEqual (@"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,,,\\,\\%%%\\%", _nfi), "#01");
+ Assert.AreEqual (@"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,,,\\,\\%%%\\%", _nfi), "#02");
+ Assert.AreEqual (@"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,,,\\,\\%%%\\%", _nfi), "#03");
+ Assert.AreEqual (@"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,,,\\,\\%%%\\%", _nfi), "#04");
+ Assert.AreEqual (@"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,,,\\,\\%%%\\%", _nfi), "#05");
+ Assert.AreEqual (@"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,,,\\,\\%%%\\%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08072 ()
+ {
+ Assert.AreEqual (@"-2147483648E+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,\,,\\\,\\%%%\\\%", _nfi), "#01");
+ Assert.AreEqual (@"-2147483648e+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,\,,\\\,\\%%%\\\%", _nfi), "#02");
+ Assert.AreEqual (@"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,\,,\\\,\\%%%\\\%", _nfi), "#03");
+ Assert.AreEqual (@"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,\,,\\\,\\%%%\\\%", _nfi), "#04");
+ Assert.AreEqual (@"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,\,,\\\,\\%%%\\\%", _nfi), "#05");
+ Assert.AreEqual (@"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,\,,\\\,\\%%%\\\%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08073 ()
+ {
+ Assert.AreEqual (@"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E+00\\,\,,\\\,\\%%%\\\%", _nfi), "#01");
+ Assert.AreEqual (@"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e+00\\,\,,\\\,\\%%%\\\%", _nfi), "#02");
+ Assert.AreEqual (@"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E-00\\,\,,\\\,\\%%%\\\%", _nfi), "#03");
+ Assert.AreEqual (@"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e-00\\,\,,\\\,\\%%%\\\%", _nfi), "#04");
+ Assert.AreEqual (@"-0021474836E48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E00\\,\,,\\\,\\%%%\\\%", _nfi), "#05");
+ Assert.AreEqual (@"-0021474836e48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e00\\,\,,\\\,\\%%%\\\%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08074 ()
+ {
+ Assert.AreEqual (@"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\+00\\,\,,\\\,\\%%%\\\%", _nfi), "#01");
+ Assert.AreEqual (@"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\+00\\,\,,\\\,\\%%%\\\%", _nfi), "#02");
+ Assert.AreEqual (@"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\-00\\,\,,\\\,\\%%%\\\%", _nfi), "#03");
+ Assert.AreEqual (@"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\-00\\,\,,\\\,\\%%%\\\%", _nfi), "#04");
+ }
+
+ [Test]
+ public void Test08075 ()
+ {
+ Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,',%'%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,',%'%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,',%'%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,',%'%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,',%'%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,',%'%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08076 ()
+ {
+ Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,\",%\"%%%", _nfi), "#01");
+ Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,\",%\"%%%", _nfi), "#02");
+ Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,\",%\"%%%", _nfi), "#03");
+ Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,\",%\"%%%", _nfi), "#04");
+ Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,\",%\"%%%", _nfi), "#05");
+ Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,\",%\"%%%", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test08077 ()
+ {
+ Assert.AreEqual ("-", Int32.MinValue.ToString (";", _nfi), "#01");
+ Assert.AreEqual ("", Int32.MaxValue.ToString (";", _nfi), "#02");
+ Assert.AreEqual ("",0.ToString (";", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08078 ()
+ {
+ Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,#;", _nfi), "#01");
+ Assert.AreEqual ("2,147,483,647", Int32.MaxValue.ToString ("#,#;", _nfi), "#02");
+ Assert.AreEqual ("", 0.ToString ("#,#;", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08079 ()
+ {
+ Assert.AreEqual ("2,147,483,648", Int32.MinValue.ToString (";#,#", _nfi), "#01");
+ Assert.AreEqual ("", Int32.MaxValue.ToString (";#,#", _nfi), "#02");
+ Assert.AreEqual ("", 0.ToString (";#,#", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08080 ()
+ {
+ Assert.AreEqual ("2,147,483,648", Int32.MinValue.ToString ("0000000000,.0000000000;#,#", _nfi), "#01");
+ Assert.AreEqual ("0002147483.6470000000", Int32.MaxValue.ToString ("0000000000,.0000000000;#,#", _nfi), "#02");
+ Assert.AreEqual ("0000000000.0000000000", 0.ToString ("0000000000,.0000000000;#,#", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08081 ()
+ {
+ Assert.AreEqual ("-", Int32.MinValue.ToString (";;", _nfi), "#01");
+ Assert.AreEqual ("", Int32.MaxValue.ToString (";;", _nfi), "#02");
+ Assert.AreEqual ("",0.ToString (";;", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08082 ()
+ {
+ Assert.AreEqual ("-", Int32.MinValue.ToString (";;0%", _nfi), "#01");
+ Assert.AreEqual ("", Int32.MaxValue.ToString (";;0%", _nfi), "#02");
+ Assert.AreEqual ("0%",0.ToString (";;0%", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08083 ()
+ {
+ Assert.AreEqual ("2147484", Int32.MinValue.ToString (";0,;0%", _nfi), "#01");
+ Assert.AreEqual ("", Int32.MaxValue.ToString (";0,;0%", _nfi), "#02");
+ Assert.AreEqual ("0%",0.ToString (";0,;0%", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08084 ()
+ {
+ Assert.AreEqual ("2147484", Int32.MinValue.ToString ("0E+0;0,;0%", _nfi), "#01");
+ Assert.AreEqual ("2E+9", Int32.MaxValue.ToString ("0E+0;0,;0%", _nfi), "#02");
+ Assert.AreEqual ("0%",0.ToString ("0E+0;0,;0%", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08085 ()
+ {
+ Assert.AreEqual ("214,748,364,80;0%", Int32.MinValue.ToString (@"0E+0;0,\;0%", _nfi), "#01");
+ Assert.AreEqual ("2E+9", Int32.MaxValue.ToString (@"0E+0;0,\;0%", _nfi), "#02");
+ Assert.AreEqual ("0E+0",0.ToString (@"0E+0;0,\;0%", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08086 ()
+ {
+ Assert.AreEqual ("214,748,364,80;0%", Int32.MinValue.ToString ("0E+0;0,\";\"0%", _nfi), "#01");
+ Assert.AreEqual ("2E+9", Int32.MaxValue.ToString ("0E+0;0,\";\"0%", _nfi), "#02");
+ Assert.AreEqual ("0E+0",0.ToString ("0E+0;0,\";\"0%", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test08087 ()
+ {
+ // MS.NET bug?
+ NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "$$$";
+ Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
+ }
+
+ [Test]
+ public void Test08088 ()
+ {
+ // MS.NET bug?
+ NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
+ nfi.NumberGroupSeparator = "$$$";
+ Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
+ }
+
+ [Test]
+ public void Test08089 ()
+ {
+ NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
+ nfi.NumberGroupSizes = new int[] {3,2,1,0};
+ Assert.AreEqual ("-00000000002147,4,83,648", Int32.MinValue.ToString ("0000000000,0000000000", nfi), "#01");
+ }
+
+ [Test]
+ public void Test08090 ()
+ {
+ // MS.NET bug?
+ NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
+ nfi.PercentSymbol = "$$$";
+ Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
+ }
+
+ [Test]
+ public void Test08091 ()
+ {
+ // MS.NET bug?
+ Assert.AreEqual ("B2147", Int32.MinValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi), "#01");
+ Assert.AreEqual ("A2147484", Int32.MaxValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi), "#02");
+ Assert.AreEqual ("C0", 0.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi), "#03");
+ }
+
+ // Test10000- Double and D
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Test10000 ()
+ {
+ Assert.AreEqual ("0", 0.0.ToString ("D", _nfi), "#01");
+ }
+
+ // Test11000- Double and E
+ [Test]
+ public void Test11000 ()
+ {
+ Assert.AreEqual ("0.000000E+000", 0.0.ToString ("E", _nfi), "#01");
+ Assert.AreEqual ("0.000000e+000", 0.0.ToString ("e", _nfi), "#02");
+ Assert.AreEqual ("-1.797693E+308", Double.MinValue.ToString ("E", _nfi), "#03");
+ Assert.AreEqual ("-1.797693e+308", Double.MinValue.ToString ("e", _nfi), "#04");
+ Assert.AreEqual ("1.797693E+308", Double.MaxValue.ToString ("E", _nfi), "#05");
+ Assert.AreEqual ("1.797693e+308", Double.MaxValue.ToString ("e", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test11001 ()
+ {
+ Assert.AreEqual ("E ", 0.0.ToString ("E ", _nfi), "#01");
+ Assert.AreEqual (" E", 0.0.ToString (" E", _nfi), "#02");
+ Assert.AreEqual (" E ", 0.0.ToString (" E ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11002 ()
+ {
+ Assert.AreEqual ("-E ", (-1.0).ToString ("E ", _nfi), "#01");
+ Assert.AreEqual ("- E", (-1.0).ToString (" E", _nfi), "#02");
+ Assert.AreEqual ("- E ", (-1.0).ToString (" E ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11003 ()
+ {
+ Assert.AreEqual ("0E+000", 0.0.ToString ("E0", _nfi), "#01");
+ Assert.AreEqual ("0.0000000000000000E+000", 0.0.ToString ("E16", _nfi), "#02");
+ Assert.AreEqual ("0.00000000000000000E+000", 0.0.ToString ("E17", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.0.ToString ("E99", _nfi), "#04");
+ Assert.AreEqual ("E100", 0.0.ToString ("E100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test11004 ()
+ {
+ Assert.AreEqual ("2E+308", Double.MaxValue.ToString ("E0", _nfi), "#01");
+ Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("E16", _nfi), "#02");
+ Assert.AreEqual ("1.79769313486231570E+308", Double.MaxValue.ToString ("E17", _nfi), "#03");
+ Assert.AreEqual ("1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MaxValue.ToString ("E99", _nfi), "#04");
+ Assert.AreEqual ("E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("E100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test11005 ()
+ {
+ Assert.AreEqual ("-2E+308", Double.MinValue.ToString ("E0", _nfi), "#01");
+ Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("E16", _nfi), "#02");
+ Assert.AreEqual ("-1.79769313486231570E+308", Double.MinValue.ToString ("E17", _nfi), "#03");
+ Assert.AreEqual ("-1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MinValue.ToString ("E99", _nfi), "#04");
+ Assert.AreEqual ("-E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("E100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test11006 ()
+ {
+ Assert.AreEqual ("EF", 0.0.ToString ("EF", _nfi), "#01");
+ Assert.AreEqual ("E0F", 0.0.ToString ("E0F", _nfi), "#02");
+ Assert.AreEqual ("E0xF", 0.0.ToString ("E0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11007 ()
+ {
+ Assert.AreEqual ("EF", Double.MaxValue.ToString ("EF", _nfi), "#01");
+ Assert.AreEqual ("E0F", Double.MaxValue.ToString ("E0F", _nfi), "#02");
+ Assert.AreEqual ("E0xF", Double.MaxValue.ToString ("E0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11008 ()
+ {
+ Assert.AreEqual ("-EF", Double.MinValue.ToString ("EF", _nfi), "#01");
+ Assert.AreEqual ("E0F", Double.MinValue.ToString ("E0F", _nfi), "#02");
+ Assert.AreEqual ("E0xF", Double.MinValue.ToString ("E0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11009 ()
+ {
+ Assert.AreEqual ("0.00000000000000000E+000", 0.0.ToString ("E0000000000000000000000000000000000000017", _nfi), "#01");
+ Assert.AreEqual ("1.79769313486231570E+308", Double.MaxValue.ToString ("E0000000000000000000000000000000000000017", _nfi), "#02");
+ Assert.AreEqual ("-1.79769313486231570E+308", Double.MinValue.ToString ("E0000000000000000000000000000000000000017", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11010 ()
+ {
+ Assert.AreEqual ("+E", 0.0.ToString ("+E", _nfi), "#01");
+ Assert.AreEqual ("E+", 0.0.ToString ("E+", _nfi), "#02");
+ Assert.AreEqual ("+E+", 0.0.ToString ("+E+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11011 ()
+ {
+ Assert.AreEqual ("+E", Double.MaxValue.ToString ("+E", _nfi), "#01");
+ Assert.AreEqual ("E+", Double.MaxValue.ToString ("E+", _nfi), "#02");
+ Assert.AreEqual ("+E+", Double.MaxValue.ToString ("+E+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11012 ()
+ {
+ Assert.AreEqual ("-+E", Double.MinValue.ToString ("+E", _nfi), "#01");
+ Assert.AreEqual ("-E+", Double.MinValue.ToString ("E+", _nfi), "#02");
+ Assert.AreEqual ("-+E+", Double.MinValue.ToString ("+E+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11013 ()
+ {
+ Assert.AreEqual ("-E", 0.0.ToString ("-E", _nfi), "#01");
+ Assert.AreEqual ("E-", 0.0.ToString ("E-", _nfi), "#02");
+ Assert.AreEqual ("-E-", 0.0.ToString ("-E-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11014 ()
+ {
+ Assert.AreEqual ("-E", Double.MaxValue.ToString ("-E", _nfi), "#01");
+ Assert.AreEqual ("E-", Double.MaxValue.ToString ("E-", _nfi), "#02");
+ Assert.AreEqual ("-E-", Double.MaxValue.ToString ("-E-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11015 ()
+ {
+ Assert.AreEqual ("--E", Double.MinValue.ToString ("-E", _nfi), "#01");
+ Assert.AreEqual ("-E-", Double.MinValue.ToString ("E-", _nfi), "#02");
+ Assert.AreEqual ("--E-", Double.MinValue.ToString ("-E-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11016 ()
+ {
+ Assert.AreEqual ("E+0", 0.0.ToString ("E+0", _nfi), "#01");
+ Assert.AreEqual ("E+0", Double.MaxValue.ToString ("E+0", _nfi), "#02");
+ Assert.AreEqual ("E+0", Double.MinValue.ToString ("E+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11017 ()
+ {
+ Assert.AreEqual ("E+9", 0.0.ToString ("E+9", _nfi), "#01");
+ Assert.AreEqual ("E+9", Double.MaxValue.ToString ("E+9", _nfi), "#02");
+ Assert.AreEqual ("-E+9", Double.MinValue.ToString ("E+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11018 ()
+ {
+ Assert.AreEqual ("E-9", 0.0.ToString ("E-9", _nfi), "#01");
+ Assert.AreEqual ("E-9", Double.MaxValue.ToString ("E-9", _nfi), "#02");
+ Assert.AreEqual ("-E-9", Double.MinValue.ToString ("E-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11019 ()
+ {
+ Assert.AreEqual ("E0", 0.0.ToString ("E0,", _nfi), "#01");
+ Assert.AreEqual ("E0", Double.MaxValue.ToString ("E0,", _nfi), "#02");
+ Assert.AreEqual ("E0", Double.MinValue.ToString ("E0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11020 ()
+ {
+ Assert.AreEqual ("E0", 0.0.ToString ("E0.", _nfi), "#01");
+ Assert.AreEqual ("E0", Double.MaxValue.ToString ("E0.", _nfi), "#02");
+ Assert.AreEqual ("E0", Double.MinValue.ToString ("E0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11021 ()
+ {
+ Assert.AreEqual ("E0.0", 0.0.ToString ("E0.0", _nfi), "#01");
+ Assert.AreEqual ("E309.2", Double.MaxValue.ToString ("E0.0", _nfi), "#02");
+ Assert.AreEqual ("-E309.2", Double.MinValue.ToString ("E0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11022 ()
+ {
+ Assert.AreEqual ("E09", 0.0.ToString ("E0.9", _nfi), "#01");
+ Assert.AreEqual ("E09", Double.MaxValue.ToString ("E0.9", _nfi), "#02");
+ Assert.AreEqual ("E09", Double.MinValue.ToString ("E0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test11023 ()
+ {
+ Assert.AreEqual ("1.1E+000", 1.05.ToString ("E1", _nfi), "#01");
+ Assert.AreEqual ("1.2E+000", 1.15.ToString ("E1", _nfi), "#02");
+ Assert.AreEqual ("1.3E+000", 1.25.ToString ("E1", _nfi), "#03");
+ Assert.AreEqual ("1.4E+000", 1.35.ToString ("E1", _nfi), "#04");
+ Assert.AreEqual ("1.5E+000", 1.45.ToString ("E1", _nfi), "#05");
+ Assert.AreEqual ("1.6E+000", 1.55.ToString ("E1", _nfi), "#06");
+ Assert.AreEqual ("1.7E+000", 1.65.ToString ("E1", _nfi), "#07");
+ Assert.AreEqual ("1.8E+000", 1.75.ToString ("E1", _nfi), "#08");
+ Assert.AreEqual ("1.9E+000", 1.85.ToString ("E1", _nfi), "#09");
+ Assert.AreEqual ("2.0E+000", 1.95.ToString ("E1", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test11024 ()
+ {
+ Assert.AreEqual ("1.01E+000", 1.005.ToString ("E2", _nfi), "#01");
+ Assert.AreEqual ("1.02E+000", 1.015.ToString ("E2", _nfi), "#02");
+ Assert.AreEqual ("1.03E+000", 1.025.ToString ("E2", _nfi), "#03");
+ Assert.AreEqual ("1.04E+000", 1.035.ToString ("E2", _nfi), "#04");
+ Assert.AreEqual ("1.05E+000", 1.045.ToString ("E2", _nfi), "#05");
+ Assert.AreEqual ("1.06E+000", 1.055.ToString ("E2", _nfi), "#06");
+ Assert.AreEqual ("1.07E+000", 1.065.ToString ("E2", _nfi), "#07");
+ Assert.AreEqual ("1.08E+000", 1.075.ToString ("E2", _nfi), "#08");
+ Assert.AreEqual ("1.09E+000", 1.085.ToString ("E2", _nfi), "#09");
+ Assert.AreEqual ("1.10E+000", 1.095.ToString ("E2", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test11025 ()
+ {
+ Assert.AreEqual ("1.00000000000001E+000", 1.000000000000005.ToString ("E14", _nfi), "#01");
+ Assert.AreEqual ("1.00000000000002E+000", 1.000000000000015.ToString ("E14", _nfi), "#02");
+ Assert.AreEqual ("1.00000000000003E+000", 1.000000000000025.ToString ("E14", _nfi), "#03");
+ Assert.AreEqual ("1.00000000000004E+000", 1.000000000000035.ToString ("E14", _nfi), "#04");
+ Assert.AreEqual ("1.00000000000005E+000", 1.000000000000045.ToString ("E14", _nfi), "#05");
+ Assert.AreEqual ("1.00000000000006E+000", 1.000000000000055.ToString ("E14", _nfi), "#06");
+ Assert.AreEqual ("1.00000000000007E+000", 1.000000000000065.ToString ("E14", _nfi), "#07");
+ Assert.AreEqual ("1.00000000000008E+000", 1.000000000000075.ToString ("E14", _nfi), "#08");
+ Assert.AreEqual ("1.00000000000009E+000", 1.000000000000085.ToString ("E14", _nfi), "#09");
+ Assert.AreEqual ("1.00000000000010E+000", 1.000000000000095.ToString ("E14", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test11026 ()
+ {
+ Assert.AreEqual ("1.000000000000000E+000", 1.0000000000000005.ToString ("E15", _nfi), "#01");
+ Assert.AreEqual ("1.000000000000002E+000", 1.0000000000000015.ToString ("E15", _nfi), "#02");
+ Assert.AreEqual ("1.000000000000002E+000", 1.0000000000000025.ToString ("E15", _nfi), "#03");
+ Assert.AreEqual ("1.000000000000004E+000", 1.0000000000000035.ToString ("E15", _nfi), "#04");
+ Assert.AreEqual ("1.000000000000004E+000", 1.0000000000000045.ToString ("E15", _nfi), "#05");
+ Assert.AreEqual ("1.000000000000006E+000", 1.0000000000000055.ToString ("E15", _nfi), "#06");
+ Assert.AreEqual ("1.000000000000006E+000", 1.0000000000000065.ToString ("E15", _nfi), "#07");
+ Assert.AreEqual ("1.000000000000008E+000", 1.0000000000000075.ToString ("E15", _nfi), "#08");
+ Assert.AreEqual ("1.000000000000008E+000", 1.0000000000000085.ToString ("E15", _nfi), "#09");
+ Assert.AreEqual ("1.000000000000010E+000", 1.0000000000000095.ToString ("E15", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test11027 ()
+ {
+ Assert.AreEqual ("1.0000000000000000E+000", 1.00000000000000005.ToString ("E16", _nfi), "#01");
+ Assert.AreEqual ("1.0000000000000002E+000", 1.00000000000000015.ToString ("E16", _nfi), "#02");
+ Assert.AreEqual ("1.0000000000000002E+000", 1.00000000000000025.ToString ("E16", _nfi), "#03");
+ Assert.AreEqual ("1.0000000000000004E+000", 1.00000000000000035.ToString ("E16", _nfi), "#04");
+ Assert.AreEqual ("1.0000000000000004E+000", 1.00000000000000045.ToString ("E16", _nfi), "#05");
+ Assert.AreEqual ("1.0000000000000004E+000", 1.00000000000000055.ToString ("E16", _nfi), "#06");
+ Assert.AreEqual ("1.0000000000000007E+000", 1.00000000000000065.ToString ("E16", _nfi), "#07");
+ Assert.AreEqual ("1.0000000000000007E+000", 1.00000000000000075.ToString ("E16", _nfi), "#08");
+ Assert.AreEqual ("1.0000000000000009E+000", 1.00000000000000085.ToString ("E16", _nfi), "#09");
+ Assert.AreEqual ("1.0000000000000009E+000", 1.00000000000000095.ToString ("E16", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test11028 ()
+ {
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000005.ToString ("E17", _nfi), "#01");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000015.ToString ("E17", _nfi), "#02");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000025.ToString ("E17", _nfi), "#03");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000035.ToString ("E17", _nfi), "#04");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000045.ToString ("E17", _nfi), "#05");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000055.ToString ("E17", _nfi), "#06");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000065.ToString ("E17", _nfi), "#07");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000075.ToString ("E17", _nfi), "#08");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000085.ToString ("E17", _nfi), "#09");
+ Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000095.ToString ("E17", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test11029 ()
+ {
+ Assert.AreEqual ("1E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E0"), "#01");
+ Assert.AreEqual ("1.2345678901234567E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E16"), "#02");
+ Assert.AreEqual ("1.23456789012345670E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E17"), "#03");
+ Assert.AreEqual ("1.234567890123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E99"), "#04");
+ Assert.AreEqual ("E101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E100"), "#04");
+ }
+
+ [Test]
+ public void Test11030 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("-1#000000E+008", (-99999999.9).ToString ("E", nfi), "#01");
+ }
+
+ [Test]
+ public void Test11031 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+
+ Assert.AreEqual ("1.000000E-000", 1.0.ToString ("E", nfi), "#01");
+ Assert.AreEqual ("0.000000E-000", 0.0.ToString ("E", nfi), "#02");
+ Assert.AreEqual ("+1.000000E-000", (-1.0).ToString ("E", nfi), "#03");
+ }
+
+ [Test]
+ public void TestNaNToString ()
+ {
+ var nfi = CultureInfo.CurrentCulture.NumberFormat;
+ Assert.AreEqual (nfi.PositiveInfinitySymbol, Double.PositiveInfinity.ToString(), "#01");
+ Assert.AreEqual (nfi.NegativeInfinitySymbol, Double.NegativeInfinity.ToString(), "#02");
+ Assert.AreEqual (nfi.NaNSymbol, Double.NaN.ToString(), "#03");
+ Assert.AreEqual (nfi.PositiveInfinitySymbol, Single.PositiveInfinity.ToString(), "#04");
+ Assert.AreEqual (nfi.NegativeInfinitySymbol, Single.NegativeInfinity.ToString(), "#05");
+ Assert.AreEqual (nfi.NaNSymbol, Single.NaN.ToString(), "#06");
+
+ Assert.AreEqual (nfi.PositiveInfinitySymbol, Double.PositiveInfinity.ToString("R"), "#07");
+ Assert.AreEqual (nfi.NegativeInfinitySymbol, Double.NegativeInfinity.ToString("R"), "#08");
+ Assert.AreEqual (nfi.NaNSymbol, Double.NaN.ToString("R"), "#09");
+ Assert.AreEqual (nfi.PositiveInfinitySymbol, Single.PositiveInfinity.ToString("R"), "#10");
+ Assert.AreEqual (nfi.NegativeInfinitySymbol, Single.NegativeInfinity.ToString("R"), "#11");
+ Assert.AreEqual (nfi.NaNSymbol, Single.NaN.ToString("R"), "#12");
+ }
+
+ [Test]
+ public void Test11032 ()
+ {
+ Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("E99", _nfi) , "#01");
+ Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("E99", _nfi) , "#02");
+ Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("E99", _nfi) , "#03");
+ }
+
+ // Test12000- Double and F
+ [Test]
+ public void Test12000 ()
+ {
+ Assert.AreEqual ("0.00", 0.0.ToString ("F", _nfi), "#01");
+ Assert.AreEqual ("0.00", 0.0.ToString ("f", _nfi), "#02");
+ Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("F", _nfi), "#03");
+ Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("f", _nfi), "#04");
+ Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("F", _nfi), "#05");
+ Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("f", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test12001 ()
+ {
+ Assert.AreEqual ("F ", 0.0.ToString ("F ", _nfi), "#01");
+ Assert.AreEqual (" F", 0.0.ToString (" F", _nfi), "#02");
+ Assert.AreEqual (" F ", 0.0.ToString (" F ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12002 ()
+ {
+ Assert.AreEqual ("-F ", (-1.0).ToString ("F ", _nfi), "#01");
+ Assert.AreEqual ("- F", (-1.0).ToString (" F", _nfi), "#02");
+ Assert.AreEqual ("- F ", (-1.0).ToString (" F ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12003 ()
+ {
+ Assert.AreEqual ("0", 0.0.ToString ("F0", _nfi), "#01");
+ Assert.AreEqual ("0.0000000000000000", 0.0.ToString ("F16", _nfi), "#02");
+ Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("F17", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("F99", _nfi), "#04");
+ Assert.AreEqual ("F100", 0.0.ToString ("F100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test12004 ()
+ {
+ Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0", _nfi), "#01");
+ Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MaxValue.ToString ("F16", _nfi), "#02");
+ Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F17", _nfi), "#03");
+ Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F99", _nfi), "#04");
+ Assert.AreEqual ("F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test12005 ()
+ {
+ Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0", _nfi), "#01");
+ Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MinValue.ToString ("F16", _nfi), "#02");
+ Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F17", _nfi), "#03");
+ Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F99", _nfi), "#04");
+ Assert.AreEqual ("-F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test12006 ()
+ {
+ Assert.AreEqual ("FF", 0.0.ToString ("FF", _nfi), "#01");
+ Assert.AreEqual ("F0F", 0.0.ToString ("F0F", _nfi), "#02");
+ Assert.AreEqual ("F0xF", 0.0.ToString ("F0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12007 ()
+ {
+ Assert.AreEqual ("FF", Double.MaxValue.ToString ("FF", _nfi), "#01");
+ Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("F0F", _nfi), "#02");
+ Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("F0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12008 ()
+ {
+ Assert.AreEqual ("-FF", Double.MinValue.ToString ("FF", _nfi), "#01");
+ Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("F0F", _nfi), "#02");
+ Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("F0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12009 ()
+ {
+ Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("F0000000000000000000000000000000000000017", _nfi), "#01");
+ Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F0000000000000000000000000000000000000017", _nfi), "#02");
+ Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F0000000000000000000000000000000000000017", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12010 ()
+ {
+ Assert.AreEqual ("+F", 0.0.ToString ("+F", _nfi), "#01");
+ Assert.AreEqual ("F+", 0.0.ToString ("F+", _nfi), "#02");
+ Assert.AreEqual ("+F+", 0.0.ToString ("+F+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12011 ()
+ {
+ Assert.AreEqual ("+F", Double.MaxValue.ToString ("+F", _nfi), "#01");
+ Assert.AreEqual ("F+", Double.MaxValue.ToString ("F+", _nfi), "#02");
+ Assert.AreEqual ("+F+", Double.MaxValue.ToString ("+F+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12012 ()
+ {
+ Assert.AreEqual ("-+F", Double.MinValue.ToString ("+F", _nfi), "#01");
+ Assert.AreEqual ("-F+", Double.MinValue.ToString ("F+", _nfi), "#02");
+ Assert.AreEqual ("-+F+", Double.MinValue.ToString ("+F+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12013 ()
+ {
+ Assert.AreEqual ("-F", 0.0.ToString ("-F", _nfi), "#01");
+ Assert.AreEqual ("F-", 0.0.ToString ("F-", _nfi), "#02");
+ Assert.AreEqual ("-F-", 0.0.ToString ("-F-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12014 ()
+ {
+ Assert.AreEqual ("-F", Double.MaxValue.ToString ("-F", _nfi), "#01");
+ Assert.AreEqual ("F-", Double.MaxValue.ToString ("F-", _nfi), "#02");
+ Assert.AreEqual ("-F-", Double.MaxValue.ToString ("-F-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12015 ()
+ {
+ Assert.AreEqual ("--F", Double.MinValue.ToString ("-F", _nfi), "#01");
+ Assert.AreEqual ("-F-", Double.MinValue.ToString ("F-", _nfi), "#02");
+ Assert.AreEqual ("--F-", Double.MinValue.ToString ("-F-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12016 ()
+ {
+ Assert.AreEqual ("F+0", 0.0.ToString ("F+0", _nfi), "#01");
+ Assert.AreEqual ("F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F+0", _nfi), "#02");
+ Assert.AreEqual ("-F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12017 ()
+ {
+ Assert.AreEqual ("F+9", 0.0.ToString ("F+9", _nfi), "#01");
+ Assert.AreEqual ("F+9", Double.MaxValue.ToString ("F+9", _nfi), "#02");
+ Assert.AreEqual ("-F+9", Double.MinValue.ToString ("F+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12018 ()
+ {
+ Assert.AreEqual ("F-9", 0.0.ToString ("F-9", _nfi), "#01");
+ Assert.AreEqual ("F-9", Double.MaxValue.ToString ("F-9", _nfi), "#02");
+ Assert.AreEqual ("-F-9", Double.MinValue.ToString ("F-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12019 ()
+ {
+ Assert.AreEqual ("F0", 0.0.ToString ("F0,", _nfi), "#01");
+ Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0,", _nfi), "#02");
+ Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12020 ()
+ {
+ Assert.AreEqual ("F0", 0.0.ToString ("F0.", _nfi), "#01");
+ Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0.", _nfi), "#02");
+ Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12021 ()
+ {
+ Assert.AreEqual ("F0.0", 0.0.ToString ("F0.0", _nfi), "#01");
+ Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("F0.0", _nfi), "#02");
+ Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("F0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12022 ()
+ {
+ Assert.AreEqual ("F09", 0.0.ToString ("F0.9", _nfi), "#01");
+ Assert.AreEqual ("F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("F0.9", _nfi), "#02");
+ Assert.AreEqual ("-F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("F0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test12023 ()
+ {
+ Assert.AreEqual ("1.1", 1.05.ToString ("F1", _nfi), "#01");
+ Assert.AreEqual ("1.2", 1.15.ToString ("F1", _nfi), "#02");
+ Assert.AreEqual ("1.3", 1.25.ToString ("F1", _nfi), "#03");
+ Assert.AreEqual ("1.4", 1.35.ToString ("F1", _nfi), "#04");
+ Assert.AreEqual ("1.5", 1.45.ToString ("F1", _nfi), "#05");
+ Assert.AreEqual ("1.6", 1.55.ToString ("F1", _nfi), "#06");
+ Assert.AreEqual ("1.7", 1.65.ToString ("F1", _nfi), "#07");
+ Assert.AreEqual ("1.8", 1.75.ToString ("F1", _nfi), "#08");
+ Assert.AreEqual ("1.9", 1.85.ToString ("F1", _nfi), "#09");
+ Assert.AreEqual ("2.0", 1.95.ToString ("F1", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test12024 ()
+ {
+ Assert.AreEqual ("1.01", 1.005.ToString ("F2", _nfi), "#01");
+ Assert.AreEqual ("1.02", 1.015.ToString ("F2", _nfi), "#02");
+ Assert.AreEqual ("1.03", 1.025.ToString ("F2", _nfi), "#03");
+ Assert.AreEqual ("1.04", 1.035.ToString ("F2", _nfi), "#04");
+ Assert.AreEqual ("1.05", 1.045.ToString ("F2", _nfi), "#05");
+ Assert.AreEqual ("1.06", 1.055.ToString ("F2", _nfi), "#06");
+ Assert.AreEqual ("1.07", 1.065.ToString ("F2", _nfi), "#07");
+ Assert.AreEqual ("1.08", 1.075.ToString ("F2", _nfi), "#08");
+ Assert.AreEqual ("1.09", 1.085.ToString ("F2", _nfi), "#09");
+ Assert.AreEqual ("1.10", 1.095.ToString ("F2", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test12025 ()
+ {
+ Assert.AreEqual ("1.00000000000001", 1.000000000000005.ToString ("F14", _nfi), "#01");
+ Assert.AreEqual ("1.00000000000002", 1.000000000000015.ToString ("F14", _nfi), "#02");
+ Assert.AreEqual ("1.00000000000003", 1.000000000000025.ToString ("F14", _nfi), "#03");
+ Assert.AreEqual ("1.00000000000004", 1.000000000000035.ToString ("F14", _nfi), "#04");
+ Assert.AreEqual ("1.00000000000005", 1.000000000000045.ToString ("F14", _nfi), "#05");
+ Assert.AreEqual ("1.00000000000006", 1.000000000000055.ToString ("F14", _nfi), "#06");
+ Assert.AreEqual ("1.00000000000007", 1.000000000000065.ToString ("F14", _nfi), "#07");
+ Assert.AreEqual ("1.00000000000008", 1.000000000000075.ToString ("F14", _nfi), "#08");
+ Assert.AreEqual ("1.00000000000009", 1.000000000000085.ToString ("F14", _nfi), "#09");
+ Assert.AreEqual ("1.00000000000010", 1.000000000000095.ToString ("F14", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test12026 ()
+ {
+ Assert.AreEqual ("1.000000000000000", 1.0000000000000005.ToString ("F15", _nfi), "#01");
+ Assert.AreEqual ("1.000000000000000", 1.0000000000000015.ToString ("F15", _nfi), "#02");
+ Assert.AreEqual ("1.000000000000000", 1.0000000000000025.ToString ("F15", _nfi), "#03");
+ Assert.AreEqual ("1.000000000000000", 1.0000000000000035.ToString ("F15", _nfi), "#04");
+ Assert.AreEqual ("1.000000000000000", 1.0000000000000045.ToString ("F15", _nfi), "#05");
+ Assert.AreEqual ("1.000000000000010", 1.0000000000000055.ToString ("F15", _nfi), "#06");
+ Assert.AreEqual ("1.000000000000010", 1.0000000000000065.ToString ("F15", _nfi), "#07");
+ Assert.AreEqual ("1.000000000000010", 1.0000000000000075.ToString ("F15", _nfi), "#08");
+ Assert.AreEqual ("1.000000000000010", 1.0000000000000085.ToString ("F15", _nfi), "#09");
+ Assert.AreEqual ("1.000000000000010", 1.0000000000000095.ToString ("F15", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test12027 ()
+ {
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000005.ToString ("F16", _nfi), "#01");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000015.ToString ("F16", _nfi), "#02");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000025.ToString ("F16", _nfi), "#03");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000035.ToString ("F16", _nfi), "#04");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000045.ToString ("F16", _nfi), "#05");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000055.ToString ("F16", _nfi), "#06");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000065.ToString ("F16", _nfi), "#07");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000075.ToString ("F16", _nfi), "#08");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000085.ToString ("F16", _nfi), "#09");
+ Assert.AreEqual ("1.0000000000000000", 1.00000000000000095.ToString ("F16", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test12028 ()
+ {
+ Assert.AreEqual ("1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F0", _nfi), "#01");
+ Assert.AreEqual ("1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F12", _nfi), "#02");
+ Assert.AreEqual ("1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F13", _nfi), "#03");
+ Assert.AreEqual ("1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F14", _nfi), "#04");
+ Assert.AreEqual ("1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F15", _nfi), "#05");
+ Assert.AreEqual ("1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F99", _nfi), "#06");
+ Assert.AreEqual ("F101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F100", _nfi), "#07");
+ }
+
+ [Test]
+ public void Test12029 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("-99999999#90", (-99999999.9).ToString ("F", nfi), "#01");
+ }
+
+ [Test]
+ public void Test12030 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+
+ Assert.AreEqual ("1.00", 1.0.ToString ("F", nfi), "#01");
+ Assert.AreEqual ("0.00", 0.0.ToString ("F", nfi), "#02");
+ Assert.AreEqual ("+1.00", (-1.0).ToString ("F", nfi), "#03");
+ }
+
+ [Test]
+ public void Test12031 ()
+ {
+ Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("F99", _nfi) , "#01");
+ Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("F99", _nfi) , "#02");
+ Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("F99", _nfi) , "#03");
+ }
+
+ // Test13000- Double and G
+ [Test]
+ public void Test13000 ()
+ {
+ Assert.AreEqual ("0", 0.0.ToString ("G", _nfi), "#01");
+ Assert.AreEqual ("0", (-0.0).ToString ("G", _nfi), "#01.1");
+ Assert.AreEqual ("0", 0.0.ToString ("g", _nfi), "#02");
+ Assert.AreEqual ("-1.79769313486232E+308", Double.MinValue.ToString ("G", _nfi), "#03");
+ Assert.AreEqual ("-1.79769313486232e+308", Double.MinValue.ToString ("g", _nfi), "#04");
+ Assert.AreEqual ("1.79769313486232E+308", Double.MaxValue.ToString ("G", _nfi), "#05");
+ Assert.AreEqual ("1.79769313486232e+308", Double.MaxValue.ToString ("g", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test13001 ()
+ {
+ Assert.AreEqual ("G ", 0.0.ToString ("G ", _nfi), "#01");
+ Assert.AreEqual (" G", 0.0.ToString (" G", _nfi), "#02");
+ Assert.AreEqual (" G ", 0.0.ToString (" G ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13002 ()
+ {
+ Assert.AreEqual ("-G ", (-1.0).ToString ("G ", _nfi), "#01");
+ Assert.AreEqual ("- G", (-1.0).ToString (" G", _nfi), "#02");
+ Assert.AreEqual ("- G ", (-1.0).ToString (" G ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13003 ()
+ {
+ Assert.AreEqual ("0", 0.0.ToString ("G0", _nfi), "#01");
+ Assert.AreEqual ("0", 0.0.ToString ("G16", _nfi), "#02");
+ Assert.AreEqual ("0", 0.0.ToString ("G17", _nfi), "#03");
+ Assert.AreEqual ("0", 0.0.ToString ("G99", _nfi), "#04");
+ Assert.AreEqual ("G100", 0.0.ToString ("G100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test13004 ()
+ {
+ Assert.AreEqual ("1.79769313486232E+308", Double.MaxValue.ToString ("G0", _nfi), "#01");
+ Assert.AreEqual ("1.797693134862316E+308", Double.MaxValue.ToString ("G16", _nfi), "#02");
+ Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("G17", _nfi), "#03");
+ Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("G99", _nfi), "#04");
+ Assert.AreEqual ("G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test13005 ()
+ {
+ Assert.AreEqual ("-1.79769313486232E+308", Double.MinValue.ToString ("G0", _nfi), "#01");
+ Assert.AreEqual ("-1.797693134862316E+308", Double.MinValue.ToString ("G16", _nfi), "#02");
+ Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("G17", _nfi), "#03");
+ Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("G99", _nfi), "#04");
+ Assert.AreEqual ("-G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test13006 ()
+ {
+ Assert.AreEqual ("GF", 0.0.ToString ("GF", _nfi), "#01");
+ Assert.AreEqual ("G0F", 0.0.ToString ("G0F", _nfi), "#02");
+ Assert.AreEqual ("G0xF", 0.0.ToString ("G0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13007 ()
+ {
+ Assert.AreEqual ("GF", Double.MaxValue.ToString ("GF", _nfi), "#01");
+ Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("G0F", _nfi), "#02");
+ Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("G0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13008 ()
+ {
+ Assert.AreEqual ("-GF", Double.MinValue.ToString ("GF", _nfi), "#01");
+ Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("G0F", _nfi), "#02");
+ Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("G0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13009 ()
+ {
+ Assert.AreEqual ("0", 0.0.ToString ("G0000000000000000000000000000000000000017", _nfi), "#01");
+ Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("G0000000000000000000000000000000000000017", _nfi), "#02");
+ Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("G0000000000000000000000000000000000000017", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13010 ()
+ {
+ Assert.AreEqual ("+G", 0.0.ToString ("+G", _nfi), "#01");
+ Assert.AreEqual ("G+", 0.0.ToString ("G+", _nfi), "#02");
+ Assert.AreEqual ("+G+", 0.0.ToString ("+G+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13011 ()
+ {
+ Assert.AreEqual ("+G", Double.MaxValue.ToString ("+G", _nfi), "#01");
+ Assert.AreEqual ("G+", Double.MaxValue.ToString ("G+", _nfi), "#02");
+ Assert.AreEqual ("+G+", Double.MaxValue.ToString ("+G+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13012 ()
+ {
+ Assert.AreEqual ("-+G", Double.MinValue.ToString ("+G", _nfi), "#01");
+ Assert.AreEqual ("-G+", Double.MinValue.ToString ("G+", _nfi), "#02");
+ Assert.AreEqual ("-+G+", Double.MinValue.ToString ("+G+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13013 ()
+ {
+ Assert.AreEqual ("-G", 0.0.ToString ("-G", _nfi), "#01");
+ Assert.AreEqual ("G-", 0.0.ToString ("G-", _nfi), "#02");
+ Assert.AreEqual ("-G-", 0.0.ToString ("-G-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13014 ()
+ {
+ Assert.AreEqual ("-G", Double.MaxValue.ToString ("-G", _nfi), "#01");
+ Assert.AreEqual ("G-", Double.MaxValue.ToString ("G-", _nfi), "#02");
+ Assert.AreEqual ("-G-", Double.MaxValue.ToString ("-G-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13015 ()
+ {
+ Assert.AreEqual ("--G", Double.MinValue.ToString ("-G", _nfi), "#01");
+ Assert.AreEqual ("-G-", Double.MinValue.ToString ("G-", _nfi), "#02");
+ Assert.AreEqual ("--G-", Double.MinValue.ToString ("-G-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13016 ()
+ {
+ Assert.AreEqual ("G+0", 0.0.ToString ("G+0", _nfi), "#01");
+ Assert.AreEqual ("G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G+0", _nfi), "#02");
+ Assert.AreEqual ("-G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13017 ()
+ {
+ Assert.AreEqual ("G+9", 0.0.ToString ("G+9", _nfi), "#01");
+ Assert.AreEqual ("G+9", Double.MaxValue.ToString ("G+9", _nfi), "#02");
+ Assert.AreEqual ("-G+9", Double.MinValue.ToString ("G+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13018 ()
+ {
+ Assert.AreEqual ("G-9", 0.0.ToString ("G-9", _nfi), "#01");
+ Assert.AreEqual ("G-9", Double.MaxValue.ToString ("G-9", _nfi), "#02");
+ Assert.AreEqual ("-G-9", Double.MinValue.ToString ("G-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13019 ()
+ {
+ Assert.AreEqual ("G0", 0.0.ToString ("G0,", _nfi), "#01");
+ Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0,", _nfi), "#02");
+ Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13020 ()
+ {
+ Assert.AreEqual ("G0", 0.0.ToString ("G0.", _nfi), "#01");
+ Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0.", _nfi), "#02");
+ Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13021 ()
+ {
+ Assert.AreEqual ("G0.0", 0.0.ToString ("G0.0", _nfi), "#01");
+ Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("G0.0", _nfi), "#02");
+ Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("G0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13022 ()
+ {
+ Assert.AreEqual ("G09", 0.0.ToString ("G0.9", _nfi), "#01");
+ Assert.AreEqual ("G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("G0.9", _nfi), "#02");
+ Assert.AreEqual ("-G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("G0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test13023 ()
+ {
+ Assert.AreEqual ("0.5", 0.5.ToString ("G1", _nfi), "#01");
+ Assert.AreEqual ("2", 1.5.ToString ("G1", _nfi), "#02");
+ Assert.AreEqual ("3", 2.5.ToString ("G1", _nfi), "#03");
+ Assert.AreEqual ("4", 3.5.ToString ("G1", _nfi), "#04");
+ Assert.AreEqual ("5", 4.5.ToString ("G1", _nfi), "#05");
+ Assert.AreEqual ("6", 5.5.ToString ("G1", _nfi), "#06");
+ Assert.AreEqual ("7", 6.5.ToString ("G1", _nfi), "#07");
+ Assert.AreEqual ("8", 7.5.ToString ("G1", _nfi), "#08");
+ Assert.AreEqual ("9", 8.5.ToString ("G1", _nfi), "#09");
+ Assert.AreEqual ("1E+01", 9.5.ToString ("G1", _nfi), "#10");
+ }
+
+ [Test]
public void Test13024_CarryPropagation ()
{
- Double d = 1.15;\r
- AssertEquals ("#01", "1", d.ToString ("G1", _nfi));\r
+ Double d = 1.15;
+ Assert.AreEqual ("1", d.ToString ("G1", _nfi), "#01");
// NumberStore converts 1.15 into 1.14999...91 (1 in index 17)
- // so the call to NumberToString doesn't result in 1.2 but in 1.1\r
+ // so the call to NumberToString doesn't result in 1.2 but in 1.1
// which seems "somewhat" normal considering the #17 results,
- AssertEquals ("#02", "1.2", d.ToString ("G2", _nfi));\r
- AssertEquals ("#03", "1.15", d.ToString ("G3", _nfi));\r
- AssertEquals ("#04", "1.15", d.ToString ("G4", _nfi));\r
- AssertEquals ("#05", "1.15", d.ToString ("G5", _nfi));\r
- AssertEquals ("#06", "1.15", d.ToString ("G6", _nfi));\r
- AssertEquals ("#07", "1.15", d.ToString ("G7", _nfi));\r
- AssertEquals ("#08", "1.15", d.ToString ("G8", _nfi));\r
- AssertEquals ("#09", "1.15", d.ToString ("G9", _nfi));\r
- AssertEquals ("#10", "1.15", d.ToString ("G10", _nfi));\r
- AssertEquals ("#11", "1.15", d.ToString ("G11", _nfi));\r
- AssertEquals ("#12", "1.15", d.ToString ("G12", _nfi));\r
- AssertEquals ("#13", "1.15", d.ToString ("G13", _nfi));\r
- AssertEquals ("#14", "1.15", d.ToString ("G14", _nfi));\r
- AssertEquals ("#15", "1.15", d.ToString ("G15", _nfi));\r
- AssertEquals ("#16", "1.15", d.ToString ("G16", _nfi));\r
- AssertEquals ("#17", "1.1499999999999999", d.ToString ("G17", _nfi));\r
- }\r
-
- [Test]\r
- public void Test13024 () {\r
- AssertEquals ("#01", "1.1", 1.05.ToString ("G2", _nfi));\r
- AssertEquals ("#02", "1.2", 1.15.ToString ("G2", _nfi));\r
- AssertEquals ("#03", "1.3", 1.25.ToString ("G2", _nfi));\r
- AssertEquals ("#04", "1.4", 1.35.ToString ("G2", _nfi));\r
- AssertEquals ("#05", "1.5", 1.45.ToString ("G2", _nfi));\r
- AssertEquals ("#06", "1.6", 1.55.ToString ("G2", _nfi));\r
- AssertEquals ("#07", "1.7", 1.65.ToString ("G2", _nfi));\r
- AssertEquals ("#08", "1.8", 1.75.ToString ("G2", _nfi));\r
- AssertEquals ("#09", "1.9", 1.85.ToString ("G2", _nfi));\r
- AssertEquals ("#10", "2", 1.95.ToString ("G2", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13025 () {\r
- AssertEquals ("#01", "10", 10.05.ToString ("G2", _nfi));\r
- AssertEquals ("#02", "10", 10.15.ToString ("G2", _nfi));\r
- AssertEquals ("#03", "10", 10.25.ToString ("G2", _nfi));\r
- AssertEquals ("#04", "10", 10.35.ToString ("G2", _nfi));\r
- AssertEquals ("#05", "10", 10.45.ToString ("G2", _nfi));\r
- AssertEquals ("#06", "11", 10.55.ToString ("G2", _nfi));\r
- AssertEquals ("#07", "11", 10.65.ToString ("G2", _nfi));\r
- AssertEquals ("#08", "11", 10.75.ToString ("G2", _nfi));\r
- AssertEquals ("#09", "11", 10.85.ToString ("G2", _nfi));\r
- AssertEquals ("#10", "11", 10.95.ToString ("G2", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13026 () {\r
- AssertEquals ("#01", "1.00000000000001", 1.000000000000005.ToString ("G15", _nfi));\r
- AssertEquals ("#02", "1.00000000000002", 1.000000000000015.ToString ("G15", _nfi));\r
- AssertEquals ("#03", "1.00000000000003", 1.000000000000025.ToString ("G15", _nfi));\r
- AssertEquals ("#04", "1.00000000000004", 1.000000000000035.ToString ("G15", _nfi));\r
- AssertEquals ("#05", "1.00000000000005", 1.000000000000045.ToString ("G15", _nfi));\r
- AssertEquals ("#06", "1.00000000000006", 1.000000000000055.ToString ("G15", _nfi));\r
- AssertEquals ("#07", "1.00000000000007", 1.000000000000065.ToString ("G15", _nfi));\r
- AssertEquals ("#08", "1.00000000000008", 1.000000000000075.ToString ("G15", _nfi));\r
- AssertEquals ("#09", "1.00000000000009", 1.000000000000085.ToString ("G15", _nfi));\r
- AssertEquals ("#10", "1.0000000000001", 1.000000000000095.ToString ("G15", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13027 () {\r
- AssertEquals ("#01", "1", 1.0000000000000005.ToString ("G16", _nfi));\r
- AssertEquals ("#02", "1.000000000000002", 1.0000000000000015.ToString ("G16", _nfi));\r
- AssertEquals ("#03", "1.000000000000002", 1.0000000000000025.ToString ("G16", _nfi));\r
- AssertEquals ("#04", "1.000000000000004", 1.0000000000000035.ToString ("G16", _nfi));\r
- AssertEquals ("#05", "1.000000000000004", 1.0000000000000045.ToString ("G16", _nfi));\r
- AssertEquals ("#06", "1.000000000000006", 1.0000000000000055.ToString ("G16", _nfi));\r
- AssertEquals ("#07", "1.000000000000006", 1.0000000000000065.ToString ("G16", _nfi));\r
- AssertEquals ("#08", "1.000000000000008", 1.0000000000000075.ToString ("G16", _nfi));\r
- AssertEquals ("#09", "1.000000000000008", 1.0000000000000085.ToString ("G16", _nfi));\r
- AssertEquals ("#10", "1.00000000000001", 1.0000000000000095.ToString ("G16", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13028 () {\r
- AssertEquals ("#01", "1", 1.00000000000000005.ToString ("G17", _nfi));\r
- AssertEquals ("#02", "1.0000000000000002", 1.00000000000000015.ToString ("G17", _nfi));\r
- AssertEquals ("#03", "1.0000000000000002", 1.00000000000000025.ToString ("G17", _nfi));\r
- AssertEquals ("#04", "1.0000000000000004", 1.00000000000000035.ToString ("G17", _nfi));\r
- AssertEquals ("#05", "1.0000000000000004", 1.00000000000000045.ToString ("G17", _nfi));\r
- AssertEquals ("#06", "1.0000000000000004", 1.00000000000000055.ToString ("G17", _nfi));\r
- AssertEquals ("#07", "1.0000000000000007", 1.00000000000000065.ToString ("G17", _nfi));\r
- AssertEquals ("#08", "1.0000000000000007", 1.00000000000000075.ToString ("G17", _nfi));\r
- AssertEquals ("#09", "1.0000000000000009", 1.00000000000000085.ToString ("G17", _nfi));\r
- AssertEquals ("#10", "1.0000000000000009", 1.00000000000000095.ToString ("G17", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test13029 () {\r
- AssertEquals ("#01", "1", 1.000000000000000005.ToString ("G18", _nfi));\r
- AssertEquals ("#02", "1", 1.000000000000000015.ToString ("G18", _nfi));\r
- AssertEquals ("#03", "1", 1.000000000000000025.ToString ("G18", _nfi));\r
- AssertEquals ("#04", "1", 1.000000000000000035.ToString ("G18", _nfi));\r
- AssertEquals ("#05", "1", 1.000000000000000045.ToString ("G18", _nfi));\r
- AssertEquals ("#06", "1", 1.000000000000000055.ToString ("G18", _nfi));\r
- AssertEquals ("#07", "1", 1.000000000000000065.ToString ("G18", _nfi));\r
- AssertEquals ("#08", "1", 1.000000000000000075.ToString ("G18", _nfi));\r
- AssertEquals ("#09", "1", 1.000000000000000085.ToString ("G18", _nfi));\r
- AssertEquals ("#10", "1", 1.000000000000000095.ToString ("G18", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13030 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "-99999999#9", (-99999999.9).ToString ("G", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13031 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
-\r
- AssertEquals ("#01", "1", 1.0.ToString ("G", nfi));\r
- AssertEquals ("#02", "0", 0.0.ToString ("G", nfi));\r
- AssertEquals ("#03", "+1", (-1.0).ToString ("G", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test13032 () {\r
- AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("G99", _nfi)); \r
- AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("G99", _nfi)); \r
- AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("G99", _nfi)); \r
- }\r
-\r
- [Test]\r
- public void Test13033 () {\r
- AssertEquals ("#01", "0.0001", 0.0001.ToString ("G", _nfi));\r
- AssertEquals ("#02", "1E-05", 0.00001.ToString ("G", _nfi));\r
- AssertEquals ("#03", "0.0001", 0.0001.ToString ("G0", _nfi));\r
- AssertEquals ("#04", "1E-05", 0.00001.ToString ("G0", _nfi));\r
- AssertEquals ("#05", "100000000000000", 100000000000000.0.ToString ("G", _nfi));\r
- AssertEquals ("#06", "1E+15", 1000000000000000.0.ToString ("G", _nfi));\r
- AssertEquals ("#07", "1000000000000000", 1000000000000000.0.ToString ("G16", _nfi));\r
- }\r
-\r
- // Test14000- Double and N\r
- [Test]\r
- public void Test14000 () {\r
- AssertEquals ("#01", "0.00", 0.0.ToString ("N", _nfi));\r
- AssertEquals ("#02", "0.00", 0.0.ToString ("n", _nfi));\r
- AssertEquals ("#03", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MinValue.ToString ("N", _nfi));\r
- AssertEquals ("#04", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MinValue.ToString ("n", _nfi));\r
- AssertEquals ("#05", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MaxValue.ToString ("N", _nfi));\r
- AssertEquals ("#06", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MaxValue.ToString ("n", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14001 () {\r
- AssertEquals ("#01", "N ", 0.0.ToString ("N ", _nfi));\r
- AssertEquals ("#02", " N", 0.0.ToString (" N", _nfi));\r
- AssertEquals ("#03", " N ", 0.0.ToString (" N ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14002 () {\r
- AssertEquals ("#01", "-N ", (-1.0).ToString ("N ", _nfi));\r
- AssertEquals ("#02", "- N", (-1.0).ToString (" N", _nfi));\r
- AssertEquals ("#03", "- N ", (-1.0).ToString (" N ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14003 () {\r
- AssertEquals ("#01", "0", 0.0.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "0.0000000000000000", 0.0.ToString ("N16", _nfi));\r
- AssertEquals ("#03", "0.00000000000000000", 0.0.ToString ("N17", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("N99", _nfi));\r
- AssertEquals ("#05", "N100", 0.0.ToString ("N100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14004 () {\r
- AssertEquals ("#01", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000", Double.MaxValue.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000", Double.MaxValue.ToString ("N16", _nfi));\r
- AssertEquals ("#03", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MaxValue.ToString ("N17", _nfi));\r
- AssertEquals ("#04", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N99", _nfi));\r
- AssertEquals ("#05", "N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14005 () {\r
- AssertEquals ("#01", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000", Double.MinValue.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000", Double.MinValue.ToString ("N16", _nfi));\r
- AssertEquals ("#03", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MinValue.ToString ("N17", _nfi));\r
- AssertEquals ("#04", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N99", _nfi));\r
- AssertEquals ("#05", "-N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14006 () {\r
- AssertEquals ("#01", "NF", 0.0.ToString ("NF", _nfi));\r
- AssertEquals ("#02", "N0F", 0.0.ToString ("N0F", _nfi));\r
- AssertEquals ("#03", "N0xF", 0.0.ToString ("N0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14007 () {\r
- AssertEquals ("#01", "NF", Double.MaxValue.ToString ("NF", _nfi));\r
- AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("N0F", _nfi));\r
- AssertEquals ("#03", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("N0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14008 () {\r
- AssertEquals ("#01", "-NF", Double.MinValue.ToString ("NF", _nfi));\r
- AssertEquals ("#02", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("N0F", _nfi));\r
- AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("N0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14009 () {\r
- AssertEquals ("#01", "0.00000000000000000", 0.0.ToString ("N0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#02", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MaxValue.ToString ("N0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#03", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MinValue.ToString ("N0000000000000000000000000000000000000017", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14010 () {\r
- AssertEquals ("#01", "+N", 0.0.ToString ("+N", _nfi));\r
- AssertEquals ("#02", "N+", 0.0.ToString ("N+", _nfi));\r
- AssertEquals ("#03", "+N+", 0.0.ToString ("+N+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test14011 () {\r
- AssertEquals ("#01", "+N", Double.MaxValue.ToString ("+N", _nfi));\r
- AssertEquals ("#02", "N+", Double.MaxValue.ToString ("N+", _nfi));\r
- AssertEquals ("#03", "+N+", Double.MaxValue.ToString ("+N+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14012 () {\r
- AssertEquals ("#01", "-+N", Double.MinValue.ToString ("+N", _nfi));\r
- AssertEquals ("#02", "-N+", Double.MinValue.ToString ("N+", _nfi));\r
- AssertEquals ("#03", "-+N+", Double.MinValue.ToString ("+N+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14013 () {\r
- AssertEquals ("#01", "-N", 0.0.ToString ("-N", _nfi));\r
- AssertEquals ("#02", "N-", 0.0.ToString ("N-", _nfi));\r
- AssertEquals ("#03", "-N-", 0.0.ToString ("-N-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test14014 () {\r
- AssertEquals ("#01", "-N", Double.MaxValue.ToString ("-N", _nfi));\r
- AssertEquals ("#02", "N-", Double.MaxValue.ToString ("N-", _nfi));\r
- AssertEquals ("#03", "-N-", Double.MaxValue.ToString ("-N-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14015 () {\r
- AssertEquals ("#01", "--N", Double.MinValue.ToString ("-N", _nfi));\r
- AssertEquals ("#02", "-N-", Double.MinValue.ToString ("N-", _nfi));\r
- AssertEquals ("#03", "--N-", Double.MinValue.ToString ("-N-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14016 () {\r
- AssertEquals ("#01", "N+0", 0.0.ToString ("N+0", _nfi));\r
- AssertEquals ("#02", "N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N+0", _nfi));\r
- AssertEquals ("#03", "-N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14017 () {\r
- AssertEquals ("#01", "N+9", 0.0.ToString ("N+9", _nfi));\r
- AssertEquals ("#02", "N+9", Double.MaxValue.ToString ("N+9", _nfi));\r
- AssertEquals ("#03", "-N+9", Double.MinValue.ToString ("N+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14018 () {\r
- AssertEquals ("#01", "N-9", 0.0.ToString ("N-9", _nfi));\r
- AssertEquals ("#02", "N-9", Double.MaxValue.ToString ("N-9", _nfi));\r
- AssertEquals ("#03", "-N-9", Double.MinValue.ToString ("N-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14019 () {\r
- AssertEquals ("#01", "N0", 0.0.ToString ("N0,", _nfi));\r
- AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0,", _nfi));\r
- AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14020 () {\r
- AssertEquals ("#01", "N0", 0.0.ToString ("N0.", _nfi));\r
- AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0.", _nfi));\r
- AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14021 () {\r
- AssertEquals ("#01", "N0.0", 0.0.ToString ("N0.0", _nfi));\r
- AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("N0.0", _nfi));\r
- AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("N0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14022 () {\r
- AssertEquals ("#01", "N09", 0.0.ToString ("N0.9", _nfi));\r
- AssertEquals ("#02", "N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("N0.9", _nfi));\r
- AssertEquals ("#03", "-N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("N0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14023 () {\r
- AssertEquals ("#01", "999.1", 999.05.ToString ("N1", _nfi));\r
- AssertEquals ("#02", "999.2", 999.15.ToString ("N1", _nfi));\r
- AssertEquals ("#03", "999.3", 999.25.ToString ("N1", _nfi));\r
- AssertEquals ("#04", "999.4", 999.35.ToString ("N1", _nfi));\r
- AssertEquals ("#05", "999.5", 999.45.ToString ("N1", _nfi));\r
- AssertEquals ("#06", "999.6", 999.55.ToString ("N1", _nfi));\r
- AssertEquals ("#07", "999.7", 999.65.ToString ("N1", _nfi));\r
- AssertEquals ("#08", "999.8", 999.75.ToString ("N1", _nfi));\r
- AssertEquals ("#09", "999.9", 999.85.ToString ("N1", _nfi));\r
- AssertEquals ("#10", "1,000.0", 999.95.ToString ("N1", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14024 () {\r
- AssertEquals ("#01", "999.91", 999.905.ToString ("N2", _nfi));\r
- AssertEquals ("#02", "999.92", 999.915.ToString ("N2", _nfi));\r
- AssertEquals ("#03", "999.93", 999.925.ToString ("N2", _nfi));\r
- AssertEquals ("#04", "999.94", 999.935.ToString ("N2", _nfi));\r
- AssertEquals ("#05", "999.95", 999.945.ToString ("N2", _nfi));\r
- AssertEquals ("#06", "999.96", 999.955.ToString ("N2", _nfi));\r
- AssertEquals ("#07", "999.97", 999.965.ToString ("N2", _nfi));\r
- AssertEquals ("#08", "999.98", 999.975.ToString ("N2", _nfi));\r
- AssertEquals ("#09", "999.99", 999.985.ToString ("N2", _nfi));\r
- AssertEquals ("#10", "1,000.00", 999.995.ToString ("N2", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14025 () {\r
- AssertEquals ("#01", "999.99999999991", 999.999999999905.ToString ("N11", _nfi));\r
- AssertEquals ("#02", "999.99999999992", 999.999999999915.ToString ("N11", _nfi));\r
- AssertEquals ("#03", "999.99999999993", 999.999999999925.ToString ("N11", _nfi));\r
- AssertEquals ("#04", "999.99999999994", 999.999999999935.ToString ("N11", _nfi));\r
- AssertEquals ("#05", "999.99999999995", 999.999999999945.ToString ("N11", _nfi));\r
- AssertEquals ("#06", "999.99999999996", 999.999999999955.ToString ("N11", _nfi));\r
- AssertEquals ("#07", "999.99999999997", 999.999999999965.ToString ("N11", _nfi));\r
- AssertEquals ("#08", "999.99999999998", 999.999999999975.ToString ("N11", _nfi));\r
- AssertEquals ("#09", "999.99999999999", 999.999999999985.ToString ("N11", _nfi));\r
- AssertEquals ("#10", "1,000.00000000000", 999.999999999995.ToString ("N11", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14026 () {\r
- AssertEquals ("#01", "999.999999999990", 999.9999999999905.ToString ("N12", _nfi));\r
- AssertEquals ("#02", "999.999999999991", 999.9999999999915.ToString ("N12", _nfi));\r
- AssertEquals ("#03", "999.999999999993", 999.9999999999925.ToString ("N12", _nfi));\r
- AssertEquals ("#04", "999.999999999994", 999.9999999999935.ToString ("N12", _nfi));\r
- AssertEquals ("#05", "999.999999999995", 999.9999999999945.ToString ("N12", _nfi));\r
- AssertEquals ("#06", "999.999999999995", 999.9999999999955.ToString ("N12", _nfi));\r
- AssertEquals ("#07", "999.999999999996", 999.9999999999965.ToString ("N12", _nfi));\r
- AssertEquals ("#08", "999.999999999998", 999.9999999999975.ToString ("N12", _nfi));\r
- AssertEquals ("#09", "999.999999999999", 999.9999999999985.ToString ("N12", _nfi));\r
- AssertEquals ("#10", "1,000.000000000000", 999.9999999999995.ToString ("N12", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14027 () {\r
- AssertEquals ("#01", "999.9999999999990", 999.99999999999905.ToString ("N13", _nfi));\r
- AssertEquals ("#02", "999.9999999999990", 999.99999999999915.ToString ("N13", _nfi));\r
- AssertEquals ("#03", "999.9999999999990", 999.99999999999925.ToString ("N13", _nfi));\r
- AssertEquals ("#04", "999.9999999999990", 999.99999999999935.ToString ("N13", _nfi));\r
- AssertEquals ("#05", "999.9999999999990", 999.99999999999945.ToString ("N13", _nfi));\r
- AssertEquals ("#06", "1,000.0000000000000", 999.99999999999955.ToString ("N13", _nfi));\r
- AssertEquals ("#07", "1,000.0000000000000", 999.99999999999965.ToString ("N13", _nfi));\r
- AssertEquals ("#08", "1,000.0000000000000", 999.99999999999975.ToString ("N13", _nfi));\r
- AssertEquals ("#09", "1,000.0000000000000", 999.99999999999985.ToString ("N13", _nfi));\r
- AssertEquals ("#10", "1,000.0000000000000", 999.99999999999995.ToString ("N13", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14028 () {\r
- AssertEquals ("#01", "1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi));\r
- AssertEquals ("#03", "1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi));\r
- AssertEquals ("#04", "1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi));\r
- AssertEquals ("#05", "1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi));\r
- AssertEquals ("#06", "1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi));\r
- AssertEquals ("#07", "N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14029 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NumberDecimalSeparator = "#";\r
- AssertEquals ("#01", "-99,999,999#90", (-99999999.9).ToString ("N", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14030 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
-\r
- AssertEquals ("#01", "1,000.00", 1000.0.ToString ("N", nfi));\r
- AssertEquals ("#02", "0.00", 0.0.ToString ("N", nfi));\r
- AssertEquals ("#03", "+1,000.00", (-1000.0).ToString ("N", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test14031 () {\r
- AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi)); \r
- AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi)); \r
- AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("N99", _nfi)); \r
- }\r
-\r
- // Test15000- Double and P\r
- [Test]\r
- public void Test15000 () {\r
- AssertEquals ("#01", "0.00 %", 0.0.ToString ("P", _nfi));\r
- AssertEquals ("#02", "0.00 %", 0.0.ToString ("p", _nfi));\r
- AssertEquals ("#03", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MinValue.ToString ("P", _nfi));\r
- AssertEquals ("#04", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MinValue.ToString ("p", _nfi));\r
- AssertEquals ("#05", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MaxValue.ToString ("P", _nfi));\r
- AssertEquals ("#06", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MaxValue.ToString ("p", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15001 () {\r
- AssertEquals ("#01", "P ", 0.0.ToString ("P ", _nfi));\r
- AssertEquals ("#02", " P", 0.0.ToString (" P", _nfi));\r
- AssertEquals ("#03", " P ", 0.0.ToString (" P ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15002 () {\r
- AssertEquals ("#01", "-P ", (-1.0).ToString ("P ", _nfi));\r
- AssertEquals ("#02", "- P", (-1.0).ToString (" P", _nfi));\r
- AssertEquals ("#03", "- P ", (-1.0).ToString (" P ", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15003 () {\r
- AssertEquals ("#01", "0 %", 0.0.ToString ("P0", _nfi));\r
- AssertEquals ("#02", "0.0000000000000000 %", 0.0.ToString ("P16", _nfi));\r
- AssertEquals ("#03", "0.00000000000000000 %", 0.0.ToString ("P17", _nfi));\r
- AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.0.ToString ("P99", _nfi));\r
- AssertEquals ("#05", "P100", 0.0.ToString ("P100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15004 () {\r
- AssertEquals ("#01", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 %", Double.MaxValue.ToString ("P0", _nfi));\r
- AssertEquals ("#02", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000 %", Double.MaxValue.ToString ("P16", _nfi));\r
- AssertEquals ("#03", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MaxValue.ToString ("P17", _nfi));\r
- AssertEquals ("#04", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Double.MaxValue.ToString ("P99", _nfi));\r
- AssertEquals ("#05", "P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15005 () {\r
- AssertEquals ("#01", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 %", Double.MinValue.ToString ("P0", _nfi));\r
- AssertEquals ("#02", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000 %", Double.MinValue.ToString ("P16", _nfi));\r
- AssertEquals ("#03", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MinValue.ToString ("P17", _nfi));\r
- AssertEquals ("#04", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Double.MinValue.ToString ("P99", _nfi));\r
- AssertEquals ("#05", "P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15006 () {\r
- AssertEquals ("#01", "PF", 0.0.ToString ("PF", _nfi));\r
- AssertEquals ("#02", "P0F", 0.0.ToString ("P0F", _nfi));\r
- AssertEquals ("#03", "P0xF", 0.0.ToString ("P0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15007 () {\r
- AssertEquals ("#01", "PF", Double.MaxValue.ToString ("PF", _nfi));\r
- AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("P0F", _nfi));\r
- AssertEquals ("#03", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("P0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15008 () {\r
- AssertEquals ("#01", "-PF", Double.MinValue.ToString ("PF", _nfi));\r
- AssertEquals ("#02", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("P0F", _nfi));\r
- AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("P0xF", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15009 () {\r
- AssertEquals ("#01", "0.00000000000000000 %", 0.0.ToString ("P0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#02", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MaxValue.ToString ("P0000000000000000000000000000000000000017", _nfi));\r
- AssertEquals ("#03", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MinValue.ToString ("P0000000000000000000000000000000000000017", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15010 () {\r
- AssertEquals ("#01", "+P", 0.0.ToString ("+P", _nfi));\r
- AssertEquals ("#02", "P+", 0.0.ToString ("P+", _nfi));\r
- AssertEquals ("#03", "+P+", 0.0.ToString ("+P+", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test15011 () {\r
- AssertEquals ("#01", "+P", Double.MaxValue.ToString ("+P", _nfi));\r
- AssertEquals ("#02", "P+", Double.MaxValue.ToString ("P+", _nfi));\r
- AssertEquals ("#03", "+P+", Double.MaxValue.ToString ("+P+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15012 () {\r
- AssertEquals ("#01", "-+P", Double.MinValue.ToString ("+P", _nfi));\r
- AssertEquals ("#02", "-P+", Double.MinValue.ToString ("P+", _nfi));\r
- AssertEquals ("#03", "-+P+", Double.MinValue.ToString ("+P+", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15013 () {\r
- AssertEquals ("#01", "-P", 0.0.ToString ("-P", _nfi));\r
- AssertEquals ("#02", "P-", 0.0.ToString ("P-", _nfi));\r
- AssertEquals ("#03", "-P-", 0.0.ToString ("-P-", _nfi));\r
- }\r
- \r
- [Test]\r
- public void Test15014 () {\r
- AssertEquals ("#01", "-P", Double.MaxValue.ToString ("-P", _nfi));\r
- AssertEquals ("#02", "P-", Double.MaxValue.ToString ("P-", _nfi));\r
- AssertEquals ("#03", "-P-", Double.MaxValue.ToString ("-P-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15015 () {\r
- AssertEquals ("#01", "--P", Double.MinValue.ToString ("-P", _nfi));\r
- AssertEquals ("#02", "-P-", Double.MinValue.ToString ("P-", _nfi));\r
- AssertEquals ("#03", "--P-", Double.MinValue.ToString ("-P-", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15016 () {\r
- AssertEquals ("#01", "P+0", 0.0.ToString ("P+0", _nfi));\r
- AssertEquals ("#02", "P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P+0", _nfi));\r
- AssertEquals ("#03", "-P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P+0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15017 () {\r
- AssertEquals ("#01", "P+9", 0.0.ToString ("P+9", _nfi));\r
- AssertEquals ("#02", "P+9", Double.MaxValue.ToString ("P+9", _nfi));\r
- AssertEquals ("#03", "-P+9", Double.MinValue.ToString ("P+9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15018 () {\r
- AssertEquals ("#01", "P-9", 0.0.ToString ("P-9", _nfi));\r
- AssertEquals ("#02", "P-9", Double.MaxValue.ToString ("P-9", _nfi));\r
- AssertEquals ("#03", "-P-9", Double.MinValue.ToString ("P-9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15019 () {\r
- AssertEquals ("#01", "P0", 0.0.ToString ("P0,", _nfi));\r
- AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0,", _nfi));\r
- AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0,", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15020 () {\r
- AssertEquals ("#01", "P0", 0.0.ToString ("P0.", _nfi));\r
- AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0.", _nfi));\r
- AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0.", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15021 () {\r
- AssertEquals ("#01", "P0.0", 0.0.ToString ("P0.0", _nfi));\r
- AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("P0.0", _nfi));\r
- AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("P0.0", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15022 () {\r
- AssertEquals ("#01", "P09", 0.0.ToString ("P0.9", _nfi));\r
- AssertEquals ("#02", "P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("P0.9", _nfi));\r
- AssertEquals ("#03", "-P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("P0.9", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15023 () {\r
- AssertEquals ("#01", "999.1 %", 9.9905.ToString ("P1", _nfi));\r
- AssertEquals ("#02", "999.2 %", 9.9915.ToString ("P1", _nfi));\r
- AssertEquals ("#03", "999.3 %", 9.9925.ToString ("P1", _nfi));\r
- AssertEquals ("#04", "999.4 %", 9.9935.ToString ("P1", _nfi));\r
- AssertEquals ("#05", "999.5 %", 9.9945.ToString ("P1", _nfi));\r
- AssertEquals ("#06", "999.6 %", 9.9955.ToString ("P1", _nfi));\r
- AssertEquals ("#07", "999.7 %", 9.9965.ToString ("P1", _nfi));\r
- AssertEquals ("#08", "999.8 %", 9.9975.ToString ("P1", _nfi));\r
- AssertEquals ("#09", "999.9 %", 9.9985.ToString ("P1", _nfi));\r
- AssertEquals ("#10", "1,000.0 %", 9.9995.ToString ("P1", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15024 () {\r
- AssertEquals ("#01", "999.91 %", 9.99905.ToString ("P2", _nfi));\r
- AssertEquals ("#02", "999.92 %", 9.99915.ToString ("P2", _nfi));\r
- AssertEquals ("#03", "999.93 %", 9.99925.ToString ("P2", _nfi));\r
- AssertEquals ("#04", "999.94 %", 9.99935.ToString ("P2", _nfi));\r
- AssertEquals ("#05", "999.95 %", 9.99945.ToString ("P2", _nfi));\r
- AssertEquals ("#06", "999.96 %", 9.99955.ToString ("P2", _nfi));\r
- AssertEquals ("#07", "999.97 %", 9.99965.ToString ("P2", _nfi));\r
- AssertEquals ("#08", "999.98 %", 9.99975.ToString ("P2", _nfi));\r
- AssertEquals ("#09", "999.99 %", 9.99985.ToString ("P2", _nfi));\r
- AssertEquals ("#10", "1,000.00 %", 9.99995.ToString ("P2", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15025 () {\r
- AssertEquals ("#01", "999.99999999991 %", 9.99999999999905.ToString ("P11", _nfi));\r
- AssertEquals ("#02", "999.99999999992 %", 9.99999999999915.ToString ("P11", _nfi));\r
- AssertEquals ("#03", "999.99999999993 %", 9.99999999999925.ToString ("P11", _nfi));\r
- AssertEquals ("#04", "999.99999999994 %", 9.99999999999935.ToString ("P11", _nfi));\r
- AssertEquals ("#05", "999.99999999995 %", 9.99999999999945.ToString ("P11", _nfi));\r
- AssertEquals ("#06", "999.99999999996 %", 9.99999999999955.ToString ("P11", _nfi));\r
- AssertEquals ("#07", "999.99999999997 %", 9.99999999999965.ToString ("P11", _nfi));\r
- AssertEquals ("#08", "999.99999999998 %", 9.99999999999975.ToString ("P11", _nfi));\r
- AssertEquals ("#09", "999.99999999999 %", 9.99999999999985.ToString ("P11", _nfi));\r
- AssertEquals ("#10", "1,000.00000000000 %", 9.99999999999995.ToString ("P11", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15026 () {\r
- AssertEquals ("#01", "999.999999999991 %", 9.999999999999905.ToString ("P12", _nfi));\r
- AssertEquals ("#02", "999.999999999991 %", 9.999999999999915.ToString ("P12", _nfi));\r
- AssertEquals ("#03", "999.999999999993 %", 9.999999999999925.ToString ("P12", _nfi));\r
- AssertEquals ("#04", "999.999999999993 %", 9.999999999999935.ToString ("P12", _nfi));\r
- AssertEquals ("#05", "999.999999999994 %", 9.999999999999945.ToString ("P12", _nfi));\r
- AssertEquals ("#06", "999.999999999996 %", 9.999999999999955.ToString ("P12", _nfi));\r
- AssertEquals ("#07", "999.999999999996 %", 9.999999999999965.ToString ("P12", _nfi));\r
- AssertEquals ("#08", "999.999999999998 %", 9.999999999999975.ToString ("P12", _nfi));\r
- AssertEquals ("#09", "999.999999999999 %", 9.999999999999985.ToString ("P12", _nfi));\r
- AssertEquals ("#10", "999.999999999999 %", 9.999999999999995.ToString ("P12", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15027 () {\r
- AssertEquals ("#01", "999.9999999999990 %", 9.9999999999999905.ToString ("P13", _nfi));\r
- AssertEquals ("#02", "999.9999999999990 %", 9.9999999999999915.ToString ("P13", _nfi));\r
- AssertEquals ("#03", "999.9999999999990 %", 9.9999999999999925.ToString ("P13", _nfi));\r
- AssertEquals ("#04", "999.9999999999990 %", 9.9999999999999935.ToString ("P13", _nfi));\r
- AssertEquals ("#05", "999.9999999999990 %", 9.9999999999999945.ToString ("P13", _nfi));\r
- AssertEquals ("#06", "999.9999999999990 %", 9.9999999999999955.ToString ("P13", _nfi));\r
- AssertEquals ("#07", "1,000.0000000000000 %", 9.9999999999999965.ToString ("P13", _nfi));\r
- AssertEquals ("#08", "1,000.0000000000000 %", 9.9999999999999975.ToString ("P13", _nfi));\r
- AssertEquals ("#09", "1,000.0000000000000 %", 9.9999999999999985.ToString ("P13", _nfi));\r
- AssertEquals ("#10", "1,000.0000000000000 %", 9.9999999999999995.ToString ("P13", _nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15028 () {\r
- AssertEquals ("#01", "1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi));\r
- AssertEquals ("#02", "1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi));\r
- AssertEquals ("#03", "1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi));\r
- AssertEquals ("#04", "1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi));\r
- AssertEquals ("#05", "1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi));\r
- AssertEquals ("#06", "1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi));\r
- AssertEquals ("#07", "N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100"));\r
- }\r
-\r
- [Test]\r
- public void Test15029 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.PercentDecimalSeparator = "#";\r
- AssertEquals ("#01", "-9,999,999,990#00 %", (-99999999.9).ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15030 () {\r
- NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;\r
- nfi.NegativeSign = "+";\r
- nfi.PositiveSign = "-";\r
-\r
- AssertEquals ("#01", "1,000.00 %", 10.0.ToString ("P", nfi));\r
- AssertEquals ("#02", "0.00 %", 0.0.ToString ("P", nfi));\r
- AssertEquals ("#03", "+1,000.00 %", (-10.0).ToString ("P", nfi));\r
- }\r
-\r
- [Test]\r
- public void Test15031 () {\r
- AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi)); \r
- AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi)); \r
- AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("N99", _nfi)); \r
- }\r
-\r
- // Test16000 - Double and R\r
- [Test]\r
- public void Test16000 () {\r
- AssertEquals ("#01", "1.2345678901234567", 1.2345678901234567890.ToString ("R", _nfi));\r
- AssertEquals ("#02", "1.2345678901234567", 1.2345678901234567890.ToString ("r", _nfi));\r
- AssertEquals ("#03", "1.2345678901234567", 1.2345678901234567890.ToString ("R0", _nfi));\r
- AssertEquals ("#04", "1.2345678901234567", 1.2345678901234567890.ToString ("r0", _nfi));\r
- AssertEquals ("#05", "1.2345678901234567", 1.2345678901234567890.ToString ("R99", _nfi));\r
- AssertEquals ("#06", "1.2345678901234567", 1.2345678901234567890.ToString ("r99", _nfi));\r
- }\r
-\r
- // Test17000 - Double and X\r
- [Test]\r
- [ExpectedException (typeof (FormatException))]\r
- public void Test17000 () {\r
- AssertEquals ("#01", "", 0.0.ToString ("X99", _nfi)); \r
- }\r
- }\r
-}\r
+ Assert.AreEqual ("1.2", d.ToString ("G2", _nfi), "#02");
+ Assert.AreEqual ("1.15", d.ToString ("G3", _nfi), "#03");
+ Assert.AreEqual ("1.15", d.ToString ("G4", _nfi), "#04");
+ Assert.AreEqual ("1.15", d.ToString ("G5", _nfi), "#05");
+ Assert.AreEqual ("1.15", d.ToString ("G6", _nfi), "#06");
+ Assert.AreEqual ("1.15", d.ToString ("G7", _nfi), "#07");
+ Assert.AreEqual ("1.15", d.ToString ("G8", _nfi), "#08");
+ Assert.AreEqual ("1.15", d.ToString ("G9", _nfi), "#09");
+ Assert.AreEqual ("1.15", d.ToString ("G10", _nfi), "#10");
+ Assert.AreEqual ("1.15", d.ToString ("G11", _nfi), "#11");
+ Assert.AreEqual ("1.15", d.ToString ("G12", _nfi), "#12");
+ Assert.AreEqual ("1.15", d.ToString ("G13", _nfi), "#13");
+ Assert.AreEqual ("1.15", d.ToString ("G14", _nfi), "#14");
+ Assert.AreEqual ("1.15", d.ToString ("G15", _nfi), "#15");
+ Assert.AreEqual ("1.15", d.ToString ("G16", _nfi), "#16");
+ Assert.AreEqual ("1.1499999999999999", d.ToString ("G17", _nfi), "#17");
+ }
+
+ [Test]
+ public void Test13024 ()
+ {
+ Assert.AreEqual ("1.1", 1.05.ToString ("G2", _nfi), "#01");
+ Assert.AreEqual ("1.2", 1.15.ToString ("G2", _nfi), "#02");
+ Assert.AreEqual ("1.3", 1.25.ToString ("G2", _nfi), "#03");
+ Assert.AreEqual ("1.4", 1.35.ToString ("G2", _nfi), "#04");
+ Assert.AreEqual ("1.5", 1.45.ToString ("G2", _nfi), "#05");
+ Assert.AreEqual ("1.6", 1.55.ToString ("G2", _nfi), "#06");
+ Assert.AreEqual ("1.7", 1.65.ToString ("G2", _nfi), "#07");
+ Assert.AreEqual ("1.8", 1.75.ToString ("G2", _nfi), "#08");
+ Assert.AreEqual ("1.9", 1.85.ToString ("G2", _nfi), "#09");
+ Assert.AreEqual ("2", 1.95.ToString ("G2", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test13025 ()
+ {
+ Assert.AreEqual ("10", 10.05.ToString ("G2", _nfi), "#01");
+ Assert.AreEqual ("10", 10.15.ToString ("G2", _nfi), "#02");
+ Assert.AreEqual ("10", 10.25.ToString ("G2", _nfi), "#03");
+ Assert.AreEqual ("10", 10.35.ToString ("G2", _nfi), "#04");
+ Assert.AreEqual ("10", 10.45.ToString ("G2", _nfi), "#05");
+ Assert.AreEqual ("11", 10.55.ToString ("G2", _nfi), "#06");
+ Assert.AreEqual ("11", 10.65.ToString ("G2", _nfi), "#07");
+ Assert.AreEqual ("11", 10.75.ToString ("G2", _nfi), "#08");
+ Assert.AreEqual ("11", 10.85.ToString ("G2", _nfi), "#09");
+ Assert.AreEqual ("11", 10.95.ToString ("G2", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test13026 ()
+ {
+ Assert.AreEqual ("1.00000000000001", 1.000000000000005.ToString ("G15", _nfi), "#01");
+ Assert.AreEqual ("1.00000000000002", 1.000000000000015.ToString ("G15", _nfi), "#02");
+ Assert.AreEqual ("1.00000000000003", 1.000000000000025.ToString ("G15", _nfi), "#03");
+ Assert.AreEqual ("1.00000000000004", 1.000000000000035.ToString ("G15", _nfi), "#04");
+ Assert.AreEqual ("1.00000000000005", 1.000000000000045.ToString ("G15", _nfi), "#05");
+ Assert.AreEqual ("1.00000000000006", 1.000000000000055.ToString ("G15", _nfi), "#06");
+ Assert.AreEqual ("1.00000000000007", 1.000000000000065.ToString ("G15", _nfi), "#07");
+ Assert.AreEqual ("1.00000000000008", 1.000000000000075.ToString ("G15", _nfi), "#08");
+ Assert.AreEqual ("1.00000000000009", 1.000000000000085.ToString ("G15", _nfi), "#09");
+ Assert.AreEqual ("1.0000000000001", 1.000000000000095.ToString ("G15", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test13027 ()
+ {
+ Assert.AreEqual ("1", 1.0000000000000005.ToString ("G16", _nfi), "#01");
+ Assert.AreEqual ("1.000000000000002", 1.0000000000000015.ToString ("G16", _nfi), "#02");
+ Assert.AreEqual ("1.000000000000002", 1.0000000000000025.ToString ("G16", _nfi), "#03");
+ Assert.AreEqual ("1.000000000000004", 1.0000000000000035.ToString ("G16", _nfi), "#04");
+ Assert.AreEqual ("1.000000000000004", 1.0000000000000045.ToString ("G16", _nfi), "#05");
+ Assert.AreEqual ("1.000000000000006", 1.0000000000000055.ToString ("G16", _nfi), "#06");
+ Assert.AreEqual ("1.000000000000006", 1.0000000000000065.ToString ("G16", _nfi), "#07");
+ Assert.AreEqual ("1.000000000000008", 1.0000000000000075.ToString ("G16", _nfi), "#08");
+ Assert.AreEqual ("1.000000000000008", 1.0000000000000085.ToString ("G16", _nfi), "#09");
+ Assert.AreEqual ("1.00000000000001", 1.0000000000000095.ToString ("G16", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test13028 ()
+ {
+ Assert.AreEqual ("1", 1.00000000000000005.ToString ("G17", _nfi), "#01");
+ Assert.AreEqual ("1.0000000000000002", 1.00000000000000015.ToString ("G17", _nfi), "#02");
+ Assert.AreEqual ("1.0000000000000002", 1.00000000000000025.ToString ("G17", _nfi), "#03");
+ Assert.AreEqual ("1.0000000000000004", 1.00000000000000035.ToString ("G17", _nfi), "#04");
+ Assert.AreEqual ("1.0000000000000004", 1.00000000000000045.ToString ("G17", _nfi), "#05");
+ Assert.AreEqual ("1.0000000000000004", 1.00000000000000055.ToString ("G17", _nfi), "#06");
+ Assert.AreEqual ("1.0000000000000007", 1.00000000000000065.ToString ("G17", _nfi), "#07");
+ Assert.AreEqual ("1.0000000000000007", 1.00000000000000075.ToString ("G17", _nfi), "#08");
+ Assert.AreEqual ("1.0000000000000009", 1.00000000000000085.ToString ("G17", _nfi), "#09");
+ Assert.AreEqual ("1.0000000000000009", 1.00000000000000095.ToString ("G17", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test13029 ()
+ {
+ Assert.AreEqual ("1", 1.000000000000000005.ToString ("G18", _nfi), "#01");
+ Assert.AreEqual ("1", 1.000000000000000015.ToString ("G18", _nfi), "#02");
+ Assert.AreEqual ("1", 1.000000000000000025.ToString ("G18", _nfi), "#03");
+ Assert.AreEqual ("1", 1.000000000000000035.ToString ("G18", _nfi), "#04");
+ Assert.AreEqual ("1", 1.000000000000000045.ToString ("G18", _nfi), "#05");
+ Assert.AreEqual ("1", 1.000000000000000055.ToString ("G18", _nfi), "#06");
+ Assert.AreEqual ("1", 1.000000000000000065.ToString ("G18", _nfi), "#07");
+ Assert.AreEqual ("1", 1.000000000000000075.ToString ("G18", _nfi), "#08");
+ Assert.AreEqual ("1", 1.000000000000000085.ToString ("G18", _nfi), "#09");
+ Assert.AreEqual ("1", 1.000000000000000095.ToString ("G18", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test13030 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("-99999999#9", (-99999999.9).ToString ("G", nfi), "#01");
+ }
+
+ [Test]
+ public void Test13031 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+
+ Assert.AreEqual ("1", 1.0.ToString ("G", nfi), "#01");
+ Assert.AreEqual ("0", 0.0.ToString ("G", nfi), "#02");
+ Assert.AreEqual ("+1", (-1.0).ToString ("G", nfi), "#03");
+ }
+
+ [Test]
+ public void Test13032 ()
+ {
+ Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("G99", _nfi) , "#01");
+ Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("G99", _nfi) , "#02");
+ Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("G99", _nfi) , "#03");
+ }
+
+ [Test]
+ public void Test13033 ()
+ {
+ Assert.AreEqual ("0.0001", 0.0001.ToString ("G", _nfi), "#01");
+ Assert.AreEqual ("1E-05", 0.00001.ToString ("G", _nfi), "#02");
+ Assert.AreEqual ("0.0001", 0.0001.ToString ("G0", _nfi), "#03");
+ Assert.AreEqual ("1E-05", 0.00001.ToString ("G0", _nfi), "#04");
+ Assert.AreEqual ("100000000000000", 100000000000000.0.ToString ("G", _nfi), "#05");
+ Assert.AreEqual ("1E+15", 1000000000000000.0.ToString ("G", _nfi), "#06");
+ Assert.AreEqual ("1000000000000000", 1000000000000000.0.ToString ("G16", _nfi), "#07");
+ }
+
+ // Test14000- Double and N
+ [Test]
+ public void Test14000 ()
+ {
+ Assert.AreEqual ("0.00", 0.0.ToString ("N", _nfi), "#01");
+ Assert.AreEqual ("0.00", 0.0.ToString ("n", _nfi), "#02");
+ Assert.AreEqual ("-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MinValue.ToString ("N", _nfi), "#03");
+ Assert.AreEqual ("-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MinValue.ToString ("n", _nfi), "#04");
+ Assert.AreEqual ("179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MaxValue.ToString ("N", _nfi), "#05");
+ Assert.AreEqual ("179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MaxValue.ToString ("n", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test14001 ()
+ {
+ Assert.AreEqual ("N ", 0.0.ToString ("N ", _nfi), "#01");
+ Assert.AreEqual (" N", 0.0.ToString (" N", _nfi), "#02");
+ Assert.AreEqual (" N ", 0.0.ToString (" N ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14002 ()
+ {
+ Assert.AreEqual ("-N ", (-1.0).ToString ("N ", _nfi), "#01");
+ Assert.AreEqual ("- N", (-1.0).ToString (" N", _nfi), "#02");
+ Assert.AreEqual ("- N ", (-1.0).ToString (" N ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14003 ()
+ {
+ Assert.AreEqual ("0", 0.0.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("0.0000000000000000", 0.0.ToString ("N16", _nfi), "#02");
+ Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("N17", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("N99", _nfi), "#04");
+ Assert.AreEqual ("N100", 0.0.ToString ("N100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test14004 ()
+ {
+ Assert.AreEqual ("179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000", Double.MaxValue.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000", Double.MaxValue.ToString ("N16", _nfi), "#02");
+ Assert.AreEqual ("179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MaxValue.ToString ("N17", _nfi), "#03");
+ Assert.AreEqual ("179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N99", _nfi), "#04");
+ Assert.AreEqual ("N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test14005 ()
+ {
+ Assert.AreEqual ("-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000", Double.MinValue.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000", Double.MinValue.ToString ("N16", _nfi), "#02");
+ Assert.AreEqual ("-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MinValue.ToString ("N17", _nfi), "#03");
+ Assert.AreEqual ("-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N99", _nfi), "#04");
+ Assert.AreEqual ("-N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test14006 ()
+ {
+ Assert.AreEqual ("NF", 0.0.ToString ("NF", _nfi), "#01");
+ Assert.AreEqual ("N0F", 0.0.ToString ("N0F", _nfi), "#02");
+ Assert.AreEqual ("N0xF", 0.0.ToString ("N0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14007 ()
+ {
+ Assert.AreEqual ("NF", Double.MaxValue.ToString ("NF", _nfi), "#01");
+ Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("N0F", _nfi), "#02");
+ Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("N0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14008 ()
+ {
+ Assert.AreEqual ("-NF", Double.MinValue.ToString ("NF", _nfi), "#01");
+ Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("N0F", _nfi), "#02");
+ Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("N0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14009 ()
+ {
+ Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("N0000000000000000000000000000000000000017", _nfi), "#01");
+ Assert.AreEqual ("179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MaxValue.ToString ("N0000000000000000000000000000000000000017", _nfi), "#02");
+ Assert.AreEqual ("-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MinValue.ToString ("N0000000000000000000000000000000000000017", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14010 ()
+ {
+ Assert.AreEqual ("+N", 0.0.ToString ("+N", _nfi), "#01");
+ Assert.AreEqual ("N+", 0.0.ToString ("N+", _nfi), "#02");
+ Assert.AreEqual ("+N+", 0.0.ToString ("+N+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14011 ()
+ {
+ Assert.AreEqual ("+N", Double.MaxValue.ToString ("+N", _nfi), "#01");
+ Assert.AreEqual ("N+", Double.MaxValue.ToString ("N+", _nfi), "#02");
+ Assert.AreEqual ("+N+", Double.MaxValue.ToString ("+N+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14012 ()
+ {
+ Assert.AreEqual ("-+N", Double.MinValue.ToString ("+N", _nfi), "#01");
+ Assert.AreEqual ("-N+", Double.MinValue.ToString ("N+", _nfi), "#02");
+ Assert.AreEqual ("-+N+", Double.MinValue.ToString ("+N+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14013 ()
+ {
+ Assert.AreEqual ("-N", 0.0.ToString ("-N", _nfi), "#01");
+ Assert.AreEqual ("N-", 0.0.ToString ("N-", _nfi), "#02");
+ Assert.AreEqual ("-N-", 0.0.ToString ("-N-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14014 ()
+ {
+ Assert.AreEqual ("-N", Double.MaxValue.ToString ("-N", _nfi), "#01");
+ Assert.AreEqual ("N-", Double.MaxValue.ToString ("N-", _nfi), "#02");
+ Assert.AreEqual ("-N-", Double.MaxValue.ToString ("-N-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14015 ()
+ {
+ Assert.AreEqual ("--N", Double.MinValue.ToString ("-N", _nfi), "#01");
+ Assert.AreEqual ("-N-", Double.MinValue.ToString ("N-", _nfi), "#02");
+ Assert.AreEqual ("--N-", Double.MinValue.ToString ("-N-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14016 ()
+ {
+ Assert.AreEqual ("N+0", 0.0.ToString ("N+0", _nfi), "#01");
+ Assert.AreEqual ("N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N+0", _nfi), "#02");
+ Assert.AreEqual ("-N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14017 ()
+ {
+ Assert.AreEqual ("N+9", 0.0.ToString ("N+9", _nfi), "#01");
+ Assert.AreEqual ("N+9", Double.MaxValue.ToString ("N+9", _nfi), "#02");
+ Assert.AreEqual ("-N+9", Double.MinValue.ToString ("N+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14018 ()
+ {
+ Assert.AreEqual ("N-9", 0.0.ToString ("N-9", _nfi), "#01");
+ Assert.AreEqual ("N-9", Double.MaxValue.ToString ("N-9", _nfi), "#02");
+ Assert.AreEqual ("-N-9", Double.MinValue.ToString ("N-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14019 ()
+ {
+ Assert.AreEqual ("N0", 0.0.ToString ("N0,", _nfi), "#01");
+ Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0,", _nfi), "#02");
+ Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14020 ()
+ {
+ Assert.AreEqual ("N0", 0.0.ToString ("N0.", _nfi), "#01");
+ Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0.", _nfi), "#02");
+ Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14021 ()
+ {
+ Assert.AreEqual ("N0.0", 0.0.ToString ("N0.0", _nfi), "#01");
+ Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("N0.0", _nfi), "#02");
+ Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("N0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14022 ()
+ {
+ Assert.AreEqual ("N09", 0.0.ToString ("N0.9", _nfi), "#01");
+ Assert.AreEqual ("N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("N0.9", _nfi), "#02");
+ Assert.AreEqual ("-N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("N0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test14023 ()
+ {
+ Assert.AreEqual ("999.1", 999.05.ToString ("N1", _nfi), "#01");
+ Assert.AreEqual ("999.2", 999.15.ToString ("N1", _nfi), "#02");
+ Assert.AreEqual ("999.3", 999.25.ToString ("N1", _nfi), "#03");
+ Assert.AreEqual ("999.4", 999.35.ToString ("N1", _nfi), "#04");
+ Assert.AreEqual ("999.5", 999.45.ToString ("N1", _nfi), "#05");
+ Assert.AreEqual ("999.6", 999.55.ToString ("N1", _nfi), "#06");
+ Assert.AreEqual ("999.7", 999.65.ToString ("N1", _nfi), "#07");
+ Assert.AreEqual ("999.8", 999.75.ToString ("N1", _nfi), "#08");
+ Assert.AreEqual ("999.9", 999.85.ToString ("N1", _nfi), "#09");
+ Assert.AreEqual ("1,000.0", 999.95.ToString ("N1", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test14024 ()
+ {
+ Assert.AreEqual ("999.91", 999.905.ToString ("N2", _nfi), "#01");
+ Assert.AreEqual ("999.92", 999.915.ToString ("N2", _nfi), "#02");
+ Assert.AreEqual ("999.93", 999.925.ToString ("N2", _nfi), "#03");
+ Assert.AreEqual ("999.94", 999.935.ToString ("N2", _nfi), "#04");
+ Assert.AreEqual ("999.95", 999.945.ToString ("N2", _nfi), "#05");
+ Assert.AreEqual ("999.96", 999.955.ToString ("N2", _nfi), "#06");
+ Assert.AreEqual ("999.97", 999.965.ToString ("N2", _nfi), "#07");
+ Assert.AreEqual ("999.98", 999.975.ToString ("N2", _nfi), "#08");
+ Assert.AreEqual ("999.99", 999.985.ToString ("N2", _nfi), "#09");
+ Assert.AreEqual ("1,000.00", 999.995.ToString ("N2", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test14025 ()
+ {
+ Assert.AreEqual ("999.99999999991", 999.999999999905.ToString ("N11", _nfi), "#01");
+ Assert.AreEqual ("999.99999999992", 999.999999999915.ToString ("N11", _nfi), "#02");
+ Assert.AreEqual ("999.99999999993", 999.999999999925.ToString ("N11", _nfi), "#03");
+ Assert.AreEqual ("999.99999999994", 999.999999999935.ToString ("N11", _nfi), "#04");
+ Assert.AreEqual ("999.99999999995", 999.999999999945.ToString ("N11", _nfi), "#05");
+ Assert.AreEqual ("999.99999999996", 999.999999999955.ToString ("N11", _nfi), "#06");
+ Assert.AreEqual ("999.99999999997", 999.999999999965.ToString ("N11", _nfi), "#07");
+ Assert.AreEqual ("999.99999999998", 999.999999999975.ToString ("N11", _nfi), "#08");
+ Assert.AreEqual ("999.99999999999", 999.999999999985.ToString ("N11", _nfi), "#09");
+ Assert.AreEqual ("1,000.00000000000", 999.999999999995.ToString ("N11", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test14026 ()
+ {
+ Assert.AreEqual ("999.999999999990", 999.9999999999905.ToString ("N12", _nfi), "#01");
+ Assert.AreEqual ("999.999999999991", 999.9999999999915.ToString ("N12", _nfi), "#02");
+ Assert.AreEqual ("999.999999999993", 999.9999999999925.ToString ("N12", _nfi), "#03");
+ Assert.AreEqual ("999.999999999994", 999.9999999999935.ToString ("N12", _nfi), "#04");
+ Assert.AreEqual ("999.999999999995", 999.9999999999945.ToString ("N12", _nfi), "#05");
+ Assert.AreEqual ("999.999999999995", 999.9999999999955.ToString ("N12", _nfi), "#06");
+ Assert.AreEqual ("999.999999999996", 999.9999999999965.ToString ("N12", _nfi), "#07");
+ Assert.AreEqual ("999.999999999998", 999.9999999999975.ToString ("N12", _nfi), "#08");
+ Assert.AreEqual ("999.999999999999", 999.9999999999985.ToString ("N12", _nfi), "#09");
+ Assert.AreEqual ("1,000.000000000000", 999.9999999999995.ToString ("N12", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test14027 ()
+ {
+ Assert.AreEqual ("999.9999999999990", 999.99999999999905.ToString ("N13", _nfi), "#01");
+ Assert.AreEqual ("999.9999999999990", 999.99999999999915.ToString ("N13", _nfi), "#02");
+ Assert.AreEqual ("999.9999999999990", 999.99999999999925.ToString ("N13", _nfi), "#03");
+ Assert.AreEqual ("999.9999999999990", 999.99999999999935.ToString ("N13", _nfi), "#04");
+ Assert.AreEqual ("999.9999999999990", 999.99999999999945.ToString ("N13", _nfi), "#05");
+ Assert.AreEqual ("1,000.0000000000000", 999.99999999999955.ToString ("N13", _nfi), "#06");
+ Assert.AreEqual ("1,000.0000000000000", 999.99999999999965.ToString ("N13", _nfi), "#07");
+ Assert.AreEqual ("1,000.0000000000000", 999.99999999999975.ToString ("N13", _nfi), "#08");
+ Assert.AreEqual ("1,000.0000000000000", 999.99999999999985.ToString ("N13", _nfi), "#09");
+ Assert.AreEqual ("1,000.0000000000000", 999.99999999999995.ToString ("N13", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test14028 ()
+ {
+ Assert.AreEqual ("1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi), "#02");
+ Assert.AreEqual ("1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi), "#03");
+ Assert.AreEqual ("1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi), "#04");
+ Assert.AreEqual ("1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi), "#05");
+ Assert.AreEqual ("1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi), "#06");
+ Assert.AreEqual ("N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100", _nfi), "#07");
+ }
+
+ [Test]
+ public void Test14029 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NumberDecimalSeparator = "#";
+ Assert.AreEqual ("-99,999,999#90", (-99999999.9).ToString ("N", nfi), "#01");
+ }
+
+ [Test]
+ public void Test14030 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+
+ Assert.AreEqual ("1,000.00", 1000.0.ToString ("N", nfi), "#01");
+ Assert.AreEqual ("0.00", 0.0.ToString ("N", nfi), "#02");
+ Assert.AreEqual ("+1,000.00", (-1000.0).ToString ("N", nfi), "#03");
+ }
+
+ [Test]
+ public void Test14031 ()
+ {
+ Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi) , "#01");
+ Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi) , "#02");
+ Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("N99", _nfi) , "#03");
+ }
+
+ [Test (Description = "Bug #659061")]
+ public void Test14032 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone () as NumberFormatInfo;
+ int[] groups = new int [10];
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 1;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("2,5,5,5,6,6,6.65", (2555666.65).ToString ("N", nfi), "#01");
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 2;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("2,55,56,66.65", (2555666.65).ToString ("N", nfi), "#02");
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 3;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("2,555,666.65", (2555666.65).ToString ("N", nfi), "#03");
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 4;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("255,5666.65", (2555666.65).ToString ("N", nfi), "#04");
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 5;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("25,55666.65", (2555666.65).ToString ("N", nfi), "#05");
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 6;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("2,555666.65", (2555666.65).ToString ("N", nfi), "#06");
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 7;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("2555666.65", (2555666.65).ToString ("N", nfi), "#07");
+
+ for (int i = 0; i < groups.Length; i++)
+ groups [i] = 8;
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("2555666.65", (2555666.65).ToString ("N", nfi), "#08");
+ }
+
+ [Test]
+ public void Test14033 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone () as NumberFormatInfo;
+ int[] groups = new int [] { 1, 2, 3 };
+
+ nfi.NumberGroupSizes = groups;
+ Assert.AreEqual ("2,555,66,6.65", (2555666.65).ToString ("N", nfi), "#01");
+ }
+
+ // Test15000- Double and P
+ [Test]
+ public void Test15000 ()
+ {
+ Assert.AreEqual ("0.00 %", 0.0.ToString ("P", _nfi), "#01");
+ Assert.AreEqual ("0.00 %", 0.0.ToString ("p", _nfi), "#02");
+ Assert.AreEqual ("-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MinValue.ToString ("P", _nfi), "#03");
+ Assert.AreEqual ("-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MinValue.ToString ("p", _nfi), "#04");
+ Assert.AreEqual ("17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MaxValue.ToString ("P", _nfi), "#05");
+ Assert.AreEqual ("17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MaxValue.ToString ("p", _nfi), "#06");
+ }
+
+ [Test]
+ public void Test15001 ()
+ {
+ Assert.AreEqual ("P ", 0.0.ToString ("P ", _nfi), "#01");
+ Assert.AreEqual (" P", 0.0.ToString (" P", _nfi), "#02");
+ Assert.AreEqual (" P ", 0.0.ToString (" P ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15002 ()
+ {
+ Assert.AreEqual ("-P ", (-1.0).ToString ("P ", _nfi), "#01");
+ Assert.AreEqual ("- P", (-1.0).ToString (" P", _nfi), "#02");
+ Assert.AreEqual ("- P ", (-1.0).ToString (" P ", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15003 ()
+ {
+ Assert.AreEqual ("0 %", 0.0.ToString ("P0", _nfi), "#01");
+ Assert.AreEqual ("0.0000000000000000 %", 0.0.ToString ("P16", _nfi), "#02");
+ Assert.AreEqual ("0.00000000000000000 %", 0.0.ToString ("P17", _nfi), "#03");
+ Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.0.ToString ("P99", _nfi), "#04");
+ Assert.AreEqual ("P100", 0.0.ToString ("P100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test15004 ()
+ {
+ Assert.AreEqual ("17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 %", Double.MaxValue.ToString ("P0", _nfi), "#01");
+ Assert.AreEqual ("17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000 %", Double.MaxValue.ToString ("P16", _nfi), "#02");
+ Assert.AreEqual ("17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MaxValue.ToString ("P17", _nfi), "#03");
+ Assert.AreEqual ("17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Double.MaxValue.ToString ("P99", _nfi), "#04");
+ Assert.AreEqual ("P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test15005 ()
+ {
+ Assert.AreEqual ("-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 %", Double.MinValue.ToString ("P0", _nfi), "#01");
+ Assert.AreEqual ("-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000 %", Double.MinValue.ToString ("P16", _nfi), "#02");
+ Assert.AreEqual ("-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MinValue.ToString ("P17", _nfi), "#03");
+ Assert.AreEqual ("-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Double.MinValue.ToString ("P99", _nfi), "#04");
+ Assert.AreEqual ("P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi), "#05");
+ }
+
+ [Test]
+ public void Test15006 ()
+ {
+ Assert.AreEqual ("PF", 0.0.ToString ("PF", _nfi), "#01");
+ Assert.AreEqual ("P0F", 0.0.ToString ("P0F", _nfi), "#02");
+ Assert.AreEqual ("P0xF", 0.0.ToString ("P0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15007 ()
+ {
+ Assert.AreEqual ("PF", Double.MaxValue.ToString ("PF", _nfi), "#01");
+ Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("P0F", _nfi), "#02");
+ Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("P0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15008 ()
+ {
+ Assert.AreEqual ("-PF", Double.MinValue.ToString ("PF", _nfi), "#01");
+ Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("P0F", _nfi), "#02");
+ Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("P0xF", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15009 ()
+ {
+ Assert.AreEqual ("0.00000000000000000 %", 0.0.ToString ("P0000000000000000000000000000000000000017", _nfi), "#01");
+ Assert.AreEqual ("17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MaxValue.ToString ("P0000000000000000000000000000000000000017", _nfi), "#02");
+ Assert.AreEqual ("-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MinValue.ToString ("P0000000000000000000000000000000000000017", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15010 ()
+ {
+ Assert.AreEqual ("+P", 0.0.ToString ("+P", _nfi), "#01");
+ Assert.AreEqual ("P+", 0.0.ToString ("P+", _nfi), "#02");
+ Assert.AreEqual ("+P+", 0.0.ToString ("+P+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15011 ()
+ {
+ Assert.AreEqual ("+P", Double.MaxValue.ToString ("+P", _nfi), "#01");
+ Assert.AreEqual ("P+", Double.MaxValue.ToString ("P+", _nfi), "#02");
+ Assert.AreEqual ("+P+", Double.MaxValue.ToString ("+P+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15012 ()
+ {
+ Assert.AreEqual ("-+P", Double.MinValue.ToString ("+P", _nfi), "#01");
+ Assert.AreEqual ("-P+", Double.MinValue.ToString ("P+", _nfi), "#02");
+ Assert.AreEqual ("-+P+", Double.MinValue.ToString ("+P+", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15013 ()
+ {
+ Assert.AreEqual ("-P", 0.0.ToString ("-P", _nfi), "#01");
+ Assert.AreEqual ("P-", 0.0.ToString ("P-", _nfi), "#02");
+ Assert.AreEqual ("-P-", 0.0.ToString ("-P-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15014 ()
+ {
+ Assert.AreEqual ("-P", Double.MaxValue.ToString ("-P", _nfi), "#01");
+ Assert.AreEqual ("P-", Double.MaxValue.ToString ("P-", _nfi), "#02");
+ Assert.AreEqual ("-P-", Double.MaxValue.ToString ("-P-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15015 ()
+ {
+ Assert.AreEqual ("--P", Double.MinValue.ToString ("-P", _nfi), "#01");
+ Assert.AreEqual ("-P-", Double.MinValue.ToString ("P-", _nfi), "#02");
+ Assert.AreEqual ("--P-", Double.MinValue.ToString ("-P-", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15016 ()
+ {
+ Assert.AreEqual ("P+0", 0.0.ToString ("P+0", _nfi), "#01");
+ Assert.AreEqual ("P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P+0", _nfi), "#02");
+ Assert.AreEqual ("-P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P+0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15017 ()
+ {
+ Assert.AreEqual ("P+9", 0.0.ToString ("P+9", _nfi), "#01");
+ Assert.AreEqual ("P+9", Double.MaxValue.ToString ("P+9", _nfi), "#02");
+ Assert.AreEqual ("-P+9", Double.MinValue.ToString ("P+9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15018 ()
+ {
+ Assert.AreEqual ("P-9", 0.0.ToString ("P-9", _nfi), "#01");
+ Assert.AreEqual ("P-9", Double.MaxValue.ToString ("P-9", _nfi), "#02");
+ Assert.AreEqual ("-P-9", Double.MinValue.ToString ("P-9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15019 ()
+ {
+ Assert.AreEqual ("P0", 0.0.ToString ("P0,", _nfi), "#01");
+ Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0,", _nfi), "#02");
+ Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0,", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15020 ()
+ {
+ Assert.AreEqual ("P0", 0.0.ToString ("P0.", _nfi), "#01");
+ Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0.", _nfi), "#02");
+ Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0.", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15021 ()
+ {
+ Assert.AreEqual ("P0.0", 0.0.ToString ("P0.0", _nfi), "#01");
+ Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("P0.0", _nfi), "#02");
+ Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("P0.0", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15022 ()
+ {
+ Assert.AreEqual ("P09", 0.0.ToString ("P0.9", _nfi), "#01");
+ Assert.AreEqual ("P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("P0.9", _nfi), "#02");
+ Assert.AreEqual ("-P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("P0.9", _nfi), "#03");
+ }
+
+ [Test]
+ public void Test15023 ()
+ {
+ Assert.AreEqual ("999.1 %", 9.9905.ToString ("P1", _nfi), "#01");
+ Assert.AreEqual ("999.2 %", 9.9915.ToString ("P1", _nfi), "#02");
+ Assert.AreEqual ("999.3 %", 9.9925.ToString ("P1", _nfi), "#03");
+ Assert.AreEqual ("999.4 %", 9.9935.ToString ("P1", _nfi), "#04");
+ Assert.AreEqual ("999.5 %", 9.9945.ToString ("P1", _nfi), "#05");
+ Assert.AreEqual ("999.6 %", 9.9955.ToString ("P1", _nfi), "#06");
+ Assert.AreEqual ("999.7 %", 9.9965.ToString ("P1", _nfi), "#07");
+ Assert.AreEqual ("999.8 %", 9.9975.ToString ("P1", _nfi), "#08");
+ Assert.AreEqual ("999.9 %", 9.9985.ToString ("P1", _nfi), "#09");
+ Assert.AreEqual ("1,000.0 %", 9.9995.ToString ("P1", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test15024 ()
+ {
+ Assert.AreEqual ("999.91 %", 9.99905.ToString ("P2", _nfi), "#01");
+ Assert.AreEqual ("999.92 %", 9.99915.ToString ("P2", _nfi), "#02");
+ Assert.AreEqual ("999.93 %", 9.99925.ToString ("P2", _nfi), "#03");
+ Assert.AreEqual ("999.94 %", 9.99935.ToString ("P2", _nfi), "#04");
+ Assert.AreEqual ("999.95 %", 9.99945.ToString ("P2", _nfi), "#05");
+ Assert.AreEqual ("999.96 %", 9.99955.ToString ("P2", _nfi), "#06");
+ Assert.AreEqual ("999.97 %", 9.99965.ToString ("P2", _nfi), "#07");
+ Assert.AreEqual ("999.98 %", 9.99975.ToString ("P2", _nfi), "#08");
+ Assert.AreEqual ("999.99 %", 9.99985.ToString ("P2", _nfi), "#09");
+ Assert.AreEqual ("1,000.00 %", 9.99995.ToString ("P2", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test15025 ()
+ {
+ Assert.AreEqual ("999.99999999991 %", 9.99999999999905.ToString ("P11", _nfi), "#01");
+ Assert.AreEqual ("999.99999999992 %", 9.99999999999915.ToString ("P11", _nfi), "#02");
+ Assert.AreEqual ("999.99999999993 %", 9.99999999999925.ToString ("P11", _nfi), "#03");
+ Assert.AreEqual ("999.99999999994 %", 9.99999999999935.ToString ("P11", _nfi), "#04");
+ Assert.AreEqual ("999.99999999995 %", 9.99999999999945.ToString ("P11", _nfi), "#05");
+ Assert.AreEqual ("999.99999999996 %", 9.99999999999955.ToString ("P11", _nfi), "#06");
+ Assert.AreEqual ("999.99999999997 %", 9.99999999999965.ToString ("P11", _nfi), "#07");
+ Assert.AreEqual ("999.99999999998 %", 9.99999999999975.ToString ("P11", _nfi), "#08");
+ Assert.AreEqual ("999.99999999999 %", 9.99999999999985.ToString ("P11", _nfi), "#09");
+ Assert.AreEqual ("1,000.00000000000 %", 9.99999999999995.ToString ("P11", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test15026 ()
+ {
+ Assert.AreEqual ("999.999999999991 %", 9.999999999999905.ToString ("P12", _nfi), "#01");
+ Assert.AreEqual ("999.999999999991 %", 9.999999999999915.ToString ("P12", _nfi), "#02");
+ Assert.AreEqual ("999.999999999993 %", 9.999999999999925.ToString ("P12", _nfi), "#03");
+ Assert.AreEqual ("999.999999999993 %", 9.999999999999935.ToString ("P12", _nfi), "#04");
+ Assert.AreEqual ("999.999999999994 %", 9.999999999999945.ToString ("P12", _nfi), "#05");
+ Assert.AreEqual ("999.999999999996 %", 9.999999999999955.ToString ("P12", _nfi), "#06");
+ Assert.AreEqual ("999.999999999996 %", 9.999999999999965.ToString ("P12", _nfi), "#07");
+ Assert.AreEqual ("999.999999999998 %", 9.999999999999975.ToString ("P12", _nfi), "#08");
+ Assert.AreEqual ("999.999999999999 %", 9.999999999999985.ToString ("P12", _nfi), "#09");
+ Assert.AreEqual ("999.999999999999 %", 9.999999999999995.ToString ("P12", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test15027 ()
+ {
+ Assert.AreEqual ("999.9999999999990 %", 9.9999999999999905.ToString ("P13", _nfi), "#01");
+ Assert.AreEqual ("999.9999999999990 %", 9.9999999999999915.ToString ("P13", _nfi), "#02");
+ Assert.AreEqual ("999.9999999999990 %", 9.9999999999999925.ToString ("P13", _nfi), "#03");
+ Assert.AreEqual ("999.9999999999990 %", 9.9999999999999935.ToString ("P13", _nfi), "#04");
+ Assert.AreEqual ("999.9999999999990 %", 9.9999999999999945.ToString ("P13", _nfi), "#05");
+ Assert.AreEqual ("999.9999999999990 %", 9.9999999999999955.ToString ("P13", _nfi), "#06");
+ Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999965.ToString ("P13", _nfi), "#07");
+ Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999975.ToString ("P13", _nfi), "#08");
+ Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999985.ToString ("P13", _nfi), "#09");
+ Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999995.ToString ("P13", _nfi), "#10");
+ }
+
+ [Test]
+ public void Test15028 ()
+ {
+ Assert.AreEqual ("1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi), "#01");
+ Assert.AreEqual ("1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi), "#02");
+ Assert.AreEqual ("1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi), "#03");
+ Assert.AreEqual ("1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi), "#04");
+ Assert.AreEqual ("1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi), "#05");
+ Assert.AreEqual ("1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi), "#06");
+ Assert.AreEqual ("N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100"), "#07");
+ }
+
+ [Test]
+ public void Test15029 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.PercentDecimalSeparator = "#";
+ Assert.AreEqual ("-9,999,999,990#00 %", (-99999999.9).ToString ("P", nfi), "#01");
+ }
+
+ [Test]
+ public void Test15030 ()
+ {
+ NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
+ nfi.NegativeSign = "+";
+ nfi.PositiveSign = "-";
+
+ Assert.AreEqual ("1,000.00 %", 10.0.ToString ("P", nfi), "#01");
+ Assert.AreEqual ("0.00 %", 0.0.ToString ("P", nfi), "#02");
+ Assert.AreEqual ("+1,000.00 %", (-10.0).ToString ("P", nfi), "#03");
+ }
+
+ [Test]
+ public void Test15031 ()
+ {
+ Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi) , "#01");
+ Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi) , "#02");
+ Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("N99", _nfi) , "#03");
+ }
+
+ // TestRoundtrip for double and single
+ [Test]
+ public void TestRoundtrip()
+ {
+ Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("R", _nfi), "#01");
+ Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("r", _nfi), "#02");
+ Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("R0", _nfi), "#03");
+ Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("r0", _nfi), "#04");
+ Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("R99", _nfi), "#05");
+ Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("r99", _nfi), "#06");
+ Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("R"), "#07");
+ Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("R"), "#08");
+ Assert.AreEqual ("-1.7976931348623147E+308", (-1.7976931348623147E+308).ToString("R"), "#09");
+ Assert.AreEqual ("-3.40282347E+38", Single.MinValue.ToString("R"), "#10");
+ Assert.AreEqual ("3.40282347E+38", Single.MaxValue.ToString("R"), "#11");
+ }
+
+ // Tests arithmetic overflow in double.ToString exposed by Bug #383531
+ [Test]
+ public void TestToStringOverflow()
+ {
+ // Test all the possible double exponents with the maximal mantissa
+ long dblPattern = 0xfffffffffffff; // all 1s significand
+
+ for (long exp = 0; exp < 4096; exp++) {
+ double val = BitConverter.Int64BitsToDouble((long)(dblPattern | (exp << 52)));
+ string strRes = val.ToString("R", NumberFormatInfo.InvariantInfo);
+ double rndTripVal = Double.Parse(strRes);
+ Assert.AreEqual (val, rndTripVal, "Iter#" + exp);
+ }
+ }
+
+ // Test17000 - Double and X
+ [Test]
+ [ExpectedException (typeof (FormatException))]
+ public void Test17000 ()
+ {
+ Assert.AreEqual ("", 0.0.ToString ("X99", _nfi) , "#01");
+ }
+
+ [Test]
+ public void Test18000 ()
+ {
+ string formatString = "p 00.0000\\';n 0000.00\\';0.#\\'";
+
+ Assert.AreEqual ("p 08.3266'", 8.32663472.ToString (formatString, CultureInfo.InvariantCulture), "#1");
+ Assert.AreEqual ("n 0001.13'", (-1.1345343).ToString (formatString, CultureInfo.InvariantCulture), "#2");
+ Assert.AreEqual ("0'", 0.0.ToString (formatString, CultureInfo.InvariantCulture), "#3");
+ }
+ }
+}
projects / mono.git / blobdiff