mcs/class/corlib/Test/System/DoubleTest.cs

   1 // DoubleTest.cs - NUnit Test Cases for the System.Double class
   2 //
   3 // Bob Doan <bdoan@sicompos.com>
   4 //
   5 // (C) Ximian, Inc.  http://www.ximian.com
   6 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
   7 //
   8
   9 using System;
  10 using System.Collections;
  11 using System.Globalization;
  12 using System.Threading;
  13
  14 using NUnit.Framework;
  15
  16 namespace MonoTests.System {
  17
  18         [TestFixture]
  19         public class DoubleTest : Assertion {
  20
  21                 private const Double d_zero = 0.0;
  22                 private const Double d_neg = -1234.5678;
  23                 private const Double d_pos = 1234.9999;
  24                 private const Double d_pos2 = 1234.9999;
  25                 private const Double d_nan = Double.NaN;
  26                 private const Double d_pinf = Double.PositiveInfinity;
  27                 private const Double d_ninf = Double.NegativeInfinity;
  28                 private const String s = "What Ever";
  29                 private NumberFormatInfo Nfi = NumberFormatInfo.InvariantInfo;
  30
  31
  32                 private string[] string_values = {
  33                         "1", ".1", "1.1", "-12", "44.444432", ".000021121",
  34                         "   .00001", "  .223    ", "         -221.3233",
  35                         " 1.7976931348623157e308 ", "+1.7976931348623157E308", "-1.7976931348623157e308",
  36                         "4.9406564584124650e-324",
  37                         "6.28318530717958647692528676655900577",
  38                         "1e-05",
  39                         "6363883797383966.2933E-726",
  40                 };
  41
  42                 private string[] string_values_fail = {
  43                         "",     // empty
  44                         "- 1.0" // Inner whitespace
  45                 };
  46
  47                 private double[] double_values = {
  48                         1, .1, 1.1, -12, 44.444432, .000021121,
  49                         .00001, .223, -221.3233,
  50                         1.7976931348623157e308, 1.7976931348623157e308, -1.7976931348623157e308,
  51                         4.9406564584124650e-324,
  52                         6.28318530717958647692528676655900577,
  53                         1e-05,
  54                         0,
  55                 };
  56
  57                 [SetUp]
  58                 public void GetReady()
  59                 {
  60                         string sep = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
  61                         string_values [0] = "1";
  62                         string_values [1] = sep + "1";
  63                         string_values [2] = "1" + sep + "1";
  64                         string_values [3] = "-12";
  65                         string_values [4] = "44" + sep + "444432";
  66                         string_values [5] = sep + "000021121";
  67                         string_values [6] = "   " + sep + "00001";
  68                         string_values [7] = "  " + sep + "223    ";
  69                         string_values [8] = "         -221" + sep + "3233";
  70                         string_values [9] = " 1" + sep + "7976931348623157e308 ";
  71                         string_values [10] = "+1" + sep + "7976931348623157E308";
  72                         string_values [11] = "-1" + sep + "7976931348623157e308";
  73                         string_values [12] = "4" + sep + "9406564584124650e-324";
  74                         string_values [13] = "6" + sep + "28318530717958647692528676655900577";
  75                         string_values [14] = "1e-05";
  76                 }
  77
  78                 [Test]
  79                 public void PublicFields ()
  80                 {
  81                         Assertion.AssertEquals("Epsilon Field has wrong value", 3.9406564584124654e-324, Double.Epsilon);
  82                         Assertion.AssertEquals("MaxValue Field has wrong value", 1.7976931348623157e+308, Double.MaxValue);
  83                         Assertion.AssertEquals("MinValue Field has wrong value", -1.7976931348623157e+308, Double.MinValue);
  84                         Assertion.AssertEquals("NegativeInfinity Field has wrong value",  (double)-1.0 / (double)(0.0), Double.NegativeInfinity);
  85                         Assertion.AssertEquals("PositiveInfinity Field has wrong value",  (double)1.0 / (double)(0.0), Double.PositiveInfinity);
  86                 }
  87
  88                 [Test]
  89                 public void CompareTo () {
  90                         //If you do int foo =  d_ninf.CompareTo(d_pinf); Assertion.Assert(".." foo < 0, true) this works.... WHY???
  91                         Assertion.Assert("CompareTo Infinity failed", d_ninf.CompareTo(d_pinf) < 0);
  92
  93                         Assertion.Assert("CompareTo Failed01", d_neg.CompareTo(d_pos) < 0);
  94                         Assertion.Assert("CompareTo NaN Failed", d_nan.CompareTo(d_neg) < 0);
  95
  96                         Assertion.AssertEquals("CompareTo Failed02", 0, d_pos.CompareTo(d_pos2));
  97                         Assertion.AssertEquals("CompareTo Failed03", 0, d_pinf.CompareTo(d_pinf));
  98                         Assertion.AssertEquals("CompareTo Failed04", 0, d_ninf.CompareTo(d_ninf));
  99                         Assertion.AssertEquals("CompareTo Failed05", 0, d_nan.CompareTo(d_nan));
 100
 101                         Assertion.Assert("CompareTo Failed06", d_pos.CompareTo(d_neg) > 0);
 102                         Assertion.Assert("CompareTo Failed07", d_pos.CompareTo(d_nan) > 0);
 103                         Assertion.Assert("CompareTo Failed08", d_pos.CompareTo(null) > 0);
 104
 105                         try {
 106                                 d_pos.CompareTo(s);
 107                                 Assertion.Fail("CompareTo should raise a System.ArgumentException");
 108                         }
 109                         catch (Exception e) {
 110                                 Assertion.AssertEquals("CompareTo should be a System.ArgumentException", typeof(ArgumentException), e.GetType());
 111                         }
 112
 113                 }
 114
 115                 [Test]
 116                 public void Equals () {
 117                         Assertion.AssertEquals("Equals Failed", true, d_pos.Equals(d_pos2));
 118                         Assertion.AssertEquals("Equals Failed", false, d_pos.Equals(d_neg));
 119                         Assertion.AssertEquals("Equals Failed", false, d_pos.Equals(s));
 120
 121                 }
 122
 123                 [Test]
 124                 public void TestTypeCode () {
 125                         Assertion.AssertEquals("GetTypeCode Failed", TypeCode.Double, d_pos.GetTypeCode());
 126                 }
 127
 128                 [Test]
 129                 public void IsInfinity() {
 130                         Assertion.AssertEquals("IsInfinity Failed", true, Double.IsInfinity(Double.PositiveInfinity));
 131                         Assertion.AssertEquals("IsInfinity Failed", true, Double.IsInfinity(Double.NegativeInfinity));
 132                         Assertion.AssertEquals("IsInfinity Failed", false, Double.IsInfinity(12));
 133                 }
 134
 135                 [Test]
 136                 public void IsNan() {
 137                         Assertion.AssertEquals("IsNan Failed", true, Double.IsNaN(Double.NaN));
 138                         Assertion.AssertEquals("IsNan Failed", false, Double.IsNaN(12));
 139                         Assertion.AssertEquals("IsNan Failed", false, Double.IsNaN(Double.PositiveInfinity));
 140                 }
 141
 142                 [Test]
 143                 public void IsNegativeInfinity() {
 144                         Assertion.AssertEquals("IsNegativeInfinity Failed", true, Double.IsNegativeInfinity(Double.NegativeInfinity));
 145                         Assertion.AssertEquals("IsNegativeInfinity Failed", false, Double.IsNegativeInfinity(12));
 146                 }
 147
 148                 [Test]
 149                 public void IsPositiveInfinity() {
 150                         Assertion.AssertEquals("IsPositiveInfinity Failed", true, Double.IsPositiveInfinity(Double.PositiveInfinity));
 151                         Assertion.AssertEquals("IsPositiveInfinity Failed", false, Double.IsPositiveInfinity(12));
 152                 }
 153
 154                 [Test]
 155                 public void Parse() {
 156                         int i=0;
 157                         try {
 158                                 for(i=0;i<string_values.Length;i++) {
 159                                         Assertion.AssertEquals("Parse Failed", double_values[i], Double.Parse(string_values[i]));
 160                                 }
 161                         } catch (Exception e) {
 162                                 Assertion.Fail("TestParse: i=" + i + " failed with e = " + e.ToString());
 163                         }
 164
 165                         try {
 166                                 Assertion.AssertEquals("Parse Failed NumberStyles.Float", 10.1111, Double.Parse(" 10.1111 ", NumberStyles.Float, Nfi));
 167                         } catch (Exception e) {
 168                                 Assertion.Fail("TestParse: Parse Failed NumberStyles.Float with e = " + e.ToString());
 169                         }
 170
 171                         try {
 172                                 Assertion.AssertEquals("Parse Failed NumberStyles.AllowThousands", 1234.5678, Double.Parse("1,234.5678", NumberStyles.Float | NumberStyles.AllowThousands, Nfi));
 173                         } catch (Exception e) {
 174                                 Assertion.Fail("TestParse: Parse Failed NumberStyles.AllowThousands with e = " + e.ToString());
 175                         }
 176
 177                         try {
 178                                 Double.Parse(null);
 179                                 Assertion.Fail("Parse should raise a ArgumentNullException");
 180                         }
 181                         catch (Exception e) {
 182                                 Assertion.Assert("Parse should be a ArgumentNullException", typeof(ArgumentNullException) == e.GetType());
 183                         }
 184
 185                         try {
 186                                 Double.Parse("save the elk");
 187                                 Assertion.Fail("Parse should raise a FormatException");
 188                         }
 189                         catch (Exception e) {
 190                                 Assertion.Assert("Parse should be a FormatException", typeof(FormatException) == e.GetType());
 191                         }
 192
 193                         string sep = NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
 194                         double ovf_plus = 0;
 195                         try {
 196                                 ovf_plus = Double.Parse("1" + sep + "79769313486232e308");
 197                                 Assertion.Fail("Parse should have raised an OverflowException +");
 198                         }
 199                         catch (Exception e) {
 200                                 Assertion.AssertEquals("Should be an OverflowException + for " + ovf_plus, typeof(OverflowException), e.GetType());
 201                         }
 202
 203                         try {
 204                                 Double.Parse("-1" + sep + "79769313486232e308");
 205                                 Assertion.Fail("Parse should have raised an OverflowException -");
 206                         }
 207                         catch (Exception e) {
 208                                 Assertion.AssertEquals("Should be an OverflowException -", typeof(OverflowException), e.GetType());
 209                         }
 210
 211                         for (i = 0; i < string_values_fail.Length; ++i) {
 212                                 try {
 213                                         Double.Parse (string_values_fail [i]);
 214                                         Assertion.Fail ("Parse () should fail on '" + string_values_fail [i]);
 215                                 }
 216                                 catch (FormatException) {
 217                                 }
 218                         }
 219                 }
 220
 221                 [Test]
 222                 public void TestToString() {
 223                         //ToString is not yet Implemented......
 224                         //Assertion.AssertEquals("ToString Failed", "1234.9999", d_pos.ToString());
 225                         double d;
 226                         try {
 227                                 d = 3.1415;
 228                                 d.ToString ("X");
 229                                 d.ToString ("D");
 230                                 Assertion.Fail("Should have thrown FormatException");
 231                         } catch (FormatException) {
 232                                 /* do nothing, this is what we expect */
 233                         } catch (Exception e) {
 234                                 Assertion.Fail("Unexpected exception e: " + e);
 235                         }
 236
 237                         CustomFormatHelper();
 238
 239                 }
 240
 241                 private class Element {
 242                         public double value;
 243                         public string format;
 244                         public string result;
 245                         public Element (double value, string format, string result) {
 246                                 this.value = value;
 247                                 this.format = format;
 248                                 this.result = result;
 249                         }
 250                 }
 251
 252                 public void CustomFormatHelper () {
 253
 254                         NumberFormatInfo nfi = new NumberFormatInfo();
 255
 256                         nfi.NaNSymbol = "NaN";
 257                         nfi.PositiveSign = "+";
 258                         nfi.NegativeSign = "-";
 259                         nfi.PerMilleSymbol = "x";
 260                         nfi.PositiveInfinitySymbol = "Infinity";
 261                         nfi.NegativeInfinitySymbol = "-Infinity";
 262
 263                         nfi.NumberDecimalDigits = 5;
 264                         nfi.NumberDecimalSeparator = ".";
 265                         nfi.NumberGroupSeparator = ",";
 266                         nfi.NumberGroupSizes = new int[] {3};
 267                         nfi.NumberNegativePattern = 2;
 268
 269                         nfi.CurrencyDecimalDigits = 2;
 270                         nfi.CurrencyDecimalSeparator = ".";
 271                         nfi.CurrencyGroupSeparator = ",";
 272                         nfi.CurrencyGroupSizes = new int[] {3};
 273                         nfi.CurrencyNegativePattern = 8;
 274                         nfi.CurrencyPositivePattern = 3;
 275                         nfi.CurrencySymbol = "$";
 276
 277                         nfi.PercentDecimalDigits = 5;
 278                         nfi.PercentDecimalSeparator = ".";
 279                         nfi.PercentGroupSeparator = ",";
 280                         nfi.PercentGroupSizes = new int[] {3};
 281                         nfi.PercentNegativePattern = 0;
 282                         nfi.PercentPositivePattern = 0;
 283                         nfi.PercentSymbol = "%";
 284
 285                         ArrayList list = new ArrayList();
 286                         list.Add(new Element(123d, "#####", "123"));
 287                         list.Add(new Element(123d, "00000", "00123"));
 288                         list.Add(new Element(123d, "(###) ### - ####", "()  - 123"));
 289                         list.Add(new Element(123d, "#.##", "123"));
 290                         list.Add(new Element(123d, "0.00", "123.00"));
 291                         list.Add(new Element(123d, "00.00", "123.00"));
 292                         list.Add(new Element(123d, "#,#", "123"));
 293                         list.Add(new Element(123d, "#,,", ""));
 294                         list.Add(new Element(123d, "#,,,", ""));
 295                         list.Add(new Element(123d, "#,##0,,", "0"));
 296                         list.Add(new Element(123d, "#0.##%", "12300%"));
 297                         list.Add(new Element(123d, "0.###E+0", "1.23E+2"));
 298                         list.Add(new Element(123d, "0.###E+000", "1.23E+002"));
 299                         list.Add(new Element(123d, "0.###E-000", "1.23E002"));
 300                         list.Add(new Element(123d, "[##-##-##]", "[-1-23]"));
 301                         list.Add(new Element(123d, "##;(##)", "123"));
 302                         list.Add(new Element(123d, "##;(##)", "123"));
 303                         list.Add(new Element(1234567890d, "#####", "1234567890"));
 304                         list.Add(new Element(1234567890d, "00000", "1234567890"));
 305                         list.Add(new Element(1234567890d,
 306                                                 "(###) ### - ####", "(123) 456 - 7890"));
 307                         list.Add(new Element(1234567890d, "#.##", "1234567890"));
 308                         list.Add(new Element(1234567890d, "0.00", "1234567890.00"));
 309                         list.Add(new Element(1234567890d, "00.00", "1234567890.00"));
 310                         list.Add(new Element(1234567890d, "#,#", "1,234,567,890"));
 311                         list.Add(new Element(1234567890d, "#,,", "1235"));
 312                         list.Add(new Element(1234567890d, "#,,,", "1"));
 313                         list.Add(new Element(1234567890d, "#,##0,,", "1,235"));
 314                         list.Add(new Element(1234567890d, "#0.##%", "123456789000%"));
 315                         list.Add(new Element(1234567890d, "0.###E+0", "1.235E+9"));
 316                         list.Add(new Element(1234567890d, "0.###E+000", "1.235E+009"));
 317                         list.Add(new Element(1234567890d, "0.###E-000", "1.235E009"));
 318                         list.Add(new Element(1234567890d, "[##-##-##]", "[123456-78-90]"));
 319                         list.Add(new Element(1234567890d, "##;(##)", "1234567890"));
 320                         list.Add(new Element(1234567890d, "##;(##)", "1234567890"));
 321                         list.Add(new Element(1.2d, "#####", "1"));
 322                         list.Add(new Element(1.2d, "00000", "00001"));
 323                         list.Add(new Element(1.2d, "(###) ### - ####", "()  - 1"));
 324                         list.Add(new Element(1.2d, "#.##", "1.2"));
 325                         list.Add(new Element(1.2d, "0.00", "1.20"));
 326                         list.Add(new Element(1.2d, "00.00", "01.20"));
 327                         list.Add(new Element(1.2d, "#,#", "1"));
 328                         list.Add(new Element(1.2d, "#,,", ""));
 329                         list.Add(new Element(1.2d, "#,,,", ""));
 330                         list.Add(new Element(1.2d, "#,##0,,", "0"));
 331                         list.Add(new Element(1.2d, "#0.##%", "120%"));
 332                         list.Add(new Element(1.2d, "0.###E+0", "1.2E+0"));
 333                         list.Add(new Element(1.2d, "0.###E+000", "1.2E+000"));
 334                         list.Add(new Element(1.2d, "0.###E-000", "1.2E000"));
 335                         list.Add(new Element(1.2d, "[##-##-##]", "[--1]"));
 336                         list.Add(new Element(1.2d, "##;(##)", "1"));
 337                         list.Add(new Element(1.2d, "##;(##)", "1"));
 338                         list.Add(new Element(0.086d, "#####", ""));
 339                         list.Add(new Element(0.086d, "00000", "00000"));
 340                         list.Add(new Element(0.086d, "(###) ### - ####", "()  - "));
 341                         list.Add(new Element(0.086d, "#.##", ".09"));
 342                         list.Add(new Element(0.086d, "0.00", "0.09"));
 343                         list.Add(new Element(0.086d, "00.00", "00.09"));
 344                         list.Add(new Element(0.086d, "#,#", ""));
 345                         list.Add(new Element(0.086d, "#,,", ""));
 346                         list.Add(new Element(0.086d, "#,,,", ""));
 347                         list.Add(new Element(0.086d, "#,##0,,", "0"));
 348                         list.Add(new Element(0.086d, "#0.##%", "8.6%"));
 349                         list.Add(new Element(0.086d, "0.###E+0", "8.6E-2"));
 350                         list.Add(new Element(0.086d, "0.###E+000", "8.6E-002"));
 351                         list.Add(new Element(0.086d, "0.###E-000", "8.6E-002"));
 352                         list.Add(new Element(0.086d, "[##-##-##]", "[--]"));
 353                         list.Add(new Element(0.086d, "##;(##)", ""));
 354                         list.Add(new Element(0.086d, "##;(##)", ""));
 355                         list.Add(new Element(86000d, "#####", "86000"));
 356                         list.Add(new Element(86000d, "00000", "86000"));
 357                         list.Add(new Element(86000d, "(###) ### - ####", "() 8 - 6000"));
 358                         list.Add(new Element(86000d, "#.##", "86000"));
 359                         list.Add(new Element(86000d, "0.00", "86000.00"));
 360                         list.Add(new Element(86000d, "00.00", "86000.00"));
 361                         list.Add(new Element(86000d, "#,#", "86,000"));
 362                         list.Add(new Element(86000d, "#,,", ""));
 363                         list.Add(new Element(86000d, "#,,,", ""));
 364                         list.Add(new Element(86000d, "#,##0,,", "0"));
 365                         list.Add(new Element(86000d, "#0.##%", "8600000%"));
 366                         list.Add(new Element(86000d, "0.###E+0", "8.6E+4"));
 367                         list.Add(new Element(86000d, "0.###E+000", "8.6E+004"));
 368                         list.Add(new Element(86000d, "0.###E-000", "8.6E004"));
 369                         list.Add(new Element(86000d, "[##-##-##]", "[8-60-00]"));
 370                         list.Add(new Element(86000d, "##;(##)", "86000"));
 371                         list.Add(new Element(86000d, "##;(##)", "86000"));
 372                         list.Add(new Element(123456d, "#####", "123456"));
 373                         list.Add(new Element(123456d, "00000", "123456"));
 374                         list.Add(new Element(123456d, "(###) ### - ####", "() 12 - 3456"));
 375                         list.Add(new Element(123456d, "#.##", "123456"));
 376                         list.Add(new Element(123456d, "0.00", "123456.00"));
 377                         list.Add(new Element(123456d, "00.00", "123456.00"));
 378                         list.Add(new Element(123456d, "#,#", "123,456"));
 379                         list.Add(new Element(123456d, "#,,", ""));
 380                         list.Add(new Element(123456d, "#,,,", ""));
 381                         list.Add(new Element(123456d, "#,##0,,", "0"));
 382                         list.Add(new Element(123456d, "#0.##%", "12345600%"));
 383                         list.Add(new Element(123456d, "0.###E+0", "1.235E+5"));
 384                         list.Add(new Element(123456d, "0.###E+000", "1.235E+005"));
 385                         list.Add(new Element(123456d, "0.###E-000", "1.235E005"));
 386                         list.Add(new Element(123456d, "[##-##-##]", "[12-34-56]"));
 387                         list.Add(new Element(123456d, "##;(##)", "123456"));
 388                         list.Add(new Element(123456d, "##;(##)", "123456"));
 389                         list.Add(new Element(1234d, "#####", "1234"));
 390                         list.Add(new Element(1234d, "00000", "01234"));
 391                         list.Add(new Element(1234d, "(###) ### - ####", "()  - 1234"));
 392                         list.Add(new Element(1234d, "#.##", "1234"));
 393                         list.Add(new Element(1234d, "0.00", "1234.00"));
 394                         list.Add(new Element(1234d, "00.00", "1234.00"));
 395                         list.Add(new Element(1234d, "#,#", "1,234"));
 396                         list.Add(new Element(1234d, "#,,", ""));
 397                         list.Add(new Element(1234d, "#,,,", ""));
 398                         list.Add(new Element(1234d, "#,##0,,", "0"));
 399                         list.Add(new Element(1234d, "#0.##%", "123400%"));
 400                         list.Add(new Element(1234d, "0.###E+0", "1.234E+3"));
 401                         list.Add(new Element(1234d, "0.###E+000", "1.234E+003"));
 402                         list.Add(new Element(1234d, "0.###E-000", "1.234E003"));
 403                         list.Add(new Element(1234d, "[##-##-##]", "[-12-34]"));
 404                         list.Add(new Element(1234d, "##;(##)", "1234"));
 405                         list.Add(new Element(1234d, "##;(##)", "1234"));
 406                         list.Add(new Element(-1234d, "#####", "-1234"));
 407                         list.Add(new Element(-1234d, "00000", "-01234"));
 408                         list.Add(new Element(-1234d, "(###) ### - ####", "-()  - 1234"));
 409                         list.Add(new Element(-1234d, "#.##", "-1234"));
 410                         list.Add(new Element(-1234d, "0.00", "-1234.00"));
 411                         list.Add(new Element(-1234d, "00.00", "-1234.00"));
 412                         list.Add(new Element(-1234d, "#,#", "-1,234"));
 413                         list.Add(new Element(-1234d, "#,,", ""));
 414                         list.Add(new Element(-1234d, "#,,,", ""));
 415                         list.Add(new Element(-1234d, "#,##0,,", "0"));
 416                         list.Add(new Element(-1234d, "#0.##%", "-123400%"));
 417                         list.Add(new Element(-1234d, "0.###E+0", "-1.234E+3"));
 418                         list.Add(new Element(-1234d, "0.###E+000", "-1.234E+003"));
 419                         list.Add(new Element(-1234d, "0.###E-000", "-1.234E003"));
 420                         list.Add(new Element(-1234d, "[##-##-##]", "-[-12-34]"));
 421                         list.Add(new Element(-1234d, "##;(##)", "(1234)"));
 422                         list.Add(new Element(-1234d, "##;(##)", "(1234)"));
 423                         list.Add(new Element(12345678901234567890.123d,
 424                                                 "#####", "12345678901234600000"));
 425                         list.Add(new Element(12345678901234567890.123d,
 426                                                 "00000", "12345678901234600000"));
 427                         list.Add(new Element(12345678901234567890.123d,
 428                                                 "(###) ### - ####", "(1234567890123) 460 - 0000"));
 429                         list.Add(new Element(12345678901234567890.123d,
 430                                                 "#.##", "12345678901234600000"));
 431                         list.Add(new Element(12345678901234567890.123d,
 432                                                 "0.00", "12345678901234600000.00"));
 433                         list.Add(new Element(12345678901234567890.123d,
 434                                                 "00.00", "12345678901234600000.00"));
 435                         list.Add(new Element(12345678901234567890.123d,
 436                                                 "#,#", "12,345,678,901,234,600,000"));
 437                         list.Add(new Element(12345678901234567890.123d,
 438                                                 "#,,", "12345678901235"));
 439                         list.Add(new Element(12345678901234567890.123d,
 440                                                 "#,,,", "12345678901"));
 441                         list.Add(new Element(12345678901234567890.123d,
 442                                                 "#,##0,,", "12,345,678,901,235"));
 443                         list.Add(new Element(12345678901234567890.123d,
 444                                                 "#0.##%", "1234567890123460000000%"));
 445                         list.Add(new Element(12345678901234567890.123d,
 446                                                 "0.###E+0", "1.235E+19"));
 447                         list.Add(new Element(12345678901234567890.123d,
 448                                                 "0.###E+000", "1.235E+019"));
 449                         list.Add(new Element(12345678901234567890.123d,
 450                                                 "0.###E-000", "1.235E019"));
 451                         list.Add(new Element(12345678901234567890.123d,
 452                                                 "[##-##-##]", "[1234567890123460-00-00]"));
 453                         list.Add(new Element(12345678901234567890.123d,
 454                                                 "##;(##)", "12345678901234600000"));
 455                         list.Add(new Element(12345678901234567890.123d,
 456                                                 "##;(##)", "12345678901234600000"));
 457                         foreach (Element e in list) {
 458                                 Assertion.AssertEquals(
 459                                                 "ToString Failed: '" + e.value + "' Should be \"" + e.result + "\" with \"" + e.format + "\"",
 460                                                 e.result, e.value.ToString(e.format, nfi));
 461                         }
 462
 463                 }
 464
 465                 [Test]
 466                 public void ToString_Defaults ()
 467                 {
 468                         Double i = 254.9d;
 469                         // everything defaults to "G"
 470                         string def = i.ToString ("G");
 471                         AssertEquals ("ToString()", def, i.ToString ());
 472                         AssertEquals ("ToString((IFormatProvider)null)", def, i.ToString ((IFormatProvider)null));
 473                         AssertEquals ("ToString((string)null)", def, i.ToString ((string)null));
 474                         AssertEquals ("ToString(empty)", def, i.ToString (String.Empty));
 475                         AssertEquals ("ToString(null,null)", def, i.ToString (null, null));
 476                         AssertEquals ("ToString(empty,null)", def, i.ToString (String.Empty, null));
 477
 478                         AssertEquals ("ToString(G)", "254.9", def);
 479                 }
 480
 481                 [Test]
 482                 public void LongLongValueRoundtrip ()
 483                 {
 484                         // from bug #72955
 485                         double d = 0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000222;
 486                         AssertEquals ("1.97626258336499E-323", d.ToString ("R"));
 487                 }
 488
 489                 [Test]
 490 #if NET_2_0
 491                 [ExpectedException (typeof (ArgumentException))]
 492 #else
 493                 [Category ("NotWorking")]
 494                 // MS accept hex values under 1.x but the results neither match the long value
 495                 // nor the value of a 64bits double
 496 #endif
 497                 public void HexNumber_WithHexToParse ()
 498                 {
 499                         // from bug #72221
 500                         double d;
 501                         Assert ("parse", Double.TryParse ("0dead", NumberStyles.HexNumber, null, out d));
 502                         AssertEquals ("value", 57842, d, 0);
 503                 }
 504
 505                 [Test]
 506 #if NET_2_0
 507                 [ExpectedException (typeof (ArgumentException))]
 508 #else
 509                 [Category ("NotWorking")]
 510                 // MS accept hex values under 1.x but the results neither match the long value
 511                 // nor the value of a 64bits double
 512 #endif
 513                 public void HexNumber_NoHexToParse ()
 514                 {
 515                         double d;
 516                         Assert ("parse", Double.TryParse ("0", NumberStyles.HexNumber, null, out d));
 517                         AssertEquals ("value", 0, d, 0);
 518                 }
 519
 520                 [Test]
 521                 public void TryParseBug78546 ()
 522                 {
 523                         double value;
 524                         Assert (!Double.TryParse ("error",
 525                                 NumberStyles.Integer, null, out value));
 526                 }
 527
 528                 [Test] // bug #77721
 529                 public void ParseCurrency ()
 530                 {
 531                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US");
 532                         NumberFormatInfo f = NumberFormatInfo.CurrentInfo;
 533                         double dMin = double.Parse ("$0.00", NumberStyles.Currency, f);
 534                 }
 535         }
 536 }