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

   1 //
   2 // MonoTests.System.NumberFormatterTest
   3 //
   4 // Authors:
   5 //      akiramei (mei@work.email.ne.jp)
   6 //
   7 // (C) 2005 akiramei
   8 //
   9
  10 using System;
  11 using System.Globalization;
  12 using System.Threading;
  13
  14 using NUnit.Framework;
  15
  16 namespace MonoTests.System
  17 {
  18         [TestFixture]
  19         public class NumberFormatterTest
  20         {
  21                 CultureInfo old_culture;
  22                 NumberFormatInfo _nfi;
  23
  24                 [SetUp]
  25                 public void SetUp ()
  26                 {
  27                         old_culture = Thread.CurrentThread.CurrentCulture;
  28                         Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
  29                         _nfi = NumberFormatInfo.InvariantInfo.Clone () as NumberFormatInfo;
  30                 }
  31
  32                 [TearDown]
  33                 public void TearDown ()
  34                 {
  35                         Thread.CurrentThread.CurrentCulture = old_culture;
  36                 }
  37
  38                 // Test00000- Int32 and D
  39                 [Test]
  40                 public void Test00000 ()
  41                 {
  42                         Assert.AreEqual ("0", 0.ToString ("D", _nfi), "#01");
  43                         Assert.AreEqual ("0", 0.ToString ("d", _nfi), "#02");
  44                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("D", _nfi), "#03");
  45                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("d", _nfi), "#04");
  46                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("D", _nfi), "#05");
  47                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("d", _nfi), "#06");
  48                 }
  49
  50                 [Test]
  51                 public void Test00001 ()
  52                 {
  53                         Assert.AreEqual ("D ", 0.ToString ("D ", _nfi), "#01");
  54                         Assert.AreEqual (" D", 0.ToString (" D", _nfi), "#02");
  55                         Assert.AreEqual (" D ", 0.ToString (" D ", _nfi), "#03");
  56                 }
  57
  58                 [Test]
  59                 public void Test00002 ()
  60                 {
  61                         Assert.AreEqual ("-D ", (-1).ToString ("D ", _nfi), "#01");
  62                         Assert.AreEqual ("- D", (-1).ToString (" D", _nfi), "#02");
  63                         Assert.AreEqual ("- D ", (-1).ToString (" D ", _nfi), "#03");
  64                 }
  65
  66                 [Test]
  67                 public void Test00003 ()
  68                 {
  69                         Assert.AreEqual ("0", 0.ToString ("D0", _nfi), "#01");
  70                         Assert.AreEqual ("0000000000", 0.ToString ("D10", _nfi), "#02");
  71                         Assert.AreEqual ("00000000000", 0.ToString ("D11", _nfi), "#03");
  72                         Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("D99", _nfi), "#04");
  73                         Assert.AreEqual ("D100", 0.ToString ("D100", _nfi), "#05");
  74                 }
  75
  76                 [Test]
  77                 public void Test00004 ()
  78                 {
  79                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("D0", _nfi), "#01");
  80                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("D10", _nfi), "#02");
  81                         Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("D11", _nfi), "#03");
  82                         Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483647", Int32.MaxValue.ToString ("D99", _nfi), "#04");
  83                         Assert.AreEqual ("D12147483647", Int32.MaxValue.ToString ("D100", _nfi), "#05");
  84                 }
  85
  86                 [Test]
  87                 public void Test00005 ()
  88                 {
  89                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("D0", _nfi), "#01");
  90                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("D10", _nfi), "#02");
  91                         Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("D11", _nfi), "#03");
  92                         Assert.AreEqual ("-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483648", Int32.MinValue.ToString ("D99", _nfi), "#04");
  93                         Assert.AreEqual ("-D12147483648", Int32.MinValue.ToString ("D100", _nfi), "#05");
  94                 }
  95
  96                 [Test]
  97                 public void Test00006 ()
  98                 {
  99                         Assert.AreEqual ("DF", 0.ToString ("DF", _nfi), "#01");
 100                         Assert.AreEqual ("D0F", 0.ToString ("D0F", _nfi), "#02");
 101                         Assert.AreEqual ("D0xF", 0.ToString ("D0xF", _nfi), "#03");
 102                 }
 103
 104                 [Test]
 105                 public void Test00007 ()
 106                 {
 107                         Assert.AreEqual ("DF", Int32.MaxValue.ToString ("DF", _nfi), "#01");
 108                         Assert.AreEqual ("D2147483647F", Int32.MaxValue.ToString ("D0F", _nfi), "#02");
 109                         Assert.AreEqual ("D2147483647xF", Int32.MaxValue.ToString ("D0xF", _nfi), "#03");
 110                 }
 111
 112                 [Test]
 113                 public void Test00008 ()
 114                 {
 115                         Assert.AreEqual ("-DF", Int32.MinValue.ToString ("DF", _nfi), "#01");
 116                         Assert.AreEqual ("-D2147483648F", Int32.MinValue.ToString ("D0F", _nfi), "#02");
 117                         Assert.AreEqual ("-D2147483648xF", Int32.MinValue.ToString ("D0xF", _nfi), "#03");
 118                 }
 119
 120                 [Test]
 121                 public void Test00009 ()
 122                 {
 123                         Assert.AreEqual ("00000000000", 0.ToString ("D0000000000000000000000000000000000000011", _nfi), "#01");
 124                         Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("D0000000000000000000000000000000000000011", _nfi), "#02");
 125                         Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("D0000000000000000000000000000000000000011", _nfi), "#03");
 126                 }
 127
 128                 [Test]
 129                 public void Test00010 ()
 130                 {
 131                         Assert.AreEqual ("+D", 0.ToString ("+D", _nfi), "#01");
 132                         Assert.AreEqual ("D+", 0.ToString ("D+", _nfi), "#02");
 133                         Assert.AreEqual ("+D+", 0.ToString ("+D+", _nfi), "#03");
 134                 }
 135
 136                 [Test]
 137                 public void Test00011 ()
 138                 {
 139                         Assert.AreEqual ("+D", Int32.MaxValue.ToString ("+D", _nfi), "#01");
 140                         Assert.AreEqual ("D+", Int32.MaxValue.ToString ("D+", _nfi), "#02");
 141                         Assert.AreEqual ("+D+", Int32.MaxValue.ToString ("+D+", _nfi), "#03");
 142                 }
 143
 144                 [Test]
 145                 public void Test00012 ()
 146                 {
 147                         Assert.AreEqual ("-+D", Int32.MinValue.ToString ("+D", _nfi), "#01");
 148                         Assert.AreEqual ("-D+", Int32.MinValue.ToString ("D+", _nfi), "#02");
 149                         Assert.AreEqual ("-+D+", Int32.MinValue.ToString ("+D+", _nfi), "#03");
 150                 }
 151
 152                 [Test]
 153                 public void Test00013 ()
 154                 {
 155                         Assert.AreEqual ("-D", 0.ToString ("-D", _nfi), "#01");
 156                         Assert.AreEqual ("D-", 0.ToString ("D-", _nfi), "#02");
 157                         Assert.AreEqual ("-D-", 0.ToString ("-D-", _nfi), "#03");
 158                 }
 159
 160                 [Test]
 161                 public void Test00014 ()
 162                 {
 163                         Assert.AreEqual ("-D", Int32.MaxValue.ToString ("-D", _nfi), "#01");
 164                         Assert.AreEqual ("D-", Int32.MaxValue.ToString ("D-", _nfi), "#02");
 165                         Assert.AreEqual ("-D-", Int32.MaxValue.ToString ("-D-", _nfi), "#03");
 166                 }
 167
 168                 [Test]
 169                 public void Test00015 ()
 170                 {
 171                         Assert.AreEqual ("--D", Int32.MinValue.ToString ("-D", _nfi), "#01");
 172                         Assert.AreEqual ("-D-", Int32.MinValue.ToString ("D-", _nfi), "#02");
 173                         Assert.AreEqual ("--D-", Int32.MinValue.ToString ("-D-", _nfi), "#03");
 174                 }
 175
 176                 [Test]
 177                 public void Test00016 ()
 178                 {
 179                         Assert.AreEqual ("D+0", 0.ToString ("D+0", _nfi), "#01");
 180                         Assert.AreEqual ("D+2147483647", Int32.MaxValue.ToString ("D+0", _nfi), "#02");
 181                         Assert.AreEqual ("-D+2147483648", Int32.MinValue.ToString ("D+0", _nfi), "#03");
 182                 }
 183
 184                 [Test]
 185                 public void Test00017 ()
 186                 {
 187                         Assert.AreEqual ("D+9", 0.ToString ("D+9", _nfi), "#01");
 188                         Assert.AreEqual ("D+9", Int32.MaxValue.ToString ("D+9", _nfi), "#02");
 189                         Assert.AreEqual ("-D+9", Int32.MinValue.ToString ("D+9", _nfi), "#03");
 190                 }
 191
 192                 [Test]
 193                 public void Test00018 ()
 194                 {
 195                         Assert.AreEqual ("D-9", 0.ToString ("D-9", _nfi), "#01");
 196                         Assert.AreEqual ("D-9", Int32.MaxValue.ToString ("D-9", _nfi), "#02");
 197                         Assert.AreEqual ("-D-9", Int32.MinValue.ToString ("D-9", _nfi), "#03");
 198                 }
 199
 200                 [Test]
 201                 public void Test00019 ()
 202                 {
 203                         Assert.AreEqual ("D0", 0.ToString ("D0,", _nfi), "#01");
 204                         Assert.AreEqual ("D2147484", Int32.MaxValue.ToString ("D0,", _nfi), "#02");
 205                         Assert.AreEqual ("-D2147484", Int32.MinValue.ToString ("D0,", _nfi), "#03");
 206                 }
 207
 208                 [Test]
 209                 public void Test00020 ()
 210                 {
 211                         Assert.AreEqual ("D0", 0.ToString ("D0.", _nfi), "#01");
 212                         Assert.AreEqual ("D2147483647", Int32.MaxValue.ToString ("D0.", _nfi), "#02");
 213                         Assert.AreEqual ("-D2147483648", Int32.MinValue.ToString ("D0.", _nfi), "#03");
 214                 }
 215
 216                 [Test]
 217                 public void Test00021 ()
 218                 {
 219                         Assert.AreEqual ("D0.0", 0.ToString ("D0.0", _nfi), "#01");
 220                         Assert.AreEqual ("D2147483647.0", Int32.MaxValue.ToString ("D0.0", _nfi), "#02");
 221                         Assert.AreEqual ("-D2147483648.0", Int32.MinValue.ToString ("D0.0", _nfi), "#03");
 222                 }
 223
 224                 [Test]
 225                 public void Test00022 ()
 226                 {
 227                         Assert.AreEqual ("D09", 0.ToString ("D0.9", _nfi), "#01");
 228                         Assert.AreEqual ("D21474836479", Int32.MaxValue.ToString ("D0.9", _nfi), "#02");
 229                         Assert.AreEqual ("-D21474836489", Int32.MinValue.ToString ("D0.9", _nfi), "#03");
 230                 }
 231
 232                 // Test01000- Int32 and E
 233                 [Test]
 234                 public void Test01000 ()
 235                 {
 236                         Assert.AreEqual ("0.000000E+000", 0.ToString ("E", _nfi), "#01");
 237                         Assert.AreEqual ("0.000000e+000", 0.ToString ("e", _nfi), "#02");
 238                         Assert.AreEqual ("-2.147484E+009", Int32.MinValue.ToString ("E", _nfi), "#03");
 239                         Assert.AreEqual ("-2.147484e+009", Int32.MinValue.ToString ("e", _nfi), "#04");
 240                         Assert.AreEqual ("2.147484E+009", Int32.MaxValue.ToString ("E", _nfi), "#05");
 241                         Assert.AreEqual ("2.147484e+009", Int32.MaxValue.ToString ("e", _nfi), "#06");
 242                 }
 243
 244                 [Test]
 245                 public void Test01001 ()
 246                 {
 247                         Assert.AreEqual ("E ", 0.ToString ("E ", _nfi), "#01");
 248                         Assert.AreEqual (" E", 0.ToString (" E", _nfi), "#02");
 249                         Assert.AreEqual (" E ", 0.ToString (" E ", _nfi), "#03");
 250                 }
 251
 252                 [Test]
 253                 public void Test01002 ()
 254                 {
 255                         Assert.AreEqual ("-E ", (-1).ToString ("E ", _nfi), "#01");
 256                         Assert.AreEqual ("- E", (-1).ToString (" E", _nfi), "#02");
 257                         Assert.AreEqual ("- E ", (-1).ToString (" E ", _nfi), "#03");
 258                 }
 259
 260                 [Test]
 261                 public void Test01003 ()
 262                 {
 263                         Assert.AreEqual ("0E+000", 0.ToString ("E0", _nfi), "#01");
 264                         Assert.AreEqual ("0.000000000E+000", 0.ToString ("E9", _nfi), "#02");
 265                         Assert.AreEqual ("0.0000000000E+000", 0.ToString ("E10", _nfi), "#03");
 266                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.ToString ("E99", _nfi), "#04");
 267                         Assert.AreEqual ("E100", 0.ToString ("E100", _nfi), "#05");
 268                 }
 269
 270                 [Test]
 271                 public void Test01004 ()
 272                 {
 273                         Assert.AreEqual ("2E+009", Int32.MaxValue.ToString ("E0", _nfi), "#01");
 274                         Assert.AreEqual ("2.147483647E+009", Int32.MaxValue.ToString ("E9", _nfi), "#02");
 275                         Assert.AreEqual ("2.1474836470E+009", Int32.MaxValue.ToString ("E10", _nfi), "#03");
 276                         Assert.AreEqual ("2.147483647000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MaxValue.ToString ("E99", _nfi), "#04");
 277                         Assert.AreEqual ("E12147483647", Int32.MaxValue.ToString ("E100", _nfi), "#05");
 278                 }
 279
 280                 [Test]
 281                 public void Test01005 ()
 282                 {
 283                         Assert.AreEqual ("-2E+009", Int32.MinValue.ToString ("E0", _nfi), "#01");
 284                         Assert.AreEqual ("-2.147483648E+009", Int32.MinValue.ToString ("E9", _nfi), "#02");
 285                         Assert.AreEqual ("-2.1474836480E+009", Int32.MinValue.ToString ("E10", _nfi), "#03");
 286                         Assert.AreEqual ("-2.147483648000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MinValue.ToString ("E99", _nfi), "#04");
 287                         Assert.AreEqual ("-E12147483648", Int32.MinValue.ToString ("E100", _nfi), "#05");
 288                 }
 289
 290                 [Test]
 291                 public void Test01006 ()
 292                 {
 293                         Assert.AreEqual ("EF", 0.ToString ("EF", _nfi), "#01");
 294                         Assert.AreEqual ("E0F", 0.ToString ("E0F", _nfi), "#02");
 295                         Assert.AreEqual ("E0xF", 0.ToString ("E0xF", _nfi), "#03");
 296                 }
 297
 298                 [Test]
 299                 public void Test01007 ()
 300                 {
 301                         Assert.AreEqual ("EF", Int32.MaxValue.ToString ("EF", _nfi), "#01");
 302                         Assert.AreEqual ("E0F", Int32.MaxValue.ToString ("E0F", _nfi), "#02");
 303                         Assert.AreEqual ("E0xF", Int32.MaxValue.ToString ("E0xF", _nfi), "#03");
 304                 }
 305
 306                 [Test]
 307                 public void Test01008 ()
 308                 {
 309                         Assert.AreEqual ("-EF", Int32.MinValue.ToString ("EF", _nfi), "#01");
 310                         Assert.AreEqual ("E0F", Int32.MinValue.ToString ("E0F", _nfi), "#02");
 311                         Assert.AreEqual ("E0xF", Int32.MinValue.ToString ("E0xF", _nfi), "#03");
 312                 }
 313
 314                 [Test]
 315                 public void Test01009 ()
 316                 {
 317                         Assert.AreEqual ("0.0000000000E+000", 0.ToString ("E0000000000000000000000000000000000000010", _nfi), "#01");
 318                         Assert.AreEqual ("2.1474836470E+009", Int32.MaxValue.ToString ("E0000000000000000000000000000000000000010", _nfi), "#02");
 319                         Assert.AreEqual ("-2.1474836480E+009", Int32.MinValue.ToString ("E0000000000000000000000000000000000000010", _nfi), "#03");
 320                 }
 321
 322                 [Test]
 323                 public void Test01010 ()
 324                 {
 325                         Assert.AreEqual ("+E", 0.ToString ("+E", _nfi), "#01");
 326                         Assert.AreEqual ("E+", 0.ToString ("E+", _nfi), "#02");
 327                         Assert.AreEqual ("+E+", 0.ToString ("+E+", _nfi), "#03");
 328                 }
 329
 330                 [Test]
 331                 public void Test01011 ()
 332                 {
 333                         Assert.AreEqual ("+E", Int32.MaxValue.ToString ("+E", _nfi), "#01");
 334                         Assert.AreEqual ("E+", Int32.MaxValue.ToString ("E+", _nfi), "#02");
 335                         Assert.AreEqual ("+E+", Int32.MaxValue.ToString ("+E+", _nfi), "#03");
 336                 }
 337
 338                 [Test]
 339                 public void Test01012 ()
 340                 {
 341                         Assert.AreEqual ("-+E", Int32.MinValue.ToString ("+E", _nfi), "#01");
 342                         Assert.AreEqual ("-E+", Int32.MinValue.ToString ("E+", _nfi), "#02");
 343                         Assert.AreEqual ("-+E+", Int32.MinValue.ToString ("+E+", _nfi), "#03");
 344                 }
 345
 346                 [Test]
 347                 public void Test01013 ()
 348                 {
 349                         Assert.AreEqual ("-E", 0.ToString ("-E", _nfi), "#01");
 350                         Assert.AreEqual ("E-", 0.ToString ("E-", _nfi), "#02");
 351                         Assert.AreEqual ("-E-", 0.ToString ("-E-", _nfi), "#03");
 352                 }
 353
 354                 [Test]
 355                 public void Test01014 ()
 356                 {
 357                         Assert.AreEqual ("-E", Int32.MaxValue.ToString ("-E", _nfi), "#01");
 358                         Assert.AreEqual ("E-", Int32.MaxValue.ToString ("E-", _nfi), "#02");
 359                         Assert.AreEqual ("-E-", Int32.MaxValue.ToString ("-E-", _nfi), "#03");
 360                 }
 361
 362                 [Test]
 363                 public void Test01015 ()
 364                 {
 365                         Assert.AreEqual ("--E", Int32.MinValue.ToString ("-E", _nfi), "#01");
 366                         Assert.AreEqual ("-E-", Int32.MinValue.ToString ("E-", _nfi), "#02");
 367                         Assert.AreEqual ("--E-", Int32.MinValue.ToString ("-E-", _nfi), "#03");
 368                 }
 369
 370                 [Test]
 371                 public void Test01016 ()
 372                 {
 373                         Assert.AreEqual ("E+0", 0.ToString ("E+0", _nfi), "#01");
 374                         Assert.AreEqual ("E+0", Int32.MaxValue.ToString ("E+0", _nfi), "#02");
 375                         Assert.AreEqual ("E+0", Int32.MinValue.ToString ("E+0", _nfi), "#03");
 376                 }
 377
 378                 [Test]
 379                 public void Test01017 ()
 380                 {
 381                         Assert.AreEqual ("E+9", 0.ToString ("E+9", _nfi), "#01");
 382                         Assert.AreEqual ("E+9", Int32.MaxValue.ToString ("E+9", _nfi), "#02");
 383                         Assert.AreEqual ("-E+9", Int32.MinValue.ToString ("E+9", _nfi), "#03");
 384                 }
 385
 386                 [Test]
 387                 public void Test01018 ()
 388                 {
 389                         Assert.AreEqual ("E-9", 0.ToString ("E-9", _nfi), "#01");
 390                         Assert.AreEqual ("E-9", Int32.MaxValue.ToString ("E-9", _nfi), "#02");
 391                         Assert.AreEqual ("-E-9", Int32.MinValue.ToString ("E-9", _nfi), "#03");
 392                 }
 393
 394                 [Test]
 395                 public void Test01019 ()
 396                 {
 397                         Assert.AreEqual ("E0", 0.ToString ("E0,", _nfi), "#01");
 398                         Assert.AreEqual ("E0", Int32.MaxValue.ToString ("E0,", _nfi), "#02");
 399                         Assert.AreEqual ("E0", Int32.MinValue.ToString ("E0,", _nfi), "#03");
 400                 }
 401
 402                 [Test]
 403                 public void Test01020 ()
 404                 {
 405                         Assert.AreEqual ("E0", 0.ToString ("E0.", _nfi), "#01");
 406                         Assert.AreEqual ("E0", Int32.MaxValue.ToString ("E0.", _nfi), "#02");
 407                         Assert.AreEqual ("E0", Int32.MinValue.ToString ("E0.", _nfi), "#03");
 408                 }
 409
 410                 [Test]
 411                 public void Test01021 ()
 412                 {
 413                         Assert.AreEqual ("E0.0", 0.ToString ("E0.0", _nfi), "#01");
 414                         Assert.AreEqual ("E10.2", Int32.MaxValue.ToString ("E0.0", _nfi), "#02");
 415                         Assert.AreEqual ("-E10.2", Int32.MinValue.ToString ("E0.0", _nfi), "#03");
 416                 }
 417
 418                 [Test]
 419                 public void Test01022 ()
 420                 {
 421                         Assert.AreEqual ("E09", 0.ToString ("E0.9", _nfi), "#01");
 422                         Assert.AreEqual ("E09", Int32.MaxValue.ToString ("E0.9", _nfi), "#02");
 423                         Assert.AreEqual ("E09", Int32.MinValue.ToString ("E0.9", _nfi), "#03");
 424                 }
 425
 426                 [Test]
 427                 public void Test01023 ()
 428                 {
 429                         Assert.AreEqual ("9.999999E+007", 99999990.ToString ("E", _nfi), "#01");
 430                         Assert.AreEqual ("9.999999E+007", 99999991.ToString ("E", _nfi), "#02");
 431                         Assert.AreEqual ("9.999999E+007", 99999992.ToString ("E", _nfi), "#03");
 432                         Assert.AreEqual ("9.999999E+007", 99999993.ToString ("E", _nfi), "#04");
 433                         Assert.AreEqual ("9.999999E+007", 99999994.ToString ("E", _nfi), "#05");
 434                         Assert.AreEqual ("1.000000E+008", 99999995.ToString ("E", _nfi), "#06");
 435                         Assert.AreEqual ("1.000000E+008", 99999996.ToString ("E", _nfi), "#07");
 436                         Assert.AreEqual ("1.000000E+008", 99999997.ToString ("E", _nfi), "#08");
 437                         Assert.AreEqual ("1.000000E+008", 99999998.ToString ("E", _nfi), "#09");
 438                         Assert.AreEqual ("1.000000E+008", 99999999.ToString ("E", _nfi), "#10");
 439                 }
 440
 441                 [Test]
 442                 public void Test01024 ()
 443                 {
 444                         Assert.AreEqual ("-9.999999E+007", (-99999990).ToString ("E", _nfi), "#01");
 445                         Assert.AreEqual ("-9.999999E+007", (-99999991).ToString ("E", _nfi), "#02");
 446                         Assert.AreEqual ("-9.999999E+007", (-99999992).ToString ("E", _nfi), "#03");
 447                         Assert.AreEqual ("-9.999999E+007", (-99999993).ToString ("E", _nfi), "#04");
 448                         Assert.AreEqual ("-9.999999E+007", (-99999994).ToString ("E", _nfi), "#05");
 449                         Assert.AreEqual ("-1.000000E+008", (-99999995).ToString ("E", _nfi), "#06");
 450                         Assert.AreEqual ("-1.000000E+008", (-99999996).ToString ("E", _nfi), "#07");
 451                         Assert.AreEqual ("-1.000000E+008", (-99999997).ToString ("E", _nfi), "#08");
 452                         Assert.AreEqual ("-1.000000E+008", (-99999998).ToString ("E", _nfi), "#09");
 453                         Assert.AreEqual ("-1.000000E+008", (-99999999).ToString ("E", _nfi), "#10");
 454                 }
 455
 456                 [Test]
 457                 public void Test01025 ()
 458                 {
 459                         Assert.AreEqual ("9.999998E+007", 99999980.ToString ("E", _nfi), "#01");
 460                         Assert.AreEqual ("9.999998E+007", 99999981.ToString ("E", _nfi), "#02");
 461                         Assert.AreEqual ("9.999998E+007", 99999982.ToString ("E", _nfi), "#03");
 462                         Assert.AreEqual ("9.999998E+007", 99999983.ToString ("E", _nfi), "#04");
 463                         Assert.AreEqual ("9.999998E+007", 99999984.ToString ("E", _nfi), "#05");
 464                         Assert.AreEqual ("9.999999E+007", 99999985.ToString ("E", _nfi), "#06");
 465                         Assert.AreEqual ("9.999999E+007", 99999986.ToString ("E", _nfi), "#07");
 466                         Assert.AreEqual ("9.999999E+007", 99999987.ToString ("E", _nfi), "#08");
 467                         Assert.AreEqual ("9.999999E+007", 99999988.ToString ("E", _nfi), "#09");
 468                         Assert.AreEqual ("9.999999E+007", 99999989.ToString ("E", _nfi), "#10");
 469                 }
 470
 471                 [Test]
 472                 public void Test01026 ()
 473                 {
 474                         Assert.AreEqual ("-9.999998E+007", (-99999980).ToString ("E", _nfi), "#01");
 475                         Assert.AreEqual ("-9.999998E+007", (-99999981).ToString ("E", _nfi), "#02");
 476                         Assert.AreEqual ("-9.999998E+007", (-99999982).ToString ("E", _nfi), "#03");
 477                         Assert.AreEqual ("-9.999998E+007", (-99999983).ToString ("E", _nfi), "#04");
 478                         Assert.AreEqual ("-9.999998E+007", (-99999984).ToString ("E", _nfi), "#05");
 479                         Assert.AreEqual ("-9.999999E+007", (-99999985).ToString ("E", _nfi), "#06");
 480                         Assert.AreEqual ("-9.999999E+007", (-99999986).ToString ("E", _nfi), "#07");
 481                         Assert.AreEqual ("-9.999999E+007", (-99999987).ToString ("E", _nfi), "#08");
 482                         Assert.AreEqual ("-9.999999E+007", (-99999988).ToString ("E", _nfi), "#09");
 483                         Assert.AreEqual ("-9.999999E+007", (-99999989).ToString ("E", _nfi), "#10");
 484                 }
 485
 486                 [Test]
 487                 public void Test01027 ()
 488                 {
 489                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 490                         nfi.NumberDecimalSeparator = "#";
 491                         Assert.AreEqual ("-1#000000E+008", (-99999999).ToString ("E", nfi), "#01");
 492                 }
 493
 494                 [Test]
 495                 public void Test01028 ()
 496                 {
 497                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 498                         nfi.NegativeSign = "+";
 499                         nfi.PositiveSign = "-";
 500
 501                         Assert.AreEqual ("1.000000E-000", 1.ToString ("E", nfi), "#01");
 502                         Assert.AreEqual ("0.000000E-000", 0.ToString ("E", nfi), "#02");
 503                         Assert.AreEqual ("+1.000000E-000", (-1).ToString ("E", nfi), "#03");
 504                 }
 505
 506                 // Test02000- Int32 and F
 507                 [Test]
 508                 public void Test02000 ()
 509                 {
 510                         Assert.AreEqual ("0.00", 0.ToString ("F", _nfi), "#01");
 511                         Assert.AreEqual ("0.00", 0.ToString ("f", _nfi), "#02");
 512                         Assert.AreEqual ("-2147483648.00", Int32.MinValue.ToString ("F", _nfi), "#03");
 513                         Assert.AreEqual ("-2147483648.00", Int32.MinValue.ToString ("f", _nfi), "#04");
 514                         Assert.AreEqual ("2147483647.00", Int32.MaxValue.ToString ("F", _nfi), "#05");
 515                         Assert.AreEqual ("2147483647.00", Int32.MaxValue.ToString ("f", _nfi), "#06");
 516                 }
 517
 518                 [Test]
 519                 public void Test02001 ()
 520                 {
 521                         Assert.AreEqual ("F ", 0.ToString ("F ", _nfi), "#01");
 522                         Assert.AreEqual (" F", 0.ToString (" F", _nfi), "#02");
 523                         Assert.AreEqual (" F ", 0.ToString (" F ", _nfi), "#03");
 524                 }
 525
 526                 [Test]
 527                 public void Test02002 ()
 528                 {
 529                         Assert.AreEqual ("-F ", (-1).ToString ("F ", _nfi), "#01");
 530                         Assert.AreEqual ("- F", (-1).ToString (" F", _nfi), "#02");
 531                         Assert.AreEqual ("- F ", (-1).ToString (" F ", _nfi), "#03");
 532                 }
 533
 534                 [Test]
 535                 public void Test02003 ()
 536                 {
 537                         Assert.AreEqual ("0", 0.ToString ("F0", _nfi), "#01");
 538                         Assert.AreEqual ("0.000000000", 0.ToString ("F9", _nfi), "#02");
 539                         Assert.AreEqual ("0.0000000000", 0.ToString ("F10", _nfi), "#03");
 540                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F99", _nfi), "#04");
 541                         Assert.AreEqual ("F100", 0.ToString ("F100", _nfi), "#05");
 542                 }
 543
 544                 [Test]
 545                 public void Test02004 ()
 546                 {
 547                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("F0", _nfi), "#01");
 548                         Assert.AreEqual ("2147483647.000000000", Int32.MaxValue.ToString ("F9", _nfi), "#02");
 549                         Assert.AreEqual ("2147483647.0000000000", Int32.MaxValue.ToString ("F10", _nfi), "#03");
 550                         Assert.AreEqual ("2147483647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("F99", _nfi), "#04");
 551                         Assert.AreEqual ("F12147483647", Int32.MaxValue.ToString ("F100", _nfi), "#05");
 552                 }
 553
 554                 [Test]
 555                 public void Test02005 ()
 556                 {
 557                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("F0", _nfi), "#01");
 558                         Assert.AreEqual ("-2147483648.000000000", Int32.MinValue.ToString ("F9", _nfi), "#02");
 559                         Assert.AreEqual ("-2147483648.0000000000", Int32.MinValue.ToString ("F10", _nfi), "#03");
 560                         Assert.AreEqual ("-2147483648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("F99", _nfi), "#04");
 561                         Assert.AreEqual ("-F12147483648", Int32.MinValue.ToString ("F100", _nfi), "#05");
 562                 }
 563
 564                 [Test]
 565                 public void Test02006 ()
 566                 {
 567                         Assert.AreEqual ("FF", 0.ToString ("FF", _nfi), "#01");
 568                         Assert.AreEqual ("F0F", 0.ToString ("F0F", _nfi), "#02");
 569                         Assert.AreEqual ("F0xF", 0.ToString ("F0xF", _nfi), "#03");
 570                 }
 571
 572                 [Test]
 573                 public void Test02007 ()
 574                 {
 575                         Assert.AreEqual ("FF", Int32.MaxValue.ToString ("FF", _nfi), "#01");
 576                         Assert.AreEqual ("F2147483647F", Int32.MaxValue.ToString ("F0F", _nfi), "#02");
 577                         Assert.AreEqual ("F2147483647xF", Int32.MaxValue.ToString ("F0xF", _nfi), "#03");
 578                 }
 579
 580                 [Test]
 581                 public void Test02008 ()
 582                 {
 583                         Assert.AreEqual ("-FF", Int32.MinValue.ToString ("FF", _nfi), "#01");
 584                         Assert.AreEqual ("-F2147483648F", Int32.MinValue.ToString ("F0F", _nfi), "#02");
 585                         Assert.AreEqual ("-F2147483648xF", Int32.MinValue.ToString ("F0xF", _nfi), "#03");
 586                 }
 587
 588                 [Test]
 589                 public void Test02009 ()
 590                 {
 591                         Assert.AreEqual ("0.0000000000", 0.ToString ("F0000000000000000000000000000000000000010", _nfi), "#01");
 592                         Assert.AreEqual ("2147483647.0000000000", Int32.MaxValue.ToString ("F0000000000000000000000000000000000000010", _nfi), "#02");
 593                         Assert.AreEqual ("-2147483648.0000000000", Int32.MinValue.ToString ("F0000000000000000000000000000000000000010", _nfi), "#03");
 594                 }
 595
 596                 [Test]
 597                 public void Test02010 ()
 598                 {
 599                         Assert.AreEqual ("+F", 0.ToString ("+F", _nfi), "#01");
 600                         Assert.AreEqual ("F+", 0.ToString ("F+", _nfi), "#02");
 601                         Assert.AreEqual ("+F+", 0.ToString ("+F+", _nfi), "#03");
 602                 }
 603
 604                 [Test]
 605                 public void Test02011 ()
 606                 {
 607                         Assert.AreEqual ("+F", Int32.MaxValue.ToString ("+F", _nfi), "#01");
 608                         Assert.AreEqual ("F+", Int32.MaxValue.ToString ("F+", _nfi), "#02");
 609                         Assert.AreEqual ("+F+", Int32.MaxValue.ToString ("+F+", _nfi), "#03");
 610                 }
 611
 612                 [Test]
 613                 public void Test02012 ()
 614                 {
 615                         Assert.AreEqual ("-+F", Int32.MinValue.ToString ("+F", _nfi), "#01");
 616                         Assert.AreEqual ("-F+", Int32.MinValue.ToString ("F+", _nfi), "#02");
 617                         Assert.AreEqual ("-+F+", Int32.MinValue.ToString ("+F+", _nfi), "#03");
 618                 }
 619
 620                 [Test]
 621                 public void Test02013 ()
 622                 {
 623                         Assert.AreEqual ("-F", 0.ToString ("-F", _nfi), "#01");
 624                         Assert.AreEqual ("F-", 0.ToString ("F-", _nfi), "#02");
 625                         Assert.AreEqual ("-F-", 0.ToString ("-F-", _nfi), "#03");
 626                 }
 627
 628                 [Test]
 629                 public void Test02014 ()
 630                 {
 631                         Assert.AreEqual ("-F", Int32.MaxValue.ToString ("-F", _nfi), "#01");
 632                         Assert.AreEqual ("F-", Int32.MaxValue.ToString ("F-", _nfi), "#02");
 633                         Assert.AreEqual ("-F-", Int32.MaxValue.ToString ("-F-", _nfi), "#03");
 634                 }
 635
 636                 [Test]
 637                 public void Test02015 ()
 638                 {
 639                         Assert.AreEqual ("--F", Int32.MinValue.ToString ("-F", _nfi), "#01");
 640                         Assert.AreEqual ("-F-", Int32.MinValue.ToString ("F-", _nfi), "#02");
 641                         Assert.AreEqual ("--F-", Int32.MinValue.ToString ("-F-", _nfi), "#03");
 642                 }
 643
 644                 [Test]
 645                 public void Test02016 ()
 646                 {
 647                         Assert.AreEqual ("F+0", 0.ToString ("F+0", _nfi), "#01");
 648                         Assert.AreEqual ("F+2147483647", Int32.MaxValue.ToString ("F+0", _nfi), "#02");
 649                         Assert.AreEqual ("-F+2147483648", Int32.MinValue.ToString ("F+0", _nfi), "#03");
 650                 }
 651
 652                 [Test]
 653                 public void Test02017 ()
 654                 {
 655                         Assert.AreEqual ("F+9", 0.ToString ("F+9", _nfi), "#01");
 656                         Assert.AreEqual ("F+9", Int32.MaxValue.ToString ("F+9", _nfi), "#02");
 657                         Assert.AreEqual ("-F+9", Int32.MinValue.ToString ("F+9", _nfi), "#03");
 658                 }
 659
 660                 [Test]
 661                 public void Test02018 ()
 662                 {
 663                         Assert.AreEqual ("F-9", 0.ToString ("F-9", _nfi), "#01");
 664                         Assert.AreEqual ("F-9", Int32.MaxValue.ToString ("F-9", _nfi), "#02");
 665                         Assert.AreEqual ("-F-9", Int32.MinValue.ToString ("F-9", _nfi), "#03");
 666                 }
 667
 668                 [Test]
 669                 public void Test02019 ()
 670                 {
 671                         Assert.AreEqual ("F0", 0.ToString ("F0,", _nfi), "#01");
 672                         Assert.AreEqual ("F2147484", Int32.MaxValue.ToString ("F0,", _nfi), "#02");
 673                         Assert.AreEqual ("-F2147484", Int32.MinValue.ToString ("F0,", _nfi), "#03");
 674                 }
 675
 676                 [Test]
 677                 public void Test02020 ()
 678                 {
 679                         Assert.AreEqual ("F0", 0.ToString ("F0.", _nfi), "#01");
 680                         Assert.AreEqual ("F2147483647", Int32.MaxValue.ToString ("F0.", _nfi), "#02");
 681                         Assert.AreEqual ("-F2147483648", Int32.MinValue.ToString ("F0.", _nfi), "#03");
 682                 }
 683
 684                 [Test]
 685                 public void Test02021 ()
 686                 {
 687                         Assert.AreEqual ("F0.0", 0.ToString ("F0.0", _nfi), "#01");
 688                         Assert.AreEqual ("F2147483647.0", Int32.MaxValue.ToString ("F0.0", _nfi), "#02");
 689                         Assert.AreEqual ("-F2147483648.0", Int32.MinValue.ToString ("F0.0", _nfi), "#03");
 690                 }
 691
 692                 [Test]
 693                 public void Test02022 ()
 694                 {
 695                         Assert.AreEqual ("F09", 0.ToString ("F0.9", _nfi), "#01");
 696                         Assert.AreEqual ("F21474836479", Int32.MaxValue.ToString ("F0.9", _nfi), "#02");
 697                         Assert.AreEqual ("-F21474836489", Int32.MinValue.ToString ("F0.9", _nfi), "#03");
 698                 }
 699
 700                 [Test]
 701                 public void Test02023 ()
 702                 {
 703                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 704                         nfi.NumberDecimalDigits = 0;
 705                         Assert.AreEqual ("0", 0.ToString ("F", nfi), "#01");
 706                         nfi.NumberDecimalDigits = 1;
 707                         Assert.AreEqual ("0.0", 0.ToString ("F", nfi), "#02");
 708                         nfi.NumberDecimalDigits = 99;
 709                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F", nfi), "#03");
 710                 }
 711
 712                 [Test]
 713                 public void Test02024 ()
 714                 {
 715                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 716                         nfi.NegativeSign = "";
 717                         Assert.AreEqual ("2147483648.00", Int32.MinValue.ToString ("F", nfi), "#01");
 718                         nfi.NegativeSign = "-";
 719                         Assert.AreEqual ("-2147483648.00", Int32.MinValue.ToString ("F", nfi), "#02");
 720                         nfi.NegativeSign = "+";
 721                         Assert.AreEqual ("+2147483648.00", Int32.MinValue.ToString ("F", nfi), "#03");
 722                         nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 723                         Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648.00", Int32.MinValue.ToString ("F", nfi), "#04");
 724                 }
 725
 726                 [Test]
 727                 public void Test02025 ()
 728                 {
 729                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 730                         nfi.NegativeSign = "-";
 731                         nfi.PositiveSign = "+";
 732                         Assert.AreEqual ("-1.00", (-1).ToString ("F", nfi), "#01");
 733                         Assert.AreEqual ("0.00", 0.ToString ("F", nfi), "#02");
 734                         Assert.AreEqual ("1.00",1.ToString ("F", nfi), "#03");
 735                 }
 736
 737                 [Test]
 738                 public void Test02026 ()
 739                 {
 740                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 741                         nfi.NegativeSign = "+";
 742                         nfi.PositiveSign = "-";
 743                         Assert.AreEqual ("+1.00", (-1).ToString ("F", nfi), "#01");
 744                         Assert.AreEqual ("0.00", 0.ToString ("F", nfi), "#02");
 745                         Assert.AreEqual ("1.00",1.ToString ("F", nfi), "#03");
 746                 }
 747
 748                 [Test]
 749                 public void Test02027 ()
 750                 {
 751                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 752                         nfi.NumberDecimalSeparator = "#";
 753                         Assert.AreEqual ("1#00",1.ToString ("F", nfi), "#01");
 754                 }
 755
 756                 // Test03000 - Int32 and G
 757                 [Test]
 758                 public void Test03000 ()
 759                 {
 760                         Assert.AreEqual ("0", 0.ToString ("G", _nfi), "#01");
 761                         Assert.AreEqual ("0", 0.ToString ("g", _nfi), "#02");
 762                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G", _nfi), "#03");
 763                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("g", _nfi), "#04");
 764                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G", _nfi), "#05");
 765                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("g", _nfi), "#06");
 766                 }
 767
 768                 [Test]
 769                 public void Test03001 ()
 770                 {
 771                         Assert.AreEqual ("G ", 0.ToString ("G ", _nfi), "#01");
 772                         Assert.AreEqual (" G", 0.ToString (" G", _nfi), "#02");
 773                         Assert.AreEqual (" G ", 0.ToString (" G ", _nfi), "#03");
 774                 }
 775
 776                 [Test]
 777                 public void Test03002 ()
 778                 {
 779                         Assert.AreEqual ("-G ", (-1).ToString ("G ", _nfi), "#01");
 780                         Assert.AreEqual ("- G", (-1).ToString (" G", _nfi), "#02");
 781                         Assert.AreEqual ("- G ", (-1).ToString (" G ", _nfi), "#03");
 782                 }
 783
 784                 [Test]
 785                 public void Test03003 ()
 786                 {
 787                         Assert.AreEqual ("0", 0.ToString ("G0", _nfi), "#01");
 788                         Assert.AreEqual ("0", 0.ToString ("G9", _nfi), "#02");
 789                         Assert.AreEqual ("0", 0.ToString ("G10", _nfi), "#03");
 790                         Assert.AreEqual ("0", 0.ToString ("G99", _nfi), "#04");
 791                         Assert.AreEqual ("G100", 0.ToString ("G100", _nfi), "#05");
 792                 }
 793
 794                 [Test]
 795                 public void Test03004 ()
 796                 {
 797                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G0", _nfi), "#01");
 798                         Assert.AreEqual ("2.14748365E+09", Int32.MaxValue.ToString ("G9", _nfi), "#02");
 799                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G10", _nfi), "#03");
 800                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G99", _nfi), "#04");
 801                         Assert.AreEqual ("G12147483647", Int32.MaxValue.ToString ("G100", _nfi), "#05");
 802                 }
 803
 804                 [Test]
 805                 public void Test03005 ()
 806                 {
 807                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G0", _nfi), "#01");
 808                         Assert.AreEqual ("-2.14748365E+09", Int32.MinValue.ToString ("G9", _nfi), "#02");
 809                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G10", _nfi), "#03");
 810                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G99", _nfi), "#04");
 811                         Assert.AreEqual ("-G12147483648", Int32.MinValue.ToString ("G100", _nfi), "#05");
 812                 }
 813
 814                 [Test]
 815                 public void Test03006 ()
 816                 {
 817                         Assert.AreEqual ("GF", 0.ToString ("GF", _nfi), "#01");
 818                         Assert.AreEqual ("G0F", 0.ToString ("G0F", _nfi), "#02");
 819                         Assert.AreEqual ("G0xF", 0.ToString ("G0xF", _nfi), "#03");
 820                 }
 821
 822                 [Test]
 823                 public void Test03007 ()
 824                 {
 825                         Assert.AreEqual ("GF", Int32.MaxValue.ToString ("GF", _nfi), "#01");
 826                         Assert.AreEqual ("G2147483647F", Int32.MaxValue.ToString ("G0F", _nfi), "#02");
 827                         Assert.AreEqual ("G2147483647xF", Int32.MaxValue.ToString ("G0xF", _nfi), "#03");
 828                 }
 829
 830                 [Test]
 831                 public void Test03008 ()
 832                 {
 833                         Assert.AreEqual ("-GF", Int32.MinValue.ToString ("GF", _nfi), "#01");
 834                         Assert.AreEqual ("-G2147483648F", Int32.MinValue.ToString ("G0F", _nfi), "#02");
 835                         Assert.AreEqual ("-G2147483648xF", Int32.MinValue.ToString ("G0xF", _nfi), "#03");
 836                 }
 837
 838                 [Test]
 839                 public void Test03009 ()
 840                 {
 841                         Assert.AreEqual ("0", 0.ToString ("G0000000000000000000000000000000000000010", _nfi), "#01");
 842                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("G0000000000000000000000000000000000000010", _nfi), "#02");
 843                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G0000000000000000000000000000000000000010", _nfi), "#03");
 844                 }
 845
 846                 [Test]
 847                 public void Test03010 ()
 848                 {
 849                         Assert.AreEqual ("+G", 0.ToString ("+G", _nfi), "#01");
 850                         Assert.AreEqual ("G+", 0.ToString ("G+", _nfi), "#02");
 851                         Assert.AreEqual ("+G+", 0.ToString ("+G+", _nfi), "#03");
 852                 }
 853
 854                 [Test]
 855                 public void Test03011 ()
 856                 {
 857                         Assert.AreEqual ("+G", Int32.MaxValue.ToString ("+G", _nfi), "#01");
 858                         Assert.AreEqual ("G+", Int32.MaxValue.ToString ("G+", _nfi), "#02");
 859                         Assert.AreEqual ("+G+", Int32.MaxValue.ToString ("+G+", _nfi), "#03");
 860                 }
 861
 862                 [Test]
 863                 public void Test03012 ()
 864                 {
 865                         Assert.AreEqual ("-+G", Int32.MinValue.ToString ("+G", _nfi), "#01");
 866                         Assert.AreEqual ("-G+", Int32.MinValue.ToString ("G+", _nfi), "#02");
 867                         Assert.AreEqual ("-+G+", Int32.MinValue.ToString ("+G+", _nfi), "#03");
 868                 }
 869
 870                 [Test]
 871                 public void Test03013 ()
 872                 {
 873                         Assert.AreEqual ("-G", 0.ToString ("-G", _nfi), "#01");
 874                         Assert.AreEqual ("G-", 0.ToString ("G-", _nfi), "#02");
 875                         Assert.AreEqual ("-G-", 0.ToString ("-G-", _nfi), "#03");
 876                 }
 877
 878                 [Test]
 879                 public void Test03014 ()
 880                 {
 881                         Assert.AreEqual ("-G", Int32.MaxValue.ToString ("-G", _nfi), "#01");
 882                         Assert.AreEqual ("G-", Int32.MaxValue.ToString ("G-", _nfi), "#02");
 883                         Assert.AreEqual ("-G-", Int32.MaxValue.ToString ("-G-", _nfi), "#03");
 884                 }
 885
 886                 [Test]
 887                 public void Test03015 ()
 888                 {
 889                         Assert.AreEqual ("--G", Int32.MinValue.ToString ("-G", _nfi), "#01");
 890                         Assert.AreEqual ("-G-", Int32.MinValue.ToString ("G-", _nfi), "#02");
 891                         Assert.AreEqual ("--G-", Int32.MinValue.ToString ("-G-", _nfi), "#03");
 892                 }
 893
 894                 [Test]
 895                 public void Test03016 ()
 896                 {
 897                         Assert.AreEqual ("G+0", 0.ToString ("G+0", _nfi), "#01");
 898                         Assert.AreEqual ("G+2147483647", Int32.MaxValue.ToString ("G+0", _nfi), "#02");
 899                         Assert.AreEqual ("-G+2147483648", Int32.MinValue.ToString ("G+0", _nfi), "#03");
 900                 }
 901
 902                 [Test]
 903                 public void Test03017 ()
 904                 {
 905                         Assert.AreEqual ("G+9", 0.ToString ("G+9", _nfi), "#01");
 906                         Assert.AreEqual ("G+9", Int32.MaxValue.ToString ("G+9", _nfi), "#02");
 907                         Assert.AreEqual ("-G+9", Int32.MinValue.ToString ("G+9", _nfi), "#03");
 908                 }
 909
 910                 [Test]
 911                 public void Test03018 ()
 912                 {
 913                         Assert.AreEqual ("G-9", 0.ToString ("G-9", _nfi), "#01");
 914                         Assert.AreEqual ("G-9", Int32.MaxValue.ToString ("G-9", _nfi), "#02");
 915                         Assert.AreEqual ("-G-9", Int32.MinValue.ToString ("G-9", _nfi), "#03");
 916                 }
 917
 918                 [Test]
 919                 public void Test03019 ()
 920                 {
 921                         Assert.AreEqual ("G0", 0.ToString ("G0,", _nfi), "#01");
 922                         Assert.AreEqual ("G2147484", Int32.MaxValue.ToString ("G0,", _nfi), "#02");
 923                         Assert.AreEqual ("-G2147484", Int32.MinValue.ToString ("G0,", _nfi), "#03");
 924                 }
 925
 926                 [Test]
 927                 public void Test03020 ()
 928                 {
 929                         Assert.AreEqual ("G0", 0.ToString ("G0.", _nfi), "#01");
 930                         Assert.AreEqual ("G2147483647", Int32.MaxValue.ToString ("G0.", _nfi), "#02");
 931                         Assert.AreEqual ("-G2147483648", Int32.MinValue.ToString ("G0.", _nfi), "#03");
 932                 }
 933
 934                 [Test]
 935                 public void Test03021 ()
 936                 {
 937                         Assert.AreEqual ("G0.0", 0.ToString ("G0.0", _nfi), "#01");
 938                         Assert.AreEqual ("G2147483647.0", Int32.MaxValue.ToString ("G0.0", _nfi), "#02");
 939                         Assert.AreEqual ("-G2147483648.0", Int32.MinValue.ToString ("G0.0", _nfi), "#03");
 940                 }
 941
 942                 [Test]
 943                 public void Test03022 ()
 944                 {
 945                         Assert.AreEqual ("G09", 0.ToString ("G0.9", _nfi), "#01");
 946                         Assert.AreEqual ("G21474836479", Int32.MaxValue.ToString ("G0.9", _nfi), "#02");
 947                         Assert.AreEqual ("-G21474836489", Int32.MinValue.ToString ("G0.9", _nfi), "#03");
 948                 }
 949
 950                 [Test]
 951                 public void Test03023 ()
 952                 {
 953                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 954                         nfi.NumberDecimalDigits = 0;
 955                         Assert.AreEqual ("0", 0.ToString ("G", nfi), "#01");
 956                         nfi.NumberDecimalDigits = 1;
 957                         Assert.AreEqual ("0", 0.ToString ("G", nfi), "#02");
 958                         nfi.NumberDecimalDigits = 99;
 959                         Assert.AreEqual ("0", 0.ToString ("G", nfi), "#03");
 960                 }
 961
 962                 [Test]
 963                 public void Test03024 ()
 964                 {
 965                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 966                         nfi.NegativeSign = "";
 967                         Assert.AreEqual ("2147483648", Int32.MinValue.ToString ("G", nfi), "#01");
 968                         nfi.NegativeSign = "-";
 969                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("G", nfi), "#02");
 970                         nfi.NegativeSign = "+";
 971                         Assert.AreEqual ("+2147483648", Int32.MinValue.ToString ("G", nfi), "#03");
 972                         nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 973                         Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648", Int32.MinValue.ToString ("G", nfi), "#04");
 974                 }
 975
 976                 [Test]
 977                 public void Test03025 ()
 978                 {
 979                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 980                         nfi.NegativeSign = "-";
 981                         nfi.PositiveSign = "+";
 982                         Assert.AreEqual ("-1", (-1).ToString ("G", nfi), "#01");
 983                         Assert.AreEqual ("0", 0.ToString ("G", nfi), "#02");
 984                         Assert.AreEqual ("1",1.ToString ("G", nfi), "#03");
 985                 }
 986
 987                 [Test]
 988                 public void Test03026 ()
 989                 {
 990                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
 991                         nfi.NegativeSign = "+";
 992                         nfi.PositiveSign = "-";
 993                         Assert.AreEqual ("+1", (-1).ToString ("G", nfi), "#01");
 994                         Assert.AreEqual ("0", 0.ToString ("G", nfi), "#02");
 995                         Assert.AreEqual ("1",1.ToString ("G", nfi), "#03");
 996                 }
 997
 998                 [Test]
 999                 public void Test03027 ()
1000                 {
1001                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1002                         nfi.NumberDecimalSeparator = "#";
1003                         Assert.AreEqual ("1#2E+02",123.ToString ("G2", nfi), "#01");
1004                 }
1005
1006                 // Test04000 - Int32 and N
1007                 [Test]
1008                 public void Test04000 ()
1009                 {
1010                         Assert.AreEqual ("0.00", 0.ToString ("N", _nfi), "#01");
1011                         Assert.AreEqual ("0.00", 0.ToString ("n", _nfi), "#02");
1012                         Assert.AreEqual ("-2,147,483,648.00", Int32.MinValue.ToString ("N", _nfi), "#03");
1013                         Assert.AreEqual ("-2,147,483,648.00", Int32.MinValue.ToString ("n", _nfi), "#04");
1014                         Assert.AreEqual ("2,147,483,647.00", Int32.MaxValue.ToString ("N", _nfi), "#05");
1015                         Assert.AreEqual ("2,147,483,647.00", Int32.MaxValue.ToString ("n", _nfi), "#06");
1016                 }
1017
1018                 [Test]
1019                 public void Test04001 ()
1020                 {
1021                         Assert.AreEqual ("N ", 0.ToString ("N ", _nfi), "#01");
1022                         Assert.AreEqual (" N", 0.ToString (" N", _nfi), "#02");
1023                         Assert.AreEqual (" N ", 0.ToString (" N ", _nfi), "#03");
1024                 }
1025
1026                 [Test]
1027                 public void Test04002 ()
1028                 {
1029                         Assert.AreEqual ("-N ", (-1).ToString ("N ", _nfi), "#01");
1030                         Assert.AreEqual ("- N", (-1).ToString (" N", _nfi), "#02");
1031                         Assert.AreEqual ("- N ", (-1).ToString (" N ", _nfi), "#03");
1032                 }
1033
1034                 [Test]
1035                 public void Test04003 ()
1036                 {
1037                         Assert.AreEqual ("0", 0.ToString ("N0", _nfi), "#01");
1038                         Assert.AreEqual ("0.000000000", 0.ToString ("N9", _nfi), "#02");
1039                         Assert.AreEqual ("0.0000000000", 0.ToString ("N10", _nfi), "#03");
1040                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N99", _nfi), "#04");
1041                         Assert.AreEqual ("N100", 0.ToString ("N100", _nfi), "#05");
1042                 }
1043
1044                 [Test]
1045                 public void Test04004 ()
1046                 {
1047                         Assert.AreEqual ("2,147,483,647", Int32.MaxValue.ToString ("N0", _nfi), "#01");
1048                         Assert.AreEqual ("2,147,483,647.000000000", Int32.MaxValue.ToString ("N9", _nfi), "#02");
1049                         Assert.AreEqual ("2,147,483,647.0000000000", Int32.MaxValue.ToString ("N10", _nfi), "#03");
1050                         Assert.AreEqual ("2,147,483,647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("N99", _nfi), "#04");
1051                         Assert.AreEqual ("N12147483647", Int32.MaxValue.ToString ("N100", _nfi), "#05");
1052                 }
1053
1054                 [Test]
1055                 public void Test04005 ()
1056                 {
1057                         Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("N0", _nfi), "#01");
1058                         Assert.AreEqual ("-2,147,483,648.000000000", Int32.MinValue.ToString ("N9", _nfi), "#02");
1059                         Assert.AreEqual ("-2,147,483,648.0000000000", Int32.MinValue.ToString ("N10", _nfi), "#03");
1060                         Assert.AreEqual ("-2,147,483,648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("N99", _nfi), "#04");
1061                         Assert.AreEqual ("-N12147483648", Int32.MinValue.ToString ("N100", _nfi), "#05");
1062                 }
1063
1064                 [Test]
1065                 public void Test04006 ()
1066                 {
1067                         Assert.AreEqual ("NF", 0.ToString ("NF", _nfi), "#01");
1068                         Assert.AreEqual ("N0F", 0.ToString ("N0F", _nfi), "#02");
1069                         Assert.AreEqual ("N0xF", 0.ToString ("N0xF", _nfi), "#03");
1070                 }
1071
1072                 [Test]
1073                 public void Test04007 ()
1074                 {
1075                         Assert.AreEqual ("NF", Int32.MaxValue.ToString ("NF", _nfi), "#01");
1076                         Assert.AreEqual ("N2147483647F", Int32.MaxValue.ToString ("N0F", _nfi), "#02");
1077                         Assert.AreEqual ("N2147483647xF", Int32.MaxValue.ToString ("N0xF", _nfi), "#03");
1078                 }
1079
1080                 [Test]
1081                 public void Test04008 ()
1082                 {
1083                         Assert.AreEqual ("-NF", Int32.MinValue.ToString ("NF", _nfi), "#01");
1084                         Assert.AreEqual ("-N2147483648F", Int32.MinValue.ToString ("N0F", _nfi), "#02");
1085                         Assert.AreEqual ("-N2147483648xF", Int32.MinValue.ToString ("N0xF", _nfi), "#03");
1086                 }
1087
1088                 [Test]
1089                 public void Test04009 ()
1090                 {
1091                         Assert.AreEqual ("0.0000000000", 0.ToString ("N0000000000000000000000000000000000000010", _nfi), "#01");
1092                         Assert.AreEqual ("2,147,483,647.0000000000", Int32.MaxValue.ToString ("N0000000000000000000000000000000000000010", _nfi), "#02");
1093                         Assert.AreEqual ("-2,147,483,648.0000000000", Int32.MinValue.ToString ("N0000000000000000000000000000000000000010", _nfi), "#03");
1094                 }
1095
1096                 [Test]
1097                 public void Test04010 ()
1098                 {
1099                         Assert.AreEqual ("+N", 0.ToString ("+N", _nfi), "#01");
1100                         Assert.AreEqual ("N+", 0.ToString ("N+", _nfi), "#02");
1101                         Assert.AreEqual ("+N+", 0.ToString ("+N+", _nfi), "#03");
1102                 }
1103
1104                 [Test]
1105                 public void Test04011 ()
1106                 {
1107                         Assert.AreEqual ("+N", Int32.MaxValue.ToString ("+N", _nfi), "#01");
1108                         Assert.AreEqual ("N+", Int32.MaxValue.ToString ("N+", _nfi), "#02");
1109                         Assert.AreEqual ("+N+", Int32.MaxValue.ToString ("+N+", _nfi), "#03");
1110                 }
1111
1112                 [Test]
1113                 public void Test04012 ()
1114                 {
1115                         Assert.AreEqual ("-+N", Int32.MinValue.ToString ("+N", _nfi), "#01");
1116                         Assert.AreEqual ("-N+", Int32.MinValue.ToString ("N+", _nfi), "#02");
1117                         Assert.AreEqual ("-+N+", Int32.MinValue.ToString ("+N+", _nfi), "#03");
1118                 }
1119
1120                 [Test]
1121                 public void Test04013 ()
1122                 {
1123                         Assert.AreEqual ("-N", 0.ToString ("-N", _nfi), "#01");
1124                         Assert.AreEqual ("N-", 0.ToString ("N-", _nfi), "#02");
1125                         Assert.AreEqual ("-N-", 0.ToString ("-N-", _nfi), "#03");
1126                 }
1127
1128                 [Test]
1129                 public void Test04014 ()
1130                 {
1131                         Assert.AreEqual ("-N", Int32.MaxValue.ToString ("-N", _nfi), "#01");
1132                         Assert.AreEqual ("N-", Int32.MaxValue.ToString ("N-", _nfi), "#02");
1133                         Assert.AreEqual ("-N-", Int32.MaxValue.ToString ("-N-", _nfi), "#03");
1134                 }
1135
1136                 [Test]
1137                 public void Test04015 ()
1138                 {
1139                         Assert.AreEqual ("--N", Int32.MinValue.ToString ("-N", _nfi), "#01");
1140                         Assert.AreEqual ("-N-", Int32.MinValue.ToString ("N-", _nfi), "#02");
1141                         Assert.AreEqual ("--N-", Int32.MinValue.ToString ("-N-", _nfi), "#03");
1142                 }
1143
1144                 [Test]
1145                 public void Test04016 ()
1146                 {
1147                         Assert.AreEqual ("N+0", 0.ToString ("N+0", _nfi), "#01");
1148                         Assert.AreEqual ("N+2147483647", Int32.MaxValue.ToString ("N+0", _nfi), "#02");
1149                         Assert.AreEqual ("-N+2147483648", Int32.MinValue.ToString ("N+0", _nfi), "#03");
1150                 }
1151
1152                 [Test]
1153                 public void Test04017 ()
1154                 {
1155                         Assert.AreEqual ("N+9", 0.ToString ("N+9", _nfi), "#01");
1156                         Assert.AreEqual ("N+9", Int32.MaxValue.ToString ("N+9", _nfi), "#02");
1157                         Assert.AreEqual ("-N+9", Int32.MinValue.ToString ("N+9", _nfi), "#03");
1158                 }
1159
1160                 [Test]
1161                 public void Test04018 ()
1162                 {
1163                         Assert.AreEqual ("N-9", 0.ToString ("N-9", _nfi), "#01");
1164                         Assert.AreEqual ("N-9", Int32.MaxValue.ToString ("N-9", _nfi), "#02");
1165                         Assert.AreEqual ("-N-9", Int32.MinValue.ToString ("N-9", _nfi), "#03");
1166                 }
1167
1168                 [Test]
1169                 public void Test04019 ()
1170                 {
1171                         Assert.AreEqual ("N0", 0.ToString ("N0,", _nfi), "#01");
1172                         Assert.AreEqual ("N2147484", Int32.MaxValue.ToString ("N0,", _nfi), "#02");
1173                         Assert.AreEqual ("-N2147484", Int32.MinValue.ToString ("N0,", _nfi), "#03");
1174                 }
1175
1176                 [Test]
1177                 public void Test04020 ()
1178                 {
1179                         Assert.AreEqual ("N0", 0.ToString ("N0.", _nfi), "#01");
1180                         Assert.AreEqual ("N2147483647", Int32.MaxValue.ToString ("N0.", _nfi), "#02");
1181                         Assert.AreEqual ("-N2147483648", Int32.MinValue.ToString ("N0.", _nfi), "#03");
1182                 }
1183
1184                 [Test]
1185                 public void Test04021 ()
1186                 {
1187                         Assert.AreEqual ("N0.0", 0.ToString ("N0.0", _nfi), "#01");
1188                         Assert.AreEqual ("N2147483647.0", Int32.MaxValue.ToString ("N0.0", _nfi), "#02");
1189                         Assert.AreEqual ("-N2147483648.0", Int32.MinValue.ToString ("N0.0", _nfi), "#03");
1190                 }
1191
1192                 [Test]
1193                 public void Test04022 ()
1194                 {
1195                         Assert.AreEqual ("N09", 0.ToString ("N0.9", _nfi), "#01");
1196                         Assert.AreEqual ("N21474836479", Int32.MaxValue.ToString ("N0.9", _nfi), "#02");
1197                         Assert.AreEqual ("-N21474836489", Int32.MinValue.ToString ("N0.9", _nfi), "#03");
1198                 }
1199
1200                 [Test]
1201                 public void Test04023 ()
1202                 {
1203                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1204                         nfi.NumberDecimalDigits = 0;
1205                         Assert.AreEqual ("0", 0.ToString ("N", nfi), "#01");
1206                         nfi.NumberDecimalDigits = 1;
1207                         Assert.AreEqual ("0.0", 0.ToString ("N", nfi), "#02");
1208                         nfi.NumberDecimalDigits = 99;
1209                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N", nfi), "#03");
1210                 }
1211
1212                 [Test]
1213                 public void Test04024 ()
1214                 {
1215                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1216                         nfi.NegativeSign = "";
1217                         Assert.AreEqual ("2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#01");
1218                         nfi.NegativeSign = "-";
1219                         Assert.AreEqual ("-2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#02");
1220                         nfi.NegativeSign = "+";
1221                         Assert.AreEqual ("+2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#03");
1222                         nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
1223                         Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#04");
1224                 }
1225
1226                 [Test]
1227                 public void Test04025 ()
1228                 {
1229                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1230                         nfi.NegativeSign = "-";
1231                         nfi.PositiveSign = "+";
1232                         Assert.AreEqual ("-1.00", (-1).ToString ("N", nfi), "#01");
1233                         Assert.AreEqual ("0.00", 0.ToString ("N", nfi), "#02");
1234                         Assert.AreEqual ("1.00",1.ToString ("N", nfi), "#03");
1235                 }
1236
1237                 [Test]
1238                 public void Test04026 ()
1239                 {
1240                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1241                         nfi.NegativeSign = "+";
1242                         nfi.PositiveSign = "-";
1243                         Assert.AreEqual ("+1.00", (-1).ToString ("N", nfi), "#01");
1244                         Assert.AreEqual ("0.00", 0.ToString ("N", nfi), "#02");
1245                         Assert.AreEqual ("1.00",1.ToString ("N", nfi), "#03");
1246                 }
1247
1248                 [Test]
1249                 public void Test04027 ()
1250                 {
1251                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1252                         nfi.NumberDecimalSeparator = "#";
1253                         Assert.AreEqual ("123#0",123.ToString ("N1", nfi), "#01");
1254                 }
1255
1256                 [Test]
1257                 public void Test04028 ()
1258                 {
1259                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1260                         nfi.NumberGroupSeparator = "-";
1261                         Assert.AreEqual ("-2-147-483-648.0",Int32.MinValue.ToString ("N1", nfi), "#01");
1262                 }
1263
1264                 [Test]
1265                 public void Test04029 ()
1266                 {
1267                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1268                         nfi.NumberGroupSizes = new int [] {};
1269                         Assert.AreEqual ("-2147483648.0",Int32.MinValue.ToString ("N1", nfi), "#01");
1270                         nfi.NumberGroupSizes = new int [] {0};
1271                         Assert.AreEqual ("-2147483648.0",Int32.MinValue.ToString ("N1", nfi), "#02");
1272                         nfi.NumberGroupSizes = new int [] {1};
1273                         Assert.AreEqual ("-2,1,4,7,4,8,3,6,4,8.0",Int32.MinValue.ToString ("N1", nfi), "#03");
1274                         nfi.NumberGroupSizes = new int [] {3};
1275                         Assert.AreEqual ("-2,147,483,648.0",Int32.MinValue.ToString ("N1", nfi), "#04");
1276                         nfi.NumberGroupSizes = new int [] {9};
1277                         Assert.AreEqual ("-2,147483648.0",Int32.MinValue.ToString ("N1", nfi), "#05");
1278                 }
1279
1280                 [Test]
1281                 public void Test04030 ()
1282                 {
1283                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1284                         nfi.NumberGroupSizes = new int [] {1,2};
1285                         Assert.AreEqual ("-2,14,74,83,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#01");
1286                         nfi.NumberGroupSizes = new int [] {1,2,3};
1287                         Assert.AreEqual ("-2,147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#02");
1288                         nfi.NumberGroupSizes = new int [] {1,2,3,4};
1289                         Assert.AreEqual ("-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#03");
1290                         nfi.NumberGroupSizes = new int [] {1,2,1,2,1,2,1};
1291                         Assert.AreEqual ("-2,14,7,48,3,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#04");
1292                         nfi.NumberGroupSizes = new int [] {1,0};
1293                         Assert.AreEqual ("-214748364,8.0",Int32.MinValue.ToString ("N1", nfi), "#05");
1294                         nfi.NumberGroupSizes = new int [] {1,2,0};
1295                         Assert.AreEqual ("-2147483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#06");
1296                         nfi.NumberGroupSizes = new int [] {1,2,3,0};
1297                         Assert.AreEqual ("-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#07");
1298                         nfi.NumberGroupSizes = new int [] {1,2,3,4,0};
1299                         Assert.AreEqual ("-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi), "#08");
1300                 }
1301
1302                 [Test]
1303                 public void Test04031 ()
1304                 {
1305                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1306                         nfi.NegativeSign = "1234567890";
1307                         Assert.AreEqual ("12345678902,147,483,648.00", Int32.MinValue.ToString ("N", nfi), "#01");
1308                 }
1309
1310                 // Test05000 - Int32 and P
1311                 [Test]
1312                 public void Test05000 ()
1313                 {
1314                         Assert.AreEqual ("0.00 %", 0.ToString ("P", _nfi), "#01");
1315                         Assert.AreEqual ("0.00 %", 0.ToString ("p", _nfi), "#02");
1316                         Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", _nfi), "#03");
1317                         Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("p", _nfi), "#04");
1318                         Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", _nfi), "#05");
1319                         Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("p", _nfi), "#06");
1320                 }
1321
1322                 [Test]
1323                 public void Test05001 ()
1324                 {
1325                         Assert.AreEqual ("P ", 0.ToString ("P ", _nfi), "#01");
1326                         Assert.AreEqual (" P", 0.ToString (" P", _nfi), "#02");
1327                         Assert.AreEqual (" P ", 0.ToString (" P ", _nfi), "#03");
1328                 }
1329
1330                 [Test]
1331                 public void Test05002 ()
1332                 {
1333                         Assert.AreEqual ("-P ", (-1).ToString ("P ", _nfi), "#01");
1334                         Assert.AreEqual ("- P", (-1).ToString (" P", _nfi), "#02");
1335                         Assert.AreEqual ("- P ", (-1).ToString (" P ", _nfi), "#03");
1336                 }
1337
1338                 [Test]
1339                 public void Test05003 ()
1340                 {
1341                         Assert.AreEqual ("0 %", 0.ToString ("P0", _nfi), "#01");
1342                         Assert.AreEqual ("0.000000000 %", 0.ToString ("P9", _nfi), "#02");
1343                         Assert.AreEqual ("0.0000000000 %", 0.ToString ("P10", _nfi), "#03");
1344                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P99", _nfi), "#04");
1345                         Assert.AreEqual ("P100", 0.ToString ("P100", _nfi), "#05");
1346                 }
1347
1348                 [Test]
1349                 public void Test05004 ()
1350                 {
1351                         Assert.AreEqual ("214,748,364,700 %", Int32.MaxValue.ToString ("P0", _nfi), "#01");
1352                         Assert.AreEqual ("214,748,364,700.000000000 %", Int32.MaxValue.ToString ("P9", _nfi), "#02");
1353                         Assert.AreEqual ("214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P10", _nfi), "#03");
1354                         Assert.AreEqual ("214,748,364,700.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MaxValue.ToString ("P99", _nfi), "#04");
1355                         Assert.AreEqual ("P12147483647", Int32.MaxValue.ToString ("P100", _nfi), "#05");
1356                 }
1357
1358                 [Test]
1359                 public void Test05005 ()
1360                 {
1361                         Assert.AreEqual ("-214,748,364,800 %", Int32.MinValue.ToString ("P0", _nfi), "#01");
1362                         Assert.AreEqual ("-214,748,364,800.000000000 %", Int32.MinValue.ToString ("P9", _nfi), "#02");
1363                         Assert.AreEqual ("-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P10", _nfi), "#03");
1364                         Assert.AreEqual ("-214,748,364,800.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MinValue.ToString ("P99", _nfi), "#04");
1365                         Assert.AreEqual ("-P12147483648", Int32.MinValue.ToString ("P100", _nfi), "#05");
1366                 }
1367
1368                 [Test]
1369                 public void Test05006 ()
1370                 {
1371                         Assert.AreEqual ("PF", 0.ToString ("PF", _nfi), "#01");
1372                         Assert.AreEqual ("P0F", 0.ToString ("P0F", _nfi), "#02");
1373                         Assert.AreEqual ("P0xF", 0.ToString ("P0xF", _nfi), "#03");
1374                 }
1375
1376                 [Test]
1377                 public void Test05007 ()
1378                 {
1379                         Assert.AreEqual ("PF", Int32.MaxValue.ToString ("PF", _nfi), "#01");
1380                         Assert.AreEqual ("P2147483647F", Int32.MaxValue.ToString ("P0F", _nfi), "#02");
1381                         Assert.AreEqual ("P2147483647xF", Int32.MaxValue.ToString ("P0xF", _nfi), "#03");
1382                 }
1383
1384                 [Test]
1385                 public void Test05008 ()
1386                 {
1387                         Assert.AreEqual ("-PF", Int32.MinValue.ToString ("PF", _nfi), "#01");
1388                         Assert.AreEqual ("-P2147483648F", Int32.MinValue.ToString ("P0F", _nfi), "#02");
1389                         Assert.AreEqual ("-P2147483648xF", Int32.MinValue.ToString ("P0xF", _nfi), "#03");
1390                 }
1391
1392                 [Test]
1393                 public void Test05009 ()
1394                 {
1395                         Assert.AreEqual ("0.0000000000 %", 0.ToString ("P0000000000000000000000000000000000000010", _nfi), "#01");
1396                         Assert.AreEqual ("214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P0000000000000000000000000000000000000010", _nfi), "#02");
1397                         Assert.AreEqual ("-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P0000000000000000000000000000000000000010", _nfi), "#03");
1398                 }
1399
1400                 [Test]
1401                 public void Test05010 ()
1402                 {
1403                         Assert.AreEqual ("+P", 0.ToString ("+P", _nfi), "#01");
1404                         Assert.AreEqual ("P+", 0.ToString ("P+", _nfi), "#02");
1405                         Assert.AreEqual ("+P+", 0.ToString ("+P+", _nfi), "#03");
1406                 }
1407
1408                 [Test]
1409                 public void Test05011 ()
1410                 {
1411                         Assert.AreEqual ("+P", Int32.MaxValue.ToString ("+P", _nfi), "#01");
1412                         Assert.AreEqual ("P+", Int32.MaxValue.ToString ("P+", _nfi), "#02");
1413                         Assert.AreEqual ("+P+", Int32.MaxValue.ToString ("+P+", _nfi), "#03");
1414                 }
1415
1416                 [Test]
1417                 public void Test05012 ()
1418                 {
1419                         Assert.AreEqual ("-+P", Int32.MinValue.ToString ("+P", _nfi), "#01");
1420                         Assert.AreEqual ("-P+", Int32.MinValue.ToString ("P+", _nfi), "#02");
1421                         Assert.AreEqual ("-+P+", Int32.MinValue.ToString ("+P+", _nfi), "#03");
1422                 }
1423
1424                 [Test]
1425                 public void Test05013 ()
1426                 {
1427                         Assert.AreEqual ("-P", 0.ToString ("-P", _nfi), "#01");
1428                         Assert.AreEqual ("P-", 0.ToString ("P-", _nfi), "#02");
1429                         Assert.AreEqual ("-P-", 0.ToString ("-P-", _nfi), "#03");
1430                 }
1431
1432                 [Test]
1433                 public void Test05014 ()
1434                 {
1435                         Assert.AreEqual ("-P", Int32.MaxValue.ToString ("-P", _nfi), "#01");
1436                         Assert.AreEqual ("P-", Int32.MaxValue.ToString ("P-", _nfi), "#02");
1437                         Assert.AreEqual ("-P-", Int32.MaxValue.ToString ("-P-", _nfi), "#03");
1438                 }
1439
1440                 [Test]
1441                 public void Test05015 ()
1442                 {
1443                         Assert.AreEqual ("--P", Int32.MinValue.ToString ("-P", _nfi), "#01");
1444                         Assert.AreEqual ("-P-", Int32.MinValue.ToString ("P-", _nfi), "#02");
1445                         Assert.AreEqual ("--P-", Int32.MinValue.ToString ("-P-", _nfi), "#03");
1446                 }
1447
1448                 [Test]
1449                 public void Test05016 ()
1450                 {
1451                         Assert.AreEqual ("P+0", 0.ToString ("P+0", _nfi), "#01");
1452                         Assert.AreEqual ("P+2147483647", Int32.MaxValue.ToString ("P+0", _nfi), "#02");
1453                         Assert.AreEqual ("-P+2147483648", Int32.MinValue.ToString ("P+0", _nfi), "#03");
1454                 }
1455
1456                 [Test]
1457                 public void Test05017 ()
1458                 {
1459                         Assert.AreEqual ("P+9", 0.ToString ("P+9", _nfi), "#01");
1460                         Assert.AreEqual ("P+9", Int32.MaxValue.ToString ("P+9", _nfi), "#02");
1461                         Assert.AreEqual ("-P+9", Int32.MinValue.ToString ("P+9", _nfi), "#03");
1462                 }
1463
1464                 [Test]
1465                 public void Test05018 ()
1466                 {
1467                         Assert.AreEqual ("P-9", 0.ToString ("P-9", _nfi), "#01");
1468                         Assert.AreEqual ("P-9", Int32.MaxValue.ToString ("P-9", _nfi), "#02");
1469                         Assert.AreEqual ("-P-9", Int32.MinValue.ToString ("P-9", _nfi), "#03");
1470                 }
1471
1472                 [Test]
1473                 public void Test05019 ()
1474                 {
1475                         Assert.AreEqual ("P0", 0.ToString ("P0,", _nfi), "#01");
1476                         Assert.AreEqual ("P2147484", Int32.MaxValue.ToString ("P0,", _nfi), "#02");
1477                         Assert.AreEqual ("-P2147484", Int32.MinValue.ToString ("P0,", _nfi), "#03");
1478                 }
1479
1480                 [Test]
1481                 public void Test05020 ()
1482                 {
1483                         Assert.AreEqual ("P0", 0.ToString ("P0.", _nfi), "#01");
1484                         Assert.AreEqual ("P2147483647", Int32.MaxValue.ToString ("P0.", _nfi), "#02");
1485                         Assert.AreEqual ("-P2147483648", Int32.MinValue.ToString ("P0.", _nfi), "#03");
1486                 }
1487
1488                 [Test]
1489                 public void Test05021 ()
1490                 {
1491                         Assert.AreEqual ("P0.0", 0.ToString ("P0.0", _nfi), "#01");
1492                         Assert.AreEqual ("P2147483647.0", Int32.MaxValue.ToString ("P0.0", _nfi), "#02");
1493                         Assert.AreEqual ("-P2147483648.0", Int32.MinValue.ToString ("P0.0", _nfi), "#03");
1494                 }
1495
1496                 [Test]
1497                 public void Test05022 ()
1498                 {
1499                         Assert.AreEqual ("P09", 0.ToString ("P0.9", _nfi), "#01");
1500                         Assert.AreEqual ("P21474836479", Int32.MaxValue.ToString ("P0.9", _nfi), "#02");
1501                         Assert.AreEqual ("-P21474836489", Int32.MinValue.ToString ("P0.9", _nfi), "#03");
1502                 }
1503
1504                 [Test]
1505                 public void Test05023 ()
1506                 {
1507                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1508                         nfi.PercentDecimalDigits = 0;
1509                         Assert.AreEqual ("0 %", 0.ToString ("P", nfi), "#01");
1510                         nfi.PercentDecimalDigits = 1;
1511                         Assert.AreEqual ("0.0 %", 0.ToString ("P", nfi), "#02");
1512                         nfi.PercentDecimalDigits = 99;
1513                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P", nfi), "#03");
1514                 }
1515
1516                 [Test]
1517                 public void Test05024 ()
1518                 {
1519                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1520                         nfi.NegativeSign = "";
1521                         Assert.AreEqual ("214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
1522                         nfi.NegativeSign = "-";
1523                         Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#02");
1524                         nfi.NegativeSign = "+";
1525                         Assert.AreEqual ("+214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#03");
1526                         nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ";
1527                         Assert.AreEqual ("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#04");
1528                 }
1529
1530                 [Test]
1531                 public void Test05025 ()
1532                 {
1533                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1534                         nfi.NegativeSign = "-";
1535                         nfi.PositiveSign = "+";
1536                         Assert.AreEqual ("-100.00 %", (-1).ToString ("P", nfi), "#01");
1537                         Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#02");
1538                         Assert.AreEqual ("100.00 %",1.ToString ("P", nfi), "#03");
1539                 }
1540
1541                 [Test]
1542                 public void Test05026 ()
1543                 {
1544                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1545                         nfi.NegativeSign = "+";
1546                         nfi.PositiveSign = "-";
1547                         Assert.AreEqual ("+100.00 %", (-1).ToString ("P", nfi), "#01");
1548                         Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#02");
1549                         Assert.AreEqual ("100.00 %",1.ToString ("P", nfi), "#03");
1550                 }
1551
1552                 [Test]
1553                 public void Test05027 ()
1554                 {
1555                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1556                         nfi.PercentDecimalSeparator = "#";
1557                         Assert.AreEqual ("12,300#0 %",123.ToString ("P1", nfi), "#01");
1558                 }
1559
1560                 [Test]
1561                 public void Test05028 ()
1562                 {
1563                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1564                         nfi.PercentGroupSeparator = "-";
1565                         Assert.AreEqual ("-214-748-364-800.0 %",Int32.MinValue.ToString ("P1", nfi), "#01");
1566                 }
1567
1568                 [Test]
1569                 public void Test05029 ()
1570                 {
1571                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1572                         nfi.PercentGroupSizes = new int [] {};
1573                         Assert.AreEqual ("-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi), "#01");
1574                         nfi.PercentGroupSizes = new int [] {0};
1575                         Assert.AreEqual ("-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi), "#02");
1576                         nfi.PercentGroupSizes = new int [] {1};
1577                         Assert.AreEqual ("-2,1,4,7,4,8,3,6,4,8,0,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#03");
1578                         nfi.PercentGroupSizes = new int [] {3};
1579                         Assert.AreEqual ("-214,748,364,800.0 %",Int32.MinValue.ToString ("P1", nfi), "#04");
1580                         nfi.PercentGroupSizes = new int [] {9};
1581                         Assert.AreEqual ("-214,748364800.0 %",Int32.MinValue.ToString ("P1", nfi), "#05");
1582                 }
1583
1584                 [Test]
1585                 public void Test05030 ()
1586                 {
1587                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1588                         nfi.PercentGroupSizes = new int [] {1,2};
1589                         Assert.AreEqual ("-2,14,74,83,64,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#01");
1590                         nfi.PercentGroupSizes = new int [] {1,2,3};
1591                         Assert.AreEqual ("-214,748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#02");
1592                         nfi.PercentGroupSizes = new int [] {1,2,3,4};
1593                         Assert.AreEqual ("-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#03");
1594                         nfi.PercentGroupSizes = new int [] {1,2,1,2,1,2,1};
1595                         Assert.AreEqual ("-2,1,4,74,8,36,4,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#04");
1596                         nfi.PercentGroupSizes = new int [] {1,0};
1597                         Assert.AreEqual ("-21474836480,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#05");
1598                         nfi.PercentGroupSizes = new int [] {1,2,0};
1599                         Assert.AreEqual ("-214748364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#06");
1600                         nfi.PercentGroupSizes = new int [] {1,2,3,0};
1601                         Assert.AreEqual ("-214748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#07");
1602                         nfi.PercentGroupSizes = new int [] {1,2,3,4,0};
1603                         Assert.AreEqual ("-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi), "#08");
1604                 }
1605
1606                 [Test]
1607                 public void Test05031 ()
1608                 {
1609                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1610                         nfi.NegativeSign = "1234567890";
1611                         Assert.AreEqual ("1234567890214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
1612                 }
1613
1614                 [Test]
1615                 public void Test05032 ()
1616                 {
1617                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1618                         nfi.PercentNegativePattern = 0;
1619                         Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
1620                         Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
1621                         Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
1622                 }
1623
1624                 [Test]
1625                 public void Test05033 ()
1626                 {
1627                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1628                         nfi.PercentNegativePattern = 1;
1629                         Assert.AreEqual ("-214,748,364,800.00%", Int32.MinValue.ToString ("P", nfi), "#01");
1630                         Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
1631                         Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
1632                 }
1633
1634                 [Test]
1635                 public void Test05034 ()
1636                 {
1637                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1638                         nfi.PercentNegativePattern = 2;
1639                         Assert.AreEqual ("-%214,748,364,800.00", Int32.MinValue.ToString ("P", nfi), "#01");
1640                         Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
1641                         Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
1642                 }
1643
1644                 [Test]
1645                 public void Test05035 ()
1646                 {
1647                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1648                         nfi.PercentPositivePattern = 0;
1649                         Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
1650                         Assert.AreEqual ("214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi), "#02");
1651                         Assert.AreEqual ("0.00 %", 0.ToString ("P", nfi), "#03");
1652                 }
1653
1654                 [Test]
1655                 public void Test05036 ()
1656                 {
1657                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1658                         nfi.PercentPositivePattern = 1;
1659                         Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
1660                         Assert.AreEqual ("214,748,364,700.00%", Int32.MaxValue.ToString ("P", nfi), "#02");
1661                         Assert.AreEqual ("0.00%", 0.ToString ("P", nfi), "#03");
1662                 }
1663
1664                 [Test]
1665                 public void Test05037 ()
1666                 {
1667                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1668                         nfi.PercentPositivePattern = 2;
1669                         Assert.AreEqual ("-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi), "#01");
1670                         Assert.AreEqual ("%214,748,364,700.00", Int32.MaxValue.ToString ("P", nfi), "#02");
1671                         Assert.AreEqual ("%0.00", 0.ToString ("P", nfi), "#03");
1672                 }
1673
1674                 // Test06000 - Int32 and R
1675                 [Test]
1676                 [ExpectedException (typeof (FormatException))]
1677                 public void Test06000 ()
1678                 {
1679                         Assert.AreEqual ("0", 0.ToString ("R", _nfi), "#01");
1680                 }
1681
1682                 // Test07000- Int32 and X
1683                 [Test]
1684                 public void Test07000 ()
1685                 {
1686                         Assert.AreEqual ("0", 0.ToString ("X", _nfi), "#01");
1687                         Assert.AreEqual ("0", 0.ToString ("x", _nfi), "#02");
1688                         Assert.AreEqual ("80000000", Int32.MinValue.ToString ("X", _nfi), "#03");
1689                         Assert.AreEqual ("80000000", Int32.MinValue.ToString ("x", _nfi), "#04");
1690                         Assert.AreEqual ("7FFFFFFF", Int32.MaxValue.ToString ("X", _nfi), "#05");
1691                         Assert.AreEqual ("7fffffff", Int32.MaxValue.ToString ("x", _nfi), "#06");
1692                 }
1693
1694                 [Test]
1695                 public void Test07001 ()
1696                 {
1697                         Assert.AreEqual ("X ", 0.ToString ("X ", _nfi), "#01");
1698                         Assert.AreEqual (" X", 0.ToString (" X", _nfi), "#02");
1699                         Assert.AreEqual (" X ", 0.ToString (" X ", _nfi), "#03");
1700                 }
1701
1702                 [Test]
1703                 public void Test07002 ()
1704                 {
1705                         Assert.AreEqual ("-X ", (-1).ToString ("X ", _nfi), "#01");
1706                         Assert.AreEqual ("- X", (-1).ToString (" X", _nfi), "#02");
1707                         Assert.AreEqual ("- X ", (-1).ToString (" X ", _nfi), "#03");
1708                 }
1709
1710                 [Test]
1711                 public void Test07003 ()
1712                 {
1713                         Assert.AreEqual ("0", 0.ToString ("X0", _nfi), "#01");
1714                         Assert.AreEqual ("0000000000", 0.ToString ("X10", _nfi), "#02");
1715                         Assert.AreEqual ("00000000000", 0.ToString ("X11", _nfi), "#03");
1716                         Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("X99", _nfi), "#04");
1717                         Assert.AreEqual ("X100", 0.ToString ("X100", _nfi), "#05");
1718                 }
1719
1720                 [Test]
1721                 public void Test07004 ()
1722                 {
1723                         Assert.AreEqual ("7FFFFFFF", Int32.MaxValue.ToString ("X0", _nfi), "#01");
1724                         Assert.AreEqual ("007FFFFFFF", Int32.MaxValue.ToString ("X10", _nfi), "#02");
1725                         Assert.AreEqual ("0007FFFFFFF", Int32.MaxValue.ToString ("X11", _nfi), "#03");
1726                         Assert.AreEqual ("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FFFFFFF", Int32.MaxValue.ToString ("X99", _nfi), "#04");
1727                         Assert.AreEqual ("X12147483647", Int32.MaxValue.ToString ("X100", _nfi), "#05");
1728                 }
1729
1730                 [Test]
1731                 public void Test07005 ()
1732                 {
1733                         Assert.AreEqual ("80000000", Int32.MinValue.ToString ("X0", _nfi), "#01");
1734                         Assert.AreEqual ("0080000000", Int32.MinValue.ToString ("X10", _nfi), "#02");
1735                         Assert.AreEqual ("00080000000", Int32.MinValue.ToString ("X11", _nfi), "#03");
1736                         Assert.AreEqual ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000", Int32.MinValue.ToString ("X99", _nfi), "#04");
1737                         Assert.AreEqual ("-X12147483648", Int32.MinValue.ToString ("X100", _nfi), "#05");
1738                 }
1739
1740                 [Test]
1741                 public void Test07006 ()
1742                 {
1743                         Assert.AreEqual ("XF", 0.ToString ("XF", _nfi), "#01");
1744                         Assert.AreEqual ("X0F", 0.ToString ("X0F", _nfi), "#02");
1745                         Assert.AreEqual ("X0xF", 0.ToString ("X0xF", _nfi), "#03");
1746                 }
1747
1748                 [Test]
1749                 public void Test07007 ()
1750                 {
1751                         Assert.AreEqual ("XF", Int32.MaxValue.ToString ("XF", _nfi), "#01");
1752                         Assert.AreEqual ("X2147483647F", Int32.MaxValue.ToString ("X0F", _nfi), "#02");
1753                         Assert.AreEqual ("X2147483647xF", Int32.MaxValue.ToString ("X0xF", _nfi), "#03");
1754                 }
1755
1756                 [Test]
1757                 public void Test07008 ()
1758                 {
1759                         Assert.AreEqual ("-XF", Int32.MinValue.ToString ("XF", _nfi), "#01");
1760                         Assert.AreEqual ("-X2147483648F", Int32.MinValue.ToString ("X0F", _nfi), "#02");
1761                         Assert.AreEqual ("-X2147483648xF", Int32.MinValue.ToString ("X0xF", _nfi), "#03");
1762                 }
1763
1764                 [Test]
1765                 public void Test07009 ()
1766                 {
1767                         Assert.AreEqual ("00000000000", 0.ToString ("X0000000000000000000000000000000000000011", _nfi), "#01");
1768                         Assert.AreEqual ("0007FFFFFFF", Int32.MaxValue.ToString ("X0000000000000000000000000000000000000011", _nfi), "#02");
1769                         Assert.AreEqual ("00080000000", Int32.MinValue.ToString ("X0000000000000000000000000000000000000011", _nfi), "#03");
1770                 }
1771
1772                 [Test]
1773                 public void Test07010 ()
1774                 {
1775                         Assert.AreEqual ("+X", 0.ToString ("+X", _nfi), "#01");
1776                         Assert.AreEqual ("X+", 0.ToString ("X+", _nfi), "#02");
1777                         Assert.AreEqual ("+X+", 0.ToString ("+X+", _nfi), "#03");
1778                 }
1779
1780                 [Test]
1781                 public void Test07011 ()
1782                 {
1783                         Assert.AreEqual ("+X", Int32.MaxValue.ToString ("+X", _nfi), "#01");
1784                         Assert.AreEqual ("X+", Int32.MaxValue.ToString ("X+", _nfi), "#02");
1785                         Assert.AreEqual ("+X+", Int32.MaxValue.ToString ("+X+", _nfi), "#03");
1786                 }
1787
1788                 [Test]
1789                 public void Test07012 ()
1790                 {
1791                         Assert.AreEqual ("-+X", Int32.MinValue.ToString ("+X", _nfi), "#01");
1792                         Assert.AreEqual ("-X+", Int32.MinValue.ToString ("X+", _nfi), "#02");
1793                         Assert.AreEqual ("-+X+", Int32.MinValue.ToString ("+X+", _nfi), "#03");
1794                 }
1795
1796                 [Test]
1797                 public void Test07013 ()
1798                 {
1799                         Assert.AreEqual ("-X", 0.ToString ("-X", _nfi), "#01");
1800                         Assert.AreEqual ("X-", 0.ToString ("X-", _nfi), "#02");
1801                         Assert.AreEqual ("-X-", 0.ToString ("-X-", _nfi), "#03");
1802                 }
1803
1804                 [Test]
1805                 public void Test07014 ()
1806                 {
1807                         Assert.AreEqual ("-X", Int32.MaxValue.ToString ("-X", _nfi), "#01");
1808                         Assert.AreEqual ("X-", Int32.MaxValue.ToString ("X-", _nfi), "#02");
1809                         Assert.AreEqual ("-X-", Int32.MaxValue.ToString ("-X-", _nfi), "#03");
1810                 }
1811
1812                 [Test]
1813                 public void Test07015 ()
1814                 {
1815                         Assert.AreEqual ("--X", Int32.MinValue.ToString ("-X", _nfi), "#01");
1816                         Assert.AreEqual ("-X-", Int32.MinValue.ToString ("X-", _nfi), "#02");
1817                         Assert.AreEqual ("--X-", Int32.MinValue.ToString ("-X-", _nfi), "#03");
1818                 }
1819
1820                 [Test]
1821                 public void Test07016 ()
1822                 {
1823                         Assert.AreEqual ("X+0", 0.ToString ("X+0", _nfi), "#01");
1824                         Assert.AreEqual ("X+2147483647", Int32.MaxValue.ToString ("X+0", _nfi), "#02");
1825                         Assert.AreEqual ("-X+2147483648", Int32.MinValue.ToString ("X+0", _nfi), "#03");
1826                 }
1827
1828                 [Test]
1829                 public void Test07017 ()
1830                 {
1831                         Assert.AreEqual ("X+9", 0.ToString ("X+9", _nfi), "#01");
1832                         Assert.AreEqual ("X+9", Int32.MaxValue.ToString ("X+9", _nfi), "#02");
1833                         Assert.AreEqual ("-X+9", Int32.MinValue.ToString ("X+9", _nfi), "#03");
1834                 }
1835
1836                 [Test]
1837                 public void Test07018 ()
1838                 {
1839                         Assert.AreEqual ("X-9", 0.ToString ("X-9", _nfi), "#01");
1840                         Assert.AreEqual ("X-9", Int32.MaxValue.ToString ("X-9", _nfi), "#02");
1841                         Assert.AreEqual ("-X-9", Int32.MinValue.ToString ("X-9", _nfi), "#03");
1842                 }
1843
1844                 [Test]
1845                 public void Test07019 ()
1846                 {
1847                         Assert.AreEqual ("X0", 0.ToString ("X0,", _nfi), "#01");
1848                         Assert.AreEqual ("X2147484", Int32.MaxValue.ToString ("X0,", _nfi), "#02");
1849                         Assert.AreEqual ("-X2147484", Int32.MinValue.ToString ("X0,", _nfi), "#03");
1850                 }
1851
1852                 [Test]
1853                 public void Test07020 ()
1854                 {
1855                         Assert.AreEqual ("X0", 0.ToString ("X0.", _nfi), "#01");
1856                         Assert.AreEqual ("X2147483647", Int32.MaxValue.ToString ("X0.", _nfi), "#02");
1857                         Assert.AreEqual ("-X2147483648", Int32.MinValue.ToString ("X0.", _nfi), "#03");
1858                 }
1859
1860                 [Test]
1861                 public void Test07021 ()
1862                 {
1863                         Assert.AreEqual ("X0.0", 0.ToString ("X0.0", _nfi), "#01");
1864                         Assert.AreEqual ("X2147483647.0", Int32.MaxValue.ToString ("X0.0", _nfi), "#02");
1865                         Assert.AreEqual ("-X2147483648.0", Int32.MinValue.ToString ("X0.0", _nfi), "#03");
1866                 }
1867
1868                 [Test]
1869                 public void Test07022 ()
1870                 {
1871                         Assert.AreEqual ("X09", 0.ToString ("X0.9", _nfi), "#01");
1872                         Assert.AreEqual ("X21474836479", Int32.MaxValue.ToString ("X0.9", _nfi), "#02");
1873                         Assert.AreEqual ("-X21474836489", Int32.MinValue.ToString ("X0.9", _nfi), "#03");
1874                 }
1875
1876                 [Test]
1877                 public void Test08000 ()
1878                 {
1879                         Assert.AreEqual ("0", 0.ToString ("0", _nfi), "#01");
1880                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("0", _nfi), "#02");
1881                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("0", _nfi), "#03");
1882                 }
1883
1884                 // Test08000 - Int32 and Custom
1885                 [Test]
1886                 public void Test08001 ()
1887                 {
1888                         Assert.AreEqual ("00000000000", 0.ToString ("00000000000", _nfi), "#01");
1889                         Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("00000000000", _nfi), "#02");
1890                         Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("00000000000", _nfi), "#03");
1891                 }
1892
1893                 [Test]
1894                 public void Test08002 ()
1895                 {
1896                         Assert.AreEqual (" 00000000000 ", 0.ToString (" 00000000000 ", _nfi), "#01");
1897                         Assert.AreEqual (" 02147483647 ", Int32.MaxValue.ToString (" 00000000000 ", _nfi), "#02");
1898                         Assert.AreEqual ("- 02147483648 ", Int32.MinValue.ToString (" 00000000000 ", _nfi), "#03");
1899                 }
1900
1901                 [Test]
1902                 public void Test08003 ()
1903                 {
1904                         Assert.AreEqual ("", 0.ToString ("#", _nfi), "#01");
1905                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("#", _nfi), "#02");
1906                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("#", _nfi), "#03");
1907                 }
1908
1909                 [Test]
1910                 public void Test08004 ()
1911                 {
1912                         Assert.AreEqual ("", 0.ToString ("##########", _nfi), "#01");
1913                         Assert.AreEqual ("2147483647", Int32.MaxValue.ToString ("##########", _nfi), "#02");
1914                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString ("##########", _nfi), "#03");
1915                 }
1916
1917                 [Test]
1918                 public void Test08005 ()
1919                 {
1920                         Assert.AreEqual ("  ", 0.ToString (" ########## ", _nfi), "#01");
1921                         Assert.AreEqual (" 2147483647 ", Int32.MaxValue.ToString (" ########## ", _nfi), "#02");
1922                         Assert.AreEqual ("- 2147483648 ", Int32.MinValue.ToString (" ########## ", _nfi), "#03");
1923                 }
1924
1925                 [Test]
1926                 public void Test08006 ()
1927                 {
1928                         Assert.AreEqual ("", 0.ToString (".", _nfi), "#01");
1929                         Assert.AreEqual ("", Int32.MaxValue.ToString (".", _nfi), "#02");
1930                         Assert.AreEqual ("-", Int32.MinValue.ToString (".", _nfi), "#03");
1931                 }
1932
1933                 [Test]
1934                 public void Test08007 ()
1935                 {
1936                         Assert.AreEqual ("00000000000", 0.ToString ("00000000000.", _nfi), "#01");
1937                         Assert.AreEqual ("02147483647", Int32.MaxValue.ToString ("00000000000.", _nfi), "#02");
1938                         Assert.AreEqual ("-02147483648", Int32.MinValue.ToString ("00000000000.", _nfi), "#03");
1939                 }
1940
1941                 [Test]
1942                 public void Test08008 ()
1943                 {
1944                         Assert.AreEqual (".00000000000", 0.ToString (".00000000000", _nfi), "#01");
1945                         Assert.AreEqual ("2147483647.00000000000", Int32.MaxValue.ToString (".00000000000", _nfi), "#02");
1946                         Assert.AreEqual ("-2147483648.00000000000", Int32.MinValue.ToString (".00000000000", _nfi), "#03");
1947                 }
1948
1949                 [Test]
1950                 public void Test08009 ()
1951                 {
1952                         Assert.AreEqual ("00000000000.00000000000", 0.ToString ("00000000000.00000000000", _nfi), "#01");
1953                         Assert.AreEqual ("02147483647.00000000000", Int32.MaxValue.ToString ("00000000000.00000000000", _nfi), "#02");
1954                         Assert.AreEqual ("-02147483648.00000000000", Int32.MinValue.ToString ("00000000000.00000000000", _nfi), "#03");
1955                 }
1956
1957                 [Test]
1958                 public void Test08010 ()
1959                 {
1960                         Assert.AreEqual ("00.0000000000", 0.ToString ("00.0.00.000.0000", _nfi), "#01");
1961                         Assert.AreEqual ("01.0000000000", 1.ToString ("00.0.00.000.0000", _nfi), "#02");
1962                         Assert.AreEqual ("-01.0000000000", (-1).ToString ("00.0.00.000.0000", _nfi), "#03");
1963                 }
1964
1965                 [Test]
1966                 public void Test08011 ()
1967                 {
1968                         Assert.AreEqual ("", 0.ToString ("##.#.##.###.####", _nfi), "#01");
1969                         Assert.AreEqual ("1", 1.ToString ("##.#.##.###.####", _nfi), "#02");
1970                         Assert.AreEqual ("-1", (-1).ToString ("##.#.##.###.####", _nfi), "#03");
1971                 }
1972
1973                 [Test]
1974                 public void Test08012 ()
1975                 {
1976                         Assert.AreEqual ("00", 0.ToString ("0#.#.##.###.####", _nfi), "#01");
1977                         Assert.AreEqual ("01", 1.ToString ("0#.#.##.###.####", _nfi), "#02");
1978                         Assert.AreEqual ("-01", (-1).ToString ("0#.#.##.###.####", _nfi), "#03");
1979                 }
1980
1981                 [Test]
1982                 public void Test08013 ()
1983                 {
1984                         Assert.AreEqual ("0", 0.ToString ("#0.#.##.###.####", _nfi), "#01");
1985                         Assert.AreEqual ("1", 1.ToString ("#0.#.##.###.####", _nfi), "#02");
1986                         Assert.AreEqual ("-1", (-1).ToString ("#0.#.##.###.####", _nfi), "#03");
1987                 }
1988
1989                 [Test]
1990                 public void Test08014 ()
1991                 {
1992                         Assert.AreEqual (".0000000000", 0.ToString ("##.#.##.###.###0", _nfi), "#01");
1993                         Assert.AreEqual ("1.0000000000", 1.ToString ("##.#.##.###.###0", _nfi), "#02");
1994                         Assert.AreEqual ("-1.0000000000", (-1).ToString ("##.#.##.###.###0", _nfi), "#03");
1995                 }
1996
1997                 [Test]
1998                 public void Test08015 ()
1999                 {
2000                         Assert.AreEqual (".000000000", 0.ToString ("##.#.##.###.##0#", _nfi), "#01");
2001                         Assert.AreEqual ("1.000000000", 1.ToString ("##.#.##.###.##0#", _nfi), "#02");
2002                         Assert.AreEqual ("-1.000000000", (-1).ToString ("##.#.##.###.##0#", _nfi), "#03");
2003                 }
2004
2005                 [Test]
2006                 public void Test08016 ()
2007                 {
2008                         Assert.AreEqual (".000000000", 0.ToString ("##.#.##.##0.##0#", _nfi), "#01");
2009                         Assert.AreEqual ("1.000000000", 1.ToString ("##.#.##.##0.##0#", _nfi), "#02");
2010                         Assert.AreEqual ("-1.000000000", (-1).ToString ("##.#.##.##0.##0#", _nfi), "#03");
2011                 }
2012
2013                 [Test]
2014                 public void Test08017 ()
2015                 {
2016                         Assert.AreEqual ("0.000000000", 0.ToString ("#0.#.##.##0.##0#", _nfi), "#01");
2017                         Assert.AreEqual ("1.000000000", 1.ToString ("#0.#.##.##0.##0#", _nfi), "#02");
2018                         Assert.AreEqual ("-1.000000000", (-1).ToString ("#0.#.##.##0.##0#", _nfi), "#03");
2019                 }
2020
2021                 [Test]
2022                 public void Test08018 ()
2023                 {
2024                         Assert.AreEqual ("-0002147484", Int32.MinValue.ToString ("0000000000,", _nfi), "#01");
2025                         Assert.AreEqual ("-0000002147", Int32.MinValue.ToString ("0000000000,,", _nfi), "#02");
2026                         Assert.AreEqual ("-0000000002", Int32.MinValue.ToString ("0000000000,,,", _nfi), "#03");
2027                         Assert.AreEqual ("0000000000", Int32.MinValue.ToString ("0000000000,,,,", _nfi), "#04");
2028                         Assert.AreEqual ("0000000000", Int32.MinValue.ToString ("0000000000,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", _nfi), "#05");
2029                 }
2030
2031                 [Test]
2032                 public void Test08019 ()
2033                 {
2034                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString (",0000000000", _nfi), "#01");
2035                 }
2036
2037                 [Test]
2038                 public void Test08020 ()
2039                 {
2040                         Assert.AreEqual ("-0002147484", Int32.MinValue.ToString (",0000000000,", _nfi), "#01");
2041                 }
2042
2043                 [Test]
2044                 public void Test08021 ()
2045                 {
2046                         Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0,0000000000", _nfi), "#01");
2047                 }
2048
2049                 [Test]
2050                 public void Test08022 ()
2051                 {
2052                         Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0000000000,0", _nfi), "#01");
2053                 }
2054
2055                 [Test]
2056                 public void Test08023 ()
2057                 {
2058                         Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0", _nfi), "#01");
2059                 }
2060
2061                 [Test]
2062                 public void Test08024 ()
2063                 {
2064                         Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0", _nfi), "#01");
2065                 }
2066
2067                 [Test]
2068                 public void Test08025 ()
2069                 {
2070                         Assert.AreEqual ("-00,002,147,484", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0,", _nfi), "#01");
2071                 }
2072
2073                 [Test]
2074                 public void Test08026 ()
2075                 {
2076                         Assert.AreEqual ("-00,002,147,484", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0,", _nfi), "#01");
2077                 }
2078
2079                 [Test]
2080                 public void Test08027 ()
2081                 {
2082                         Assert.AreEqual ("-", Int32.MinValue.ToString (",", _nfi), "#01");
2083                 }
2084
2085                 [Test]
2086                 public void Test08028 ()
2087                 {
2088                         Assert.AreEqual ("-2147483648", Int32.MinValue.ToString (",##########", _nfi), "#01");
2089                 }
2090
2091                 [Test]
2092                 public void Test08029 ()
2093                 {
2094                         Assert.AreEqual ("-2147484", Int32.MinValue.ToString (",##########,", _nfi), "#01");
2095                 }
2096
2097                 [Test]
2098                 public void Test08030 ()
2099                 {
2100                         Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,##########", _nfi), "#01");
2101                 }
2102
2103                 [Test]
2104                 public void Test08031 ()
2105                 {
2106                         Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("##########,#", _nfi), "#01");
2107                 }
2108
2109                 [Test]
2110                 public void Test08032 ()
2111                 {
2112                         Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#", _nfi), "#01");
2113                 }
2114
2115                 [Test]
2116                 public void Test08033 ()
2117                 {
2118                         Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#", _nfi), "#01");
2119                 }
2120
2121                 [Test]
2122                 public void Test08034 ()
2123                 {
2124                         Assert.AreEqual ("-2,147,484", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#,", _nfi), "#01");
2125                 }
2126
2127                 [Test]
2128                 public void Test08035 ()
2129                 {
2130                         Assert.AreEqual ("-2,147,484", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#,", _nfi), "#01");
2131                 }
2132
2133                 [Test]
2134                 public void Test08036 ()
2135                 {
2136                         Assert.AreEqual ("-1", (-1000).ToString ("##########,", _nfi), "#01");
2137                 }
2138
2139                 [Test]
2140                 public void Test08037 ()
2141                 {
2142                         Assert.AreEqual ("", (-100).ToString ("##########,", _nfi), "#01");
2143                 }
2144
2145                 [Test]
2146                 public void Test08038 ()
2147                 {
2148                         Assert.AreEqual ("-%", Int32.MinValue.ToString ("%", _nfi), "#01");
2149                 }
2150
2151                 [Test]
2152                 public void Test08039 ()
2153                 {
2154                         Assert.AreEqual ("-214748364800%", Int32.MinValue.ToString ("0%", _nfi), "#01");
2155                 }
2156
2157                 [Test]
2158                 public void Test08040 ()
2159                 {
2160                         Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString ("%0", _nfi), "#01");
2161                 }
2162
2163                 [Test]
2164                 public void Test08041 ()
2165                 {
2166                         Assert.AreEqual ("-%21474836480000%", Int32.MinValue.ToString ("%0%", _nfi), "#01");
2167                 }
2168
2169                 [Test]
2170                 public void Test08042 ()
2171                 {
2172                         Assert.AreEqual ("- % 21474836480000 % ", Int32.MinValue.ToString (" % 0 % ", _nfi), "#01");
2173                 }
2174
2175                 [Test]
2176                 public void Test08043 ()
2177                 {
2178                         Assert.AreEqual ("-214748365%", Int32.MinValue.ToString ("0%,", _nfi), "#01");
2179                 }
2180
2181                 [Test]
2182                 public void Test08044 ()
2183                 {
2184                         Assert.AreEqual ("-214748365%", Int32.MinValue.ToString ("0,%", _nfi), "#01");
2185                 }
2186
2187                 [Test]
2188                 public void Test08045 ()
2189                 {
2190                         Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString (",%0", _nfi), "#01");
2191                 }
2192
2193                 [Test]
2194                 public void Test08046 ()
2195                 {
2196                         Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString ("%,0", _nfi), "#01");
2197                 }
2198
2199                 [Test]
2200                 public void Test08047 ()
2201                 {
2202                         Assert.AreEqual ("-2147483648%%%%%%", Int32.MinValue.ToString ("0,,,,%%%%%%", _nfi), "#01");
2203                 }
2204
2205                 [Test]
2206                 public void Test08048 ()
2207                 {
2208                         Assert.AreEqual ("-2147483648%%%%%%", Int32.MinValue.ToString ("0%%%%%%,,,,", _nfi), "#01");
2209                 }
2210
2211                 [Test]
2212                 public void Test08049 ()
2213                 {
2214                         Assert.AreEqual ("-%%%%%%2147483648", Int32.MinValue.ToString ("%%%%%%0,,,,", _nfi), "#01");
2215                 }
2216
2217                 [Test]
2218                 public void Test08050 ()
2219                 {
2220                         Assert.AreEqual ("E+0", Int32.MinValue.ToString ("E+0", _nfi), "#01");
2221                         Assert.AreEqual ("e+0", Int32.MinValue.ToString ("e+0", _nfi), "#02");
2222                         Assert.AreEqual ("E0", Int32.MinValue.ToString ("E-0", _nfi), "#03");
2223                         Assert.AreEqual ("e0", Int32.MinValue.ToString ("e-0", _nfi), "#04");
2224                 }
2225
2226                 [Test]
2227                 public void Test08051 ()
2228                 {
2229                         Assert.AreEqual ("-2E+9", Int32.MinValue.ToString ("0E+0", _nfi), "#01");
2230                         Assert.AreEqual ("-2e+9", Int32.MinValue.ToString ("0e+0", _nfi), "#02");
2231                         Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("0E-0", _nfi), "#03");
2232                         Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("0e-0", _nfi), "#04");
2233                         Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("0E0", _nfi), "#05");
2234                         Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("0e0", _nfi), "#06");
2235                 }
2236
2237                 [Test]
2238                 public void Test08052 ()
2239                 {
2240                         Assert.AreEqual ("-2E+9", Int32.MinValue.ToString ("#E+0", _nfi), "#01");
2241                         Assert.AreEqual ("-2e+9", Int32.MinValue.ToString ("#e+0", _nfi), "#02");
2242                         Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("#E-0", _nfi), "#03");
2243                         Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("#e-0", _nfi), "#04");
2244                         Assert.AreEqual ("-2E9", Int32.MinValue.ToString ("#E0", _nfi), "#05");
2245                         Assert.AreEqual ("-2e9", Int32.MinValue.ToString ("#e0", _nfi), "#06");
2246                 }
2247
2248                 [Test]
2249                 public void Test08053 ()
2250                 {
2251                         Assert.AreEqual ("-2147483648E+0", Int32.MinValue.ToString ("0000000000E+0", _nfi), "#01");
2252                         Assert.AreEqual ("-2147483648e+0", Int32.MinValue.ToString ("0000000000e+0", _nfi), "#02");
2253                         Assert.AreEqual ("-2147483648E0", Int32.MinValue.ToString ("0000000000E-0", _nfi), "#03");
2254                         Assert.AreEqual ("-2147483648e0", Int32.MinValue.ToString ("0000000000e-0", _nfi), "#04");
2255                         Assert.AreEqual ("-2147483648E0", Int32.MinValue.ToString ("0000000000E0", _nfi), "#05");
2256                         Assert.AreEqual ("-2147483648e0", Int32.MinValue.ToString ("0000000000e0", _nfi), "#06");
2257                 }
2258
2259                 [Test]
2260                 public void Test08054 ()
2261                 {
2262                         Assert.AreEqual ("-21474836480E-1", Int32.MinValue.ToString ("00000000000E+0", _nfi), "#01");
2263                         Assert.AreEqual ("-21474836480e-1", Int32.MinValue.ToString ("00000000000e+0", _nfi), "#02");
2264                         Assert.AreEqual ("-21474836480E-1", Int32.MinValue.ToString ("00000000000E-0", _nfi), "#03");
2265                         Assert.AreEqual ("-21474836480e-1", Int32.MinValue.ToString ("00000000000e-0", _nfi), "#04");
2266                         Assert.AreEqual ("-21474836480E-1", Int32.MinValue.ToString ("00000000000E0", _nfi), "#05");
2267                         Assert.AreEqual ("-21474836480e-1", Int32.MinValue.ToString ("00000000000e0", _nfi), "#06");
2268                 }
2269
2270                 [Test]
2271                 public void Test08055 ()
2272                 {
2273                         Assert.AreEqual ("-214748365E+1", Int32.MinValue.ToString ("000000000E+0", _nfi), "#01");
2274                         Assert.AreEqual ("-214748365e+1", Int32.MinValue.ToString ("000000000e+0", _nfi), "#02");
2275                         Assert.AreEqual ("-214748365E1", Int32.MinValue.ToString ("000000000E-0", _nfi), "#03");
2276                         Assert.AreEqual ("-214748365e1", Int32.MinValue.ToString ("000000000e-0", _nfi), "#04");
2277                         Assert.AreEqual ("-214748365E1", Int32.MinValue.ToString ("000000000E0", _nfi), "#05");
2278                         Assert.AreEqual ("-214748365e1", Int32.MinValue.ToString ("000000000e0", _nfi), "#06");
2279                 }
2280
2281                 [Test]
2282                 public void Test08056 ()
2283                 {
2284                         Assert.AreEqual ("-21474836E+2", Int32.MinValue.ToString ("00000000E+0", _nfi), "#01");
2285                         Assert.AreEqual ("-21474836e+2", Int32.MinValue.ToString ("00000000e+0", _nfi), "#02");
2286                         Assert.AreEqual ("-21474836E2", Int32.MinValue.ToString ("00000000E-0", _nfi), "#03");
2287                         Assert.AreEqual ("-21474836e2", Int32.MinValue.ToString ("00000000e-0", _nfi), "#04");
2288                         Assert.AreEqual ("-21474836E2", Int32.MinValue.ToString ("00000000E0", _nfi), "#05");
2289                         Assert.AreEqual ("-21474836e2", Int32.MinValue.ToString ("00000000e0", _nfi), "#06");
2290                 }
2291
2292                 [Test]
2293                 public void Test08057 ()
2294                 {
2295                         Assert.AreEqual ("-2147483648E+00", Int32.MinValue.ToString ("0000000000E+00", _nfi), "#01");
2296                         Assert.AreEqual ("-2147483648e+00", Int32.MinValue.ToString ("0000000000e+00", _nfi), "#02");
2297                         Assert.AreEqual ("-2147483648E00", Int32.MinValue.ToString ("0000000000E-00", _nfi), "#03");
2298                         Assert.AreEqual ("-2147483648e00", Int32.MinValue.ToString ("0000000000e-00", _nfi), "#04");
2299                         Assert.AreEqual ("-2147483648E00", Int32.MinValue.ToString ("0000000000E00", _nfi), "#05");
2300                         Assert.AreEqual ("-2147483648e00", Int32.MinValue.ToString ("0000000000e00", _nfi), "#06");
2301                 }
2302
2303                 [Test]
2304                 public void Test08058 ()
2305                 {
2306                         Assert.AreEqual ("-2147483648E+02%", Int32.MinValue.ToString ("0000000000E+00%", _nfi), "#01");
2307                         Assert.AreEqual ("-2147483648e+02%", Int32.MinValue.ToString ("0000000000e+00%", _nfi), "#02");
2308                         Assert.AreEqual ("-2147483648E02%", Int32.MinValue.ToString ("0000000000E-00%", _nfi), "#03");
2309                         Assert.AreEqual ("-2147483648e02%", Int32.MinValue.ToString ("0000000000e-00%", _nfi), "#04");
2310                         Assert.AreEqual ("-2147483648E02%", Int32.MinValue.ToString ("0000000000E00%", _nfi), "#05");
2311                         Assert.AreEqual ("-2147483648e02%", Int32.MinValue.ToString ("0000000000e00%", _nfi), "#06");
2312                 }
2313
2314                 [Test]
2315                 public void Test08059 ()
2316                 {
2317                         Assert.AreEqual ("-2147483648E+10%%%%%", Int32.MinValue.ToString ("0000000000E+00%%%%%", _nfi), "#01");
2318                         Assert.AreEqual ("-2147483648e+10%%%%%", Int32.MinValue.ToString ("0000000000e+00%%%%%", _nfi), "#02");
2319                         Assert.AreEqual ("-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E-00%%%%%", _nfi), "#03");
2320                         Assert.AreEqual ("-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e-00%%%%%", _nfi), "#04");
2321                         Assert.AreEqual ("-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E00%%%%%", _nfi), "#05");
2322                         Assert.AreEqual ("-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e00%%%%%", _nfi), "#06");
2323                 }
2324
2325                 [Test]
2326                 public void Test08060 ()
2327                 {
2328                         Assert.AreEqual ("-2147483648E-03", Int32.MinValue.ToString ("0000000000E+00,", _nfi), "#01");
2329                         Assert.AreEqual ("-2147483648e-03", Int32.MinValue.ToString ("0000000000e+00,", _nfi), "#02");
2330                         Assert.AreEqual ("-2147483648E-03", Int32.MinValue.ToString ("0000000000E-00,", _nfi), "#03");
2331                         Assert.AreEqual ("-2147483648e-03", Int32.MinValue.ToString ("0000000000e-00,", _nfi), "#04");
2332                         Assert.AreEqual ("-2147483648E-03", Int32.MinValue.ToString ("0000000000E00,", _nfi), "#05");
2333                         Assert.AreEqual ("-2147483648e-03", Int32.MinValue.ToString ("0000000000e00,", _nfi), "#06");
2334                 }
2335
2336                 [Test]
2337                 public void Test08061 ()
2338                 {
2339                         Assert.AreEqual ("-2147483648E-12", Int32.MinValue.ToString ("0000000000E+00,,,,", _nfi), "#01");
2340                         Assert.AreEqual ("-2147483648e-12", Int32.MinValue.ToString ("0000000000e+00,,,,", _nfi), "#02");
2341                         Assert.AreEqual ("-2147483648E-12", Int32.MinValue.ToString ("0000000000E-00,,,,", _nfi), "#03");
2342                         Assert.AreEqual ("-2147483648e-12", Int32.MinValue.ToString ("0000000000e-00,,,,", _nfi), "#04");
2343                         Assert.AreEqual ("-2147483648E-12", Int32.MinValue.ToString ("0000000000E00,,,,", _nfi), "#05");
2344                         Assert.AreEqual ("-2147483648e-12", Int32.MinValue.ToString ("0000000000e00,,,,", _nfi), "#06");
2345                 }
2346
2347                 [Test]
2348                 public void Test08062 ()
2349                 {
2350                         Assert.AreEqual ("-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E+00,,,,%%%%", _nfi), "#01");
2351                         Assert.AreEqual ("-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e+00,,,,%%%%", _nfi), "#02");
2352                         Assert.AreEqual ("-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E-00,,,,%%%%", _nfi), "#03");
2353                         Assert.AreEqual ("-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e-00,,,,%%%%", _nfi), "#04");
2354                         Assert.AreEqual ("-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E00,,,,%%%%", _nfi), "#05");
2355                         Assert.AreEqual ("-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e00,,,,%%%%", _nfi), "#06");
2356                 }
2357
2358                 [Test]
2359                 public void Test08063 ()
2360                 {
2361                         Assert.AreEqual ("-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E+00,,,,%%%%", _nfi), "#01");
2362                         Assert.AreEqual ("-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e+00,,,,%%%%", _nfi), "#02");
2363                         Assert.AreEqual ("-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E-00,,,,%%%%", _nfi), "#03");
2364                         Assert.AreEqual ("-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e-00,,,,%%%%", _nfi), "#04");
2365                         Assert.AreEqual ("-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E00,,,,%%%%", _nfi), "#05");
2366                         Assert.AreEqual ("-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e00,,,,%%%%", _nfi), "#06");
2367                 }
2368
2369                 [Test]
2370                 public void Test08064 ()
2371                 {
2372                         Assert.AreEqual ("-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E,+00,,,,%%%%", _nfi), "#01");
2373                         Assert.AreEqual ("-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e,+00,,,,%%%%", _nfi), "#02");
2374                         Assert.AreEqual ("-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E,-00,,,,%%%%", _nfi), "#03");
2375                         Assert.AreEqual ("-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e,-00,,,,%%%%", _nfi), "#04");
2376                         Assert.AreEqual ("-000,000,214,7E48%%%%", Int32.MinValue.ToString ("0000000000,E,00,,,,%%%%", _nfi), "#05");
2377                         Assert.AreEqual ("-000,000,214,7e48%%%%", Int32.MinValue.ToString ("0000000000,e,00,,,,%%%%", _nfi), "#06");
2378                 }
2379
2380                 [Test]
2381                 public void Test08065 ()
2382                 {
2383                         Assert.AreEqual ("-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E+,00,,,,%%%%", _nfi), "#01");
2384                         Assert.AreEqual ("-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e+,00,,,,%%%%", _nfi), "#02");
2385                         Assert.AreEqual ("-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E-,00,,,,%%%%", _nfi), "#03");
2386                         Assert.AreEqual ("-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e-,00,,,,%%%%", _nfi), "#04");
2387                 }
2388
2389                 [Test]
2390                 public void Test08066 ()
2391                 {
2392                         Assert.AreEqual ("-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E+0,0,,,,%%%%", _nfi), "#01");
2393                         Assert.AreEqual ("-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e+0,0,,,,%%%%", _nfi), "#02");
2394                         Assert.AreEqual ("-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E-0,0,,,,%%%%", _nfi), "#03");
2395                         Assert.AreEqual ("-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e-0,0,,,,%%%%", _nfi), "#04");
2396                         Assert.AreEqual ("-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E0,0,,,,%%%%", _nfi), "#05");
2397                         Assert.AreEqual ("-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e0,0,,,,%%%%", _nfi), "#06");
2398                 }
2399
2400                 [Test]
2401                 public void Test08067 ()
2402                 {
2403                         Assert.AreEqual ("-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,,%%%%", _nfi), "#01");
2404                         Assert.AreEqual ("-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,,%%%%", _nfi), "#02");
2405                         Assert.AreEqual ("-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,,%%%%", _nfi), "#03");
2406                         Assert.AreEqual ("-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,,%%%%", _nfi), "#04");
2407                         Assert.AreEqual ("-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,,%%%%", _nfi), "#05");
2408                         Assert.AreEqual ("-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,,%%%%", _nfi), "#06");
2409                 }
2410
2411                 [Test]
2412                 public void Test08068 ()
2413                 {
2414                         Assert.AreEqual ("-2147483648E+02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,%%%%", _nfi), "#01");
2415                         Assert.AreEqual ("-2147483648e+02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,%%%%", _nfi), "#02");
2416                         Assert.AreEqual ("-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,%%%%", _nfi), "#03");
2417                         Assert.AreEqual ("-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,%%%%", _nfi), "#04");
2418                         Assert.AreEqual ("-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,%%%%", _nfi), "#05");
2419                         Assert.AreEqual ("-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,%%%%", _nfi), "#06");
2420                 }
2421
2422                 [Test]
2423                 public void Test08069 ()
2424                 {
2425                         Assert.AreEqual ("-2147483648E+00,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%%", _nfi), "#01");
2426                         Assert.AreEqual ("-2147483648e+00,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%%", _nfi), "#02");
2427                         Assert.AreEqual ("-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%%", _nfi), "#03");
2428                         Assert.AreEqual ("-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%%", _nfi), "#04");
2429                         Assert.AreEqual ("-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%%", _nfi), "#05");
2430                         Assert.AreEqual ("-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%%", _nfi), "#06");
2431                 }
2432
2433                 [Test]
2434                 public void Test08070 ()
2435                 {
2436                         Assert.AreEqual ("-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%\%", _nfi), "#01");
2437                         Assert.AreEqual ("-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%\%", _nfi), "#02");
2438                         Assert.AreEqual ("-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%\%", _nfi), "#03");
2439                         Assert.AreEqual ("-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%\%", _nfi), "#04");
2440                         Assert.AreEqual ("-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%\%", _nfi), "#05");
2441                         Assert.AreEqual ("-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%\%", _nfi), "#06");
2442                 }
2443
2444                 [Test]
2445                 public void Test08071 ()
2446                 {
2447                         Assert.AreEqual (@"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,,,\\,\\%%%\\%", _nfi), "#01");
2448                         Assert.AreEqual (@"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,,,\\,\\%%%\\%", _nfi), "#02");
2449                         Assert.AreEqual (@"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,,,\\,\\%%%\\%", _nfi), "#03");
2450                         Assert.AreEqual (@"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,,,\\,\\%%%\\%", _nfi), "#04");
2451                         Assert.AreEqual (@"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,,,\\,\\%%%\\%", _nfi), "#05");
2452                         Assert.AreEqual (@"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,,,\\,\\%%%\\%", _nfi), "#06");
2453                 }
2454
2455                 [Test]
2456                 public void Test08072 ()
2457                 {
2458                         Assert.AreEqual (@"-2147483648E+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,\,,\\\,\\%%%\\\%", _nfi), "#01");
2459                         Assert.AreEqual (@"-2147483648e+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,\,,\\\,\\%%%\\\%", _nfi), "#02");
2460                         Assert.AreEqual (@"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,\,,\\\,\\%%%\\\%", _nfi), "#03");
2461                         Assert.AreEqual (@"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,\,,\\\,\\%%%\\\%", _nfi), "#04");
2462                         Assert.AreEqual (@"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,\,,\\\,\\%%%\\\%", _nfi), "#05");
2463                         Assert.AreEqual (@"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,\,,\\\,\\%%%\\\%", _nfi), "#06");
2464                 }
2465
2466                 [Test]
2467                 public void Test08073 ()
2468                 {
2469                         Assert.AreEqual (@"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E+00\\,\,,\\\,\\%%%\\\%", _nfi), "#01");
2470                         Assert.AreEqual (@"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e+00\\,\,,\\\,\\%%%\\\%", _nfi), "#02");
2471                         Assert.AreEqual (@"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E-00\\,\,,\\\,\\%%%\\\%", _nfi), "#03");
2472                         Assert.AreEqual (@"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e-00\\,\,,\\\,\\%%%\\\%", _nfi), "#04");
2473                         Assert.AreEqual (@"-0021474836E48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E00\\,\,,\\\,\\%%%\\\%", _nfi), "#05");
2474                         Assert.AreEqual (@"-0021474836e48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e00\\,\,,\\\,\\%%%\\\%", _nfi), "#06");
2475                 }
2476
2477                 [Test]
2478                 public void Test08074 ()
2479                 {
2480                         Assert.AreEqual (@"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\+00\\,\,,\\\,\\%%%\\\%", _nfi), "#01");
2481                         Assert.AreEqual (@"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\+00\\,\,,\\\,\\%%%\\\%", _nfi), "#02");
2482                         Assert.AreEqual (@"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\-00\\,\,,\\\,\\%%%\\\%", _nfi), "#03");
2483                         Assert.AreEqual (@"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\-00\\,\,,\\\,\\%%%\\\%", _nfi), "#04");
2484                 }
2485
2486                 [Test]
2487                 public void Test08075 ()
2488                 {
2489                         Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,',%'%%%", _nfi), "#01");
2490                         Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,',%'%%%", _nfi), "#02");
2491                         Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,',%'%%%", _nfi), "#03");
2492                         Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,',%'%%%", _nfi), "#04");
2493                         Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,',%'%%%", _nfi), "#05");
2494                         Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,',%'%%%", _nfi), "#06");
2495                 }
2496
2497                 [Test]
2498                 public void Test08076 ()
2499                 {
2500                         Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,\",%\"%%%", _nfi), "#01");
2501                         Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,\",%\"%%%", _nfi), "#02");
2502                         Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,\",%\"%%%", _nfi), "#03");
2503                         Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,\",%\"%%%", _nfi), "#04");
2504                         Assert.AreEqual ("-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,\",%\"%%%", _nfi), "#05");
2505                         Assert.AreEqual ("-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,\",%\"%%%", _nfi), "#06");
2506                 }
2507
2508                 [Test]
2509                 public void Test08077 ()
2510                 {
2511                         Assert.AreEqual ("-", Int32.MinValue.ToString (";", _nfi), "#01");
2512                         Assert.AreEqual ("", Int32.MaxValue.ToString (";", _nfi), "#02");
2513                         Assert.AreEqual ("",0.ToString (";", _nfi), "#03");
2514                 }
2515
2516                 [Test]
2517                 public void Test08078 ()
2518                 {
2519                         Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,#;", _nfi), "#01");
2520                         Assert.AreEqual ("2,147,483,647", Int32.MaxValue.ToString ("#,#;", _nfi), "#02");
2521                         Assert.AreEqual ("", 0.ToString ("#,#;", _nfi), "#03");
2522                 }
2523
2524                 [Test]
2525                 public void Test08079 ()
2526                 {
2527                         Assert.AreEqual ("2,147,483,648", Int32.MinValue.ToString (";#,#", _nfi), "#01");
2528                         Assert.AreEqual ("", Int32.MaxValue.ToString (";#,#", _nfi), "#02");
2529                         Assert.AreEqual ("", 0.ToString (";#,#", _nfi), "#03");
2530                 }
2531
2532                 [Test]
2533                 public void Test08080 ()
2534                 {
2535                         Assert.AreEqual ("2,147,483,648", Int32.MinValue.ToString ("0000000000,.0000000000;#,#", _nfi), "#01");
2536                         Assert.AreEqual ("0002147483.6470000000", Int32.MaxValue.ToString ("0000000000,.0000000000;#,#", _nfi), "#02");
2537                         Assert.AreEqual ("0000000000.0000000000", 0.ToString ("0000000000,.0000000000;#,#", _nfi), "#03");
2538                 }
2539
2540                 [Test]
2541                 public void Test08081 ()
2542                 {
2543                         Assert.AreEqual ("-", Int32.MinValue.ToString (";;", _nfi), "#01");
2544                         Assert.AreEqual ("", Int32.MaxValue.ToString (";;", _nfi), "#02");
2545                         Assert.AreEqual ("",0.ToString (";;", _nfi), "#03");
2546                 }
2547
2548                 [Test]
2549                 public void Test08082 ()
2550                 {
2551                         Assert.AreEqual ("-", Int32.MinValue.ToString (";;0%", _nfi), "#01");
2552                         Assert.AreEqual ("", Int32.MaxValue.ToString (";;0%", _nfi), "#02");
2553                         Assert.AreEqual ("0%",0.ToString (";;0%", _nfi), "#03");
2554                 }
2555
2556                 [Test]
2557                 public void Test08083 ()
2558                 {
2559                         Assert.AreEqual ("2147484", Int32.MinValue.ToString (";0,;0%", _nfi), "#01");
2560                         Assert.AreEqual ("", Int32.MaxValue.ToString (";0,;0%", _nfi), "#02");
2561                         Assert.AreEqual ("0%",0.ToString (";0,;0%", _nfi), "#03");
2562                 }
2563
2564                 [Test]
2565                 public void Test08084 ()
2566                 {
2567                         Assert.AreEqual ("2147484", Int32.MinValue.ToString ("0E+0;0,;0%", _nfi), "#01");
2568                         Assert.AreEqual ("2E+9", Int32.MaxValue.ToString ("0E+0;0,;0%", _nfi), "#02");
2569                         Assert.AreEqual ("0%",0.ToString ("0E+0;0,;0%", _nfi), "#03");
2570                 }
2571
2572                 [Test]
2573                 public void Test08085 ()
2574                 {
2575                         Assert.AreEqual ("214,748,364,80;0%", Int32.MinValue.ToString (@"0E+0;0,\;0%", _nfi), "#01");
2576                         Assert.AreEqual ("2E+9", Int32.MaxValue.ToString (@"0E+0;0,\;0%", _nfi), "#02");
2577                         Assert.AreEqual ("0E+0",0.ToString (@"0E+0;0,\;0%", _nfi), "#03");
2578                 }
2579
2580                 [Test]
2581                 public void Test08086 ()
2582                 {
2583                         Assert.AreEqual ("214,748,364,80;0%", Int32.MinValue.ToString ("0E+0;0,\";\"0%", _nfi), "#01");
2584                         Assert.AreEqual ("2E+9", Int32.MaxValue.ToString ("0E+0;0,\";\"0%", _nfi), "#02");
2585                         Assert.AreEqual ("0E+0",0.ToString ("0E+0;0,\";\"0%", _nfi), "#03");
2586                 }
2587
2588                 [Test]
2589                 public void Test08087 ()
2590                 {
2591                         // MS.NET bug?
2592                         NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
2593                         nfi.NumberDecimalSeparator = "$$$";
2594                         Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
2595                 }
2596
2597                 [Test]
2598                 public void Test08088 ()
2599                 {
2600                         // MS.NET bug?
2601                         NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
2602                         nfi.NumberGroupSeparator = "$$$";
2603                         Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
2604                 }
2605
2606                 [Test]
2607                 public void Test08089 ()
2608                 {
2609                         NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
2610                         nfi.NumberGroupSizes = new int[] {3,2,1,0};
2611                         Assert.AreEqual ("-00000000002147,4,83,648", Int32.MinValue.ToString ("0000000000,0000000000", nfi), "#01");
2612                 }
2613
2614                 [Test]
2615                 public void Test08090 ()
2616                 {
2617                         // MS.NET bug?
2618                         NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
2619                         nfi.PercentSymbol = "$$$";
2620                         Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
2621                 }
2622
2623                 [Test]
2624                 public void Test08091 ()
2625                 {
2626                         // MS.NET bug?
2627                         Assert.AreEqual ("B2147", Int32.MinValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi), "#01");
2628                         Assert.AreEqual ("A2147484", Int32.MaxValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi), "#02");
2629                         Assert.AreEqual ("C0", 0.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi), "#03");
2630                 }
2631
2632                 // Test10000- Double and D
2633                 [Test]
2634                 [ExpectedException (typeof (FormatException))]
2635                 public void Test10000 ()
2636                 {
2637                         Assert.AreEqual ("0", 0.0.ToString ("D", _nfi), "#01");
2638                 }
2639
2640                 // Test11000- Double and E
2641                 [Test]
2642                 public void Test11000 ()
2643                 {
2644                         Assert.AreEqual ("0.000000E+000", 0.0.ToString ("E", _nfi), "#01");
2645                         Assert.AreEqual ("0.000000e+000", 0.0.ToString ("e", _nfi), "#02");
2646                         Assert.AreEqual ("-1.797693E+308", Double.MinValue.ToString ("E", _nfi), "#03");
2647                         Assert.AreEqual ("-1.797693e+308", Double.MinValue.ToString ("e", _nfi), "#04");
2648                         Assert.AreEqual ("1.797693E+308", Double.MaxValue.ToString ("E", _nfi), "#05");
2649                         Assert.AreEqual ("1.797693e+308", Double.MaxValue.ToString ("e", _nfi), "#06");
2650                 }
2651
2652                 [Test]
2653                 public void Test11001 ()
2654                 {
2655                         Assert.AreEqual ("E ", 0.0.ToString ("E ", _nfi), "#01");
2656                         Assert.AreEqual (" E", 0.0.ToString (" E", _nfi), "#02");
2657                         Assert.AreEqual (" E ", 0.0.ToString (" E ", _nfi), "#03");
2658                 }
2659
2660                 [Test]
2661                 public void Test11002 ()
2662                 {
2663                         Assert.AreEqual ("-E ", (-1.0).ToString ("E ", _nfi), "#01");
2664                         Assert.AreEqual ("- E", (-1.0).ToString (" E", _nfi), "#02");
2665                         Assert.AreEqual ("- E ", (-1.0).ToString (" E ", _nfi), "#03");
2666                 }
2667
2668                 [Test]
2669                 public void Test11003 ()
2670                 {
2671                         Assert.AreEqual ("0E+000", 0.0.ToString ("E0", _nfi), "#01");
2672                         Assert.AreEqual ("0.0000000000000000E+000", 0.0.ToString ("E16", _nfi), "#02");
2673                         Assert.AreEqual ("0.00000000000000000E+000", 0.0.ToString ("E17", _nfi), "#03");
2674                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.0.ToString ("E99", _nfi), "#04");
2675                         Assert.AreEqual ("E100", 0.0.ToString ("E100", _nfi), "#05");
2676                 }
2677
2678                 [Test]
2679                 public void Test11004 ()
2680                 {
2681                         Assert.AreEqual ("2E+308", Double.MaxValue.ToString ("E0", _nfi), "#01");
2682                         Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("E16", _nfi), "#02");
2683                         Assert.AreEqual ("1.79769313486231570E+308", Double.MaxValue.ToString ("E17", _nfi), "#03");
2684                         Assert.AreEqual ("1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MaxValue.ToString ("E99", _nfi), "#04");
2685                         Assert.AreEqual ("E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("E100", _nfi), "#05");
2686                 }
2687
2688                 [Test]
2689                 public void Test11005 ()
2690                 {
2691                         Assert.AreEqual ("-2E+308", Double.MinValue.ToString ("E0", _nfi), "#01");
2692                         Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("E16", _nfi), "#02");
2693                         Assert.AreEqual ("-1.79769313486231570E+308", Double.MinValue.ToString ("E17", _nfi), "#03");
2694                         Assert.AreEqual ("-1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MinValue.ToString ("E99", _nfi), "#04");
2695                         Assert.AreEqual ("-E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("E100", _nfi), "#05");
2696                 }
2697
2698                 [Test]
2699                 public void Test11006 ()
2700                 {
2701                         Assert.AreEqual ("EF", 0.0.ToString ("EF", _nfi), "#01");
2702                         Assert.AreEqual ("E0F", 0.0.ToString ("E0F", _nfi), "#02");
2703                         Assert.AreEqual ("E0xF", 0.0.ToString ("E0xF", _nfi), "#03");
2704                 }
2705
2706                 [Test]
2707                 public void Test11007 ()
2708                 {
2709                         Assert.AreEqual ("EF", Double.MaxValue.ToString ("EF", _nfi), "#01");
2710                         Assert.AreEqual ("E0F", Double.MaxValue.ToString ("E0F", _nfi), "#02");
2711                         Assert.AreEqual ("E0xF", Double.MaxValue.ToString ("E0xF", _nfi), "#03");
2712                 }
2713
2714                 [Test]
2715                 public void Test11008 ()
2716                 {
2717                         Assert.AreEqual ("-EF", Double.MinValue.ToString ("EF", _nfi), "#01");
2718                         Assert.AreEqual ("E0F", Double.MinValue.ToString ("E0F", _nfi), "#02");
2719                         Assert.AreEqual ("E0xF", Double.MinValue.ToString ("E0xF", _nfi), "#03");
2720                 }
2721
2722                 [Test]
2723                 public void Test11009 ()
2724                 {
2725                         Assert.AreEqual ("0.00000000000000000E+000", 0.0.ToString ("E0000000000000000000000000000000000000017", _nfi), "#01");
2726                         Assert.AreEqual ("1.79769313486231570E+308", Double.MaxValue.ToString ("E0000000000000000000000000000000000000017", _nfi), "#02");
2727                         Assert.AreEqual ("-1.79769313486231570E+308", Double.MinValue.ToString ("E0000000000000000000000000000000000000017", _nfi), "#03");
2728                 }
2729
2730                 [Test]
2731                 public void Test11010 ()
2732                 {
2733                         Assert.AreEqual ("+E", 0.0.ToString ("+E", _nfi), "#01");
2734                         Assert.AreEqual ("E+", 0.0.ToString ("E+", _nfi), "#02");
2735                         Assert.AreEqual ("+E+", 0.0.ToString ("+E+", _nfi), "#03");
2736                 }
2737
2738                 [Test]
2739                 public void Test11011 ()
2740                 {
2741                         Assert.AreEqual ("+E", Double.MaxValue.ToString ("+E", _nfi), "#01");
2742                         Assert.AreEqual ("E+", Double.MaxValue.ToString ("E+", _nfi), "#02");
2743                         Assert.AreEqual ("+E+", Double.MaxValue.ToString ("+E+", _nfi), "#03");
2744                 }
2745
2746                 [Test]
2747                 public void Test11012 ()
2748                 {
2749                         Assert.AreEqual ("-+E", Double.MinValue.ToString ("+E", _nfi), "#01");
2750                         Assert.AreEqual ("-E+", Double.MinValue.ToString ("E+", _nfi), "#02");
2751                         Assert.AreEqual ("-+E+", Double.MinValue.ToString ("+E+", _nfi), "#03");
2752                 }
2753
2754                 [Test]
2755                 public void Test11013 ()
2756                 {
2757                         Assert.AreEqual ("-E", 0.0.ToString ("-E", _nfi), "#01");
2758                         Assert.AreEqual ("E-", 0.0.ToString ("E-", _nfi), "#02");
2759                         Assert.AreEqual ("-E-", 0.0.ToString ("-E-", _nfi), "#03");
2760                 }
2761
2762                 [Test]
2763                 public void Test11014 ()
2764                 {
2765                         Assert.AreEqual ("-E", Double.MaxValue.ToString ("-E", _nfi), "#01");
2766                         Assert.AreEqual ("E-", Double.MaxValue.ToString ("E-", _nfi), "#02");
2767                         Assert.AreEqual ("-E-", Double.MaxValue.ToString ("-E-", _nfi), "#03");
2768                 }
2769
2770                 [Test]
2771                 public void Test11015 ()
2772                 {
2773                         Assert.AreEqual ("--E", Double.MinValue.ToString ("-E", _nfi), "#01");
2774                         Assert.AreEqual ("-E-", Double.MinValue.ToString ("E-", _nfi), "#02");
2775                         Assert.AreEqual ("--E-", Double.MinValue.ToString ("-E-", _nfi), "#03");
2776                 }
2777
2778                 [Test]
2779                 public void Test11016 ()
2780                 {
2781                         Assert.AreEqual ("E+0", 0.0.ToString ("E+0", _nfi), "#01");
2782                         Assert.AreEqual ("E+0", Double.MaxValue.ToString ("E+0", _nfi), "#02");
2783                         Assert.AreEqual ("E+0", Double.MinValue.ToString ("E+0", _nfi), "#03");
2784                 }
2785
2786                 [Test]
2787                 public void Test11017 ()
2788                 {
2789                         Assert.AreEqual ("E+9", 0.0.ToString ("E+9", _nfi), "#01");
2790                         Assert.AreEqual ("E+9", Double.MaxValue.ToString ("E+9", _nfi), "#02");
2791                         Assert.AreEqual ("-E+9", Double.MinValue.ToString ("E+9", _nfi), "#03");
2792                 }
2793
2794                 [Test]
2795                 public void Test11018 ()
2796                 {
2797                         Assert.AreEqual ("E-9", 0.0.ToString ("E-9", _nfi), "#01");
2798                         Assert.AreEqual ("E-9", Double.MaxValue.ToString ("E-9", _nfi), "#02");
2799                         Assert.AreEqual ("-E-9", Double.MinValue.ToString ("E-9", _nfi), "#03");
2800                 }
2801
2802                 [Test]
2803                 public void Test11019 ()
2804                 {
2805                         Assert.AreEqual ("E0", 0.0.ToString ("E0,", _nfi), "#01");
2806                         Assert.AreEqual ("E0", Double.MaxValue.ToString ("E0,", _nfi), "#02");
2807                         Assert.AreEqual ("E0", Double.MinValue.ToString ("E0,", _nfi), "#03");
2808                 }
2809
2810                 [Test]
2811                 public void Test11020 ()
2812                 {
2813                         Assert.AreEqual ("E0", 0.0.ToString ("E0.", _nfi), "#01");
2814                         Assert.AreEqual ("E0", Double.MaxValue.ToString ("E0.", _nfi), "#02");
2815                         Assert.AreEqual ("E0", Double.MinValue.ToString ("E0.", _nfi), "#03");
2816                 }
2817
2818                 [Test]
2819                 public void Test11021 ()
2820                 {
2821                         Assert.AreEqual ("E0.0", 0.0.ToString ("E0.0", _nfi), "#01");
2822                         Assert.AreEqual ("E309.2", Double.MaxValue.ToString ("E0.0", _nfi), "#02");
2823                         Assert.AreEqual ("-E309.2", Double.MinValue.ToString ("E0.0", _nfi), "#03");
2824                 }
2825
2826                 [Test]
2827                 public void Test11022 ()
2828                 {
2829                         Assert.AreEqual ("E09", 0.0.ToString ("E0.9", _nfi), "#01");
2830                         Assert.AreEqual ("E09", Double.MaxValue.ToString ("E0.9", _nfi), "#02");
2831                         Assert.AreEqual ("E09", Double.MinValue.ToString ("E0.9", _nfi), "#03");
2832                 }
2833
2834                 [Test]
2835                 public void Test11023 ()
2836                 {
2837                         Assert.AreEqual ("1.1E+000", 1.05.ToString ("E1", _nfi), "#01");
2838                         Assert.AreEqual ("1.2E+000", 1.15.ToString ("E1", _nfi), "#02");
2839                         Assert.AreEqual ("1.3E+000", 1.25.ToString ("E1", _nfi), "#03");
2840                         Assert.AreEqual ("1.4E+000", 1.35.ToString ("E1", _nfi), "#04");
2841                         Assert.AreEqual ("1.5E+000", 1.45.ToString ("E1", _nfi), "#05");
2842                         Assert.AreEqual ("1.6E+000", 1.55.ToString ("E1", _nfi), "#06");
2843                         Assert.AreEqual ("1.7E+000", 1.65.ToString ("E1", _nfi), "#07");
2844                         Assert.AreEqual ("1.8E+000", 1.75.ToString ("E1", _nfi), "#08");
2845                         Assert.AreEqual ("1.9E+000", 1.85.ToString ("E1", _nfi), "#09");
2846                         Assert.AreEqual ("2.0E+000", 1.95.ToString ("E1", _nfi), "#10");
2847                 }
2848
2849                 [Test]
2850                 public void Test11024 ()
2851                 {
2852                         Assert.AreEqual ("1.01E+000", 1.005.ToString ("E2", _nfi), "#01");
2853                         Assert.AreEqual ("1.02E+000", 1.015.ToString ("E2", _nfi), "#02");
2854                         Assert.AreEqual ("1.03E+000", 1.025.ToString ("E2", _nfi), "#03");
2855                         Assert.AreEqual ("1.04E+000", 1.035.ToString ("E2", _nfi), "#04");
2856                         Assert.AreEqual ("1.05E+000", 1.045.ToString ("E2", _nfi), "#05");
2857                         Assert.AreEqual ("1.06E+000", 1.055.ToString ("E2", _nfi), "#06");
2858                         Assert.AreEqual ("1.07E+000", 1.065.ToString ("E2", _nfi), "#07");
2859                         Assert.AreEqual ("1.08E+000", 1.075.ToString ("E2", _nfi), "#08");
2860                         Assert.AreEqual ("1.09E+000", 1.085.ToString ("E2", _nfi), "#09");
2861                         Assert.AreEqual ("1.10E+000", 1.095.ToString ("E2", _nfi), "#10");
2862                 }
2863
2864                 [Test]
2865                 public void Test11025 ()
2866                 {
2867                         Assert.AreEqual ("1.00000000000001E+000", 1.000000000000005.ToString ("E14", _nfi), "#01");
2868                         Assert.AreEqual ("1.00000000000002E+000", 1.000000000000015.ToString ("E14", _nfi), "#02");
2869                         Assert.AreEqual ("1.00000000000003E+000", 1.000000000000025.ToString ("E14", _nfi), "#03");
2870                         Assert.AreEqual ("1.00000000000004E+000", 1.000000000000035.ToString ("E14", _nfi), "#04");
2871                         Assert.AreEqual ("1.00000000000005E+000", 1.000000000000045.ToString ("E14", _nfi), "#05");
2872                         Assert.AreEqual ("1.00000000000006E+000", 1.000000000000055.ToString ("E14", _nfi), "#06");
2873                         Assert.AreEqual ("1.00000000000007E+000", 1.000000000000065.ToString ("E14", _nfi), "#07");
2874                         Assert.AreEqual ("1.00000000000008E+000", 1.000000000000075.ToString ("E14", _nfi), "#08");
2875                         Assert.AreEqual ("1.00000000000009E+000", 1.000000000000085.ToString ("E14", _nfi), "#09");
2876                         Assert.AreEqual ("1.00000000000010E+000", 1.000000000000095.ToString ("E14", _nfi), "#10");
2877                 }
2878
2879                 [Test]
2880                 public void Test11026 ()
2881                 {
2882                         Assert.AreEqual ("1.000000000000000E+000", 1.0000000000000005.ToString ("E15", _nfi), "#01");
2883                         Assert.AreEqual ("1.000000000000002E+000", 1.0000000000000015.ToString ("E15", _nfi), "#02");
2884                         Assert.AreEqual ("1.000000000000002E+000", 1.0000000000000025.ToString ("E15", _nfi), "#03");
2885                         Assert.AreEqual ("1.000000000000004E+000", 1.0000000000000035.ToString ("E15", _nfi), "#04");
2886                         Assert.AreEqual ("1.000000000000004E+000", 1.0000000000000045.ToString ("E15", _nfi), "#05");
2887                         Assert.AreEqual ("1.000000000000006E+000", 1.0000000000000055.ToString ("E15", _nfi), "#06");
2888                         Assert.AreEqual ("1.000000000000006E+000", 1.0000000000000065.ToString ("E15", _nfi), "#07");
2889                         Assert.AreEqual ("1.000000000000008E+000", 1.0000000000000075.ToString ("E15", _nfi), "#08");
2890                         Assert.AreEqual ("1.000000000000008E+000", 1.0000000000000085.ToString ("E15", _nfi), "#09");
2891                         Assert.AreEqual ("1.000000000000010E+000", 1.0000000000000095.ToString ("E15", _nfi), "#10");
2892                 }
2893
2894                 [Test]
2895                 public void Test11027 ()
2896                 {
2897                         Assert.AreEqual ("1.0000000000000000E+000", 1.00000000000000005.ToString ("E16", _nfi), "#01");
2898                         Assert.AreEqual ("1.0000000000000002E+000", 1.00000000000000015.ToString ("E16", _nfi), "#02");
2899                         Assert.AreEqual ("1.0000000000000002E+000", 1.00000000000000025.ToString ("E16", _nfi), "#03");
2900                         Assert.AreEqual ("1.0000000000000004E+000", 1.00000000000000035.ToString ("E16", _nfi), "#04");
2901                         Assert.AreEqual ("1.0000000000000004E+000", 1.00000000000000045.ToString ("E16", _nfi), "#05");
2902                         Assert.AreEqual ("1.0000000000000004E+000", 1.00000000000000055.ToString ("E16", _nfi), "#06");
2903                         Assert.AreEqual ("1.0000000000000007E+000", 1.00000000000000065.ToString ("E16", _nfi), "#07");
2904                         Assert.AreEqual ("1.0000000000000007E+000", 1.00000000000000075.ToString ("E16", _nfi), "#08");
2905                         Assert.AreEqual ("1.0000000000000009E+000", 1.00000000000000085.ToString ("E16", _nfi), "#09");
2906                         Assert.AreEqual ("1.0000000000000009E+000", 1.00000000000000095.ToString ("E16", _nfi), "#10");
2907                 }
2908
2909                 [Test]
2910                 public void Test11028 ()
2911                 {
2912                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000005.ToString ("E17", _nfi), "#01");
2913                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000015.ToString ("E17", _nfi), "#02");
2914                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000025.ToString ("E17", _nfi), "#03");
2915                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000035.ToString ("E17", _nfi), "#04");
2916                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000045.ToString ("E17", _nfi), "#05");
2917                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000055.ToString ("E17", _nfi), "#06");
2918                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000065.ToString ("E17", _nfi), "#07");
2919                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000075.ToString ("E17", _nfi), "#08");
2920                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000085.ToString ("E17", _nfi), "#09");
2921                         Assert.AreEqual ("1.00000000000000000E+000", 1.000000000000000095.ToString ("E17", _nfi), "#10");
2922                 }
2923
2924                 [Test]
2925                 public void Test11029 ()
2926                 {
2927                         Assert.AreEqual ("1E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E0"), "#01");
2928                         Assert.AreEqual ("1.2345678901234567E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E16"), "#02");
2929                         Assert.AreEqual ("1.23456789012345670E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E17"), "#03");
2930                         Assert.AreEqual ("1.234567890123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E99"), "#04");
2931                         Assert.AreEqual ("E101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E100"), "#04");
2932                 }
2933
2934                 [Test]
2935                 public void Test11030 ()
2936                 {
2937                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
2938                         nfi.NumberDecimalSeparator = "#";
2939                         Assert.AreEqual ("-1#000000E+008", (-99999999.9).ToString ("E", nfi), "#01");
2940                 }
2941
2942                 [Test]
2943                 public void Test11031 ()
2944                 {
2945                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
2946                         nfi.NegativeSign = "+";
2947                         nfi.PositiveSign = "-";
2948
2949                         Assert.AreEqual ("1.000000E-000", 1.0.ToString ("E", nfi), "#01");
2950                         Assert.AreEqual ("0.000000E-000", 0.0.ToString ("E", nfi), "#02");
2951                         Assert.AreEqual ("+1.000000E-000", (-1.0).ToString ("E", nfi), "#03");
2952                 }
2953
2954                 [Test]
2955                 public void TestNaNToString ()
2956                 {
2957                         Assert.AreEqual ("Infinity", Double.PositiveInfinity.ToString(), "#01");
2958                         Assert.AreEqual ("-Infinity", Double.NegativeInfinity.ToString(), "#02");
2959                         Assert.AreEqual ("NaN", Double.NaN.ToString(), "#03");
2960                         Assert.AreEqual ("Infinity", Single.PositiveInfinity.ToString(), "#04");
2961                         Assert.AreEqual ("-Infinity", Single.NegativeInfinity.ToString(), "#05");
2962                         Assert.AreEqual ("NaN", Single.NaN.ToString(), "#06");
2963
2964                         Assert.AreEqual ("Infinity", Double.PositiveInfinity.ToString("R"), "#07");
2965                         Assert.AreEqual ("-Infinity", Double.NegativeInfinity.ToString("R"), "#08");
2966                         Assert.AreEqual ("NaN", Double.NaN.ToString("R"), "#09");
2967                         Assert.AreEqual ("Infinity", Single.PositiveInfinity.ToString("R"), "#10");
2968                         Assert.AreEqual ("-Infinity", Single.NegativeInfinity.ToString("R"), "#11");
2969                         Assert.AreEqual ("NaN", Single.NaN.ToString("R"), "#12");
2970                 }
2971
2972                 [Test]
2973                 public void Test11032 ()
2974                 {
2975                         Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("E99", _nfi) , "#01");
2976                         Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("E99", _nfi) , "#02");
2977                         Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("E99", _nfi) , "#03");
2978                 }
2979
2980                 // Test12000- Double and F
2981                 [Test]
2982                 public void Test12000 ()
2983                 {
2984                         Assert.AreEqual ("0.00", 0.0.ToString ("F", _nfi), "#01");
2985                         Assert.AreEqual ("0.00", 0.0.ToString ("f", _nfi), "#02");
2986                         Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("F", _nfi), "#03");
2987                         Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("f", _nfi), "#04");
2988                         Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("F", _nfi), "#05");
2989                         Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("f", _nfi), "#06");
2990                 }
2991
2992                 [Test]
2993                 public void Test12001 ()
2994                 {
2995                         Assert.AreEqual ("F ", 0.0.ToString ("F ", _nfi), "#01");
2996                         Assert.AreEqual (" F", 0.0.ToString (" F", _nfi), "#02");
2997                         Assert.AreEqual (" F ", 0.0.ToString (" F ", _nfi), "#03");
2998                 }
2999
3000                 [Test]
3001                 public void Test12002 ()
3002                 {
3003                         Assert.AreEqual ("-F ", (-1.0).ToString ("F ", _nfi), "#01");
3004                         Assert.AreEqual ("- F", (-1.0).ToString (" F", _nfi), "#02");
3005                         Assert.AreEqual ("- F ", (-1.0).ToString (" F ", _nfi), "#03");
3006                 }
3007
3008                 [Test]
3009                 public void Test12003 ()
3010                 {
3011                         Assert.AreEqual ("0", 0.0.ToString ("F0", _nfi), "#01");
3012                         Assert.AreEqual ("0.0000000000000000", 0.0.ToString ("F16", _nfi), "#02");
3013                         Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("F17", _nfi), "#03");
3014                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("F99", _nfi), "#04");
3015                         Assert.AreEqual ("F100", 0.0.ToString ("F100", _nfi), "#05");
3016                 }
3017
3018                 [Test]
3019                 public void Test12004 ()
3020                 {
3021                         Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0", _nfi), "#01");
3022                         Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MaxValue.ToString ("F16", _nfi), "#02");
3023                         Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F17", _nfi), "#03");
3024                         Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F99", _nfi), "#04");
3025                         Assert.AreEqual ("F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F100", _nfi), "#05");
3026                 }
3027
3028                 [Test]
3029                 public void Test12005 ()
3030                 {
3031                         Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0", _nfi), "#01");
3032                         Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MinValue.ToString ("F16", _nfi), "#02");
3033                         Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F17", _nfi), "#03");
3034                         Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F99", _nfi), "#04");
3035                         Assert.AreEqual ("-F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F100", _nfi), "#05");
3036                 }
3037
3038                 [Test]
3039                 public void Test12006 ()
3040                 {
3041                         Assert.AreEqual ("FF", 0.0.ToString ("FF", _nfi), "#01");
3042                         Assert.AreEqual ("F0F", 0.0.ToString ("F0F", _nfi), "#02");
3043                         Assert.AreEqual ("F0xF", 0.0.ToString ("F0xF", _nfi), "#03");
3044                 }
3045
3046                 [Test]
3047                 public void Test12007 ()
3048                 {
3049                         Assert.AreEqual ("FF", Double.MaxValue.ToString ("FF", _nfi), "#01");
3050                         Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("F0F", _nfi), "#02");
3051                         Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("F0xF", _nfi), "#03");
3052                 }
3053
3054                 [Test]
3055                 public void Test12008 ()
3056                 {
3057                         Assert.AreEqual ("-FF", Double.MinValue.ToString ("FF", _nfi), "#01");
3058                         Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("F0F", _nfi), "#02");
3059                         Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("F0xF", _nfi), "#03");
3060                 }
3061
3062                 [Test]
3063                 public void Test12009 ()
3064                 {
3065                         Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("F0000000000000000000000000000000000000017", _nfi), "#01");
3066                         Assert.AreEqual ("179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F0000000000000000000000000000000000000017", _nfi), "#02");
3067                         Assert.AreEqual ("-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F0000000000000000000000000000000000000017", _nfi), "#03");
3068                 }
3069
3070                 [Test]
3071                 public void Test12010 ()
3072                 {
3073                         Assert.AreEqual ("+F", 0.0.ToString ("+F", _nfi), "#01");
3074                         Assert.AreEqual ("F+", 0.0.ToString ("F+", _nfi), "#02");
3075                         Assert.AreEqual ("+F+", 0.0.ToString ("+F+", _nfi), "#03");
3076                 }
3077
3078                 [Test]
3079                 public void Test12011 ()
3080                 {
3081                         Assert.AreEqual ("+F", Double.MaxValue.ToString ("+F", _nfi), "#01");
3082                         Assert.AreEqual ("F+", Double.MaxValue.ToString ("F+", _nfi), "#02");
3083                         Assert.AreEqual ("+F+", Double.MaxValue.ToString ("+F+", _nfi), "#03");
3084                 }
3085
3086                 [Test]
3087                 public void Test12012 ()
3088                 {
3089                         Assert.AreEqual ("-+F", Double.MinValue.ToString ("+F", _nfi), "#01");
3090                         Assert.AreEqual ("-F+", Double.MinValue.ToString ("F+", _nfi), "#02");
3091                         Assert.AreEqual ("-+F+", Double.MinValue.ToString ("+F+", _nfi), "#03");
3092                 }
3093
3094                 [Test]
3095                 public void Test12013 ()
3096                 {
3097                         Assert.AreEqual ("-F", 0.0.ToString ("-F", _nfi), "#01");
3098                         Assert.AreEqual ("F-", 0.0.ToString ("F-", _nfi), "#02");
3099                         Assert.AreEqual ("-F-", 0.0.ToString ("-F-", _nfi), "#03");
3100                 }
3101
3102                 [Test]
3103                 public void Test12014 ()
3104                 {
3105                         Assert.AreEqual ("-F", Double.MaxValue.ToString ("-F", _nfi), "#01");
3106                         Assert.AreEqual ("F-", Double.MaxValue.ToString ("F-", _nfi), "#02");
3107                         Assert.AreEqual ("-F-", Double.MaxValue.ToString ("-F-", _nfi), "#03");
3108                 }
3109
3110                 [Test]
3111                 public void Test12015 ()
3112                 {
3113                         Assert.AreEqual ("--F", Double.MinValue.ToString ("-F", _nfi), "#01");
3114                         Assert.AreEqual ("-F-", Double.MinValue.ToString ("F-", _nfi), "#02");
3115                         Assert.AreEqual ("--F-", Double.MinValue.ToString ("-F-", _nfi), "#03");
3116                 }
3117
3118                 [Test]
3119                 public void Test12016 ()
3120                 {
3121                         Assert.AreEqual ("F+0", 0.0.ToString ("F+0", _nfi), "#01");
3122                         Assert.AreEqual ("F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F+0", _nfi), "#02");
3123                         Assert.AreEqual ("-F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F+0", _nfi), "#03");
3124                 }
3125
3126                 [Test]
3127                 public void Test12017 ()
3128                 {
3129                         Assert.AreEqual ("F+9", 0.0.ToString ("F+9", _nfi), "#01");
3130                         Assert.AreEqual ("F+9", Double.MaxValue.ToString ("F+9", _nfi), "#02");
3131                         Assert.AreEqual ("-F+9", Double.MinValue.ToString ("F+9", _nfi), "#03");
3132                 }
3133
3134                 [Test]
3135                 public void Test12018 ()
3136                 {
3137                         Assert.AreEqual ("F-9", 0.0.ToString ("F-9", _nfi), "#01");
3138                         Assert.AreEqual ("F-9", Double.MaxValue.ToString ("F-9", _nfi), "#02");
3139                         Assert.AreEqual ("-F-9", Double.MinValue.ToString ("F-9", _nfi), "#03");
3140                 }
3141
3142                 [Test]
3143                 public void Test12019 ()
3144                 {
3145                         Assert.AreEqual ("F0", 0.0.ToString ("F0,", _nfi), "#01");
3146                         Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0,", _nfi), "#02");
3147                         Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0,", _nfi), "#03");
3148                 }
3149
3150                 [Test]
3151                 public void Test12020 ()
3152                 {
3153                         Assert.AreEqual ("F0", 0.0.ToString ("F0.", _nfi), "#01");
3154                         Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0.", _nfi), "#02");
3155                         Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0.", _nfi), "#03");
3156                 }
3157
3158                 [Test]
3159                 public void Test12021 ()
3160                 {
3161                         Assert.AreEqual ("F0.0", 0.0.ToString ("F0.0", _nfi), "#01");
3162                         Assert.AreEqual ("F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("F0.0", _nfi), "#02");
3163                         Assert.AreEqual ("-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("F0.0", _nfi), "#03");
3164                 }
3165
3166                 [Test]
3167                 public void Test12022 ()
3168                 {
3169                         Assert.AreEqual ("F09", 0.0.ToString ("F0.9", _nfi), "#01");
3170                         Assert.AreEqual ("F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("F0.9", _nfi), "#02");
3171                         Assert.AreEqual ("-F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("F0.9", _nfi), "#03");
3172                 }
3173
3174                 [Test]
3175                 public void Test12023 ()
3176                 {
3177                         Assert.AreEqual ("1.1", 1.05.ToString ("F1", _nfi), "#01");
3178                         Assert.AreEqual ("1.2", 1.15.ToString ("F1", _nfi), "#02");
3179                         Assert.AreEqual ("1.3", 1.25.ToString ("F1", _nfi), "#03");
3180                         Assert.AreEqual ("1.4", 1.35.ToString ("F1", _nfi), "#04");
3181                         Assert.AreEqual ("1.5", 1.45.ToString ("F1", _nfi), "#05");
3182                         Assert.AreEqual ("1.6", 1.55.ToString ("F1", _nfi), "#06");
3183                         Assert.AreEqual ("1.7", 1.65.ToString ("F1", _nfi), "#07");
3184                         Assert.AreEqual ("1.8", 1.75.ToString ("F1", _nfi), "#08");
3185                         Assert.AreEqual ("1.9", 1.85.ToString ("F1", _nfi), "#09");
3186                         Assert.AreEqual ("2.0", 1.95.ToString ("F1", _nfi), "#10");
3187                 }
3188
3189                 [Test]
3190                 public void Test12024 ()
3191                 {
3192                         Assert.AreEqual ("1.01", 1.005.ToString ("F2", _nfi), "#01");
3193                         Assert.AreEqual ("1.02", 1.015.ToString ("F2", _nfi), "#02");
3194                         Assert.AreEqual ("1.03", 1.025.ToString ("F2", _nfi), "#03");
3195                         Assert.AreEqual ("1.04", 1.035.ToString ("F2", _nfi), "#04");
3196                         Assert.AreEqual ("1.05", 1.045.ToString ("F2", _nfi), "#05");
3197                         Assert.AreEqual ("1.06", 1.055.ToString ("F2", _nfi), "#06");
3198                         Assert.AreEqual ("1.07", 1.065.ToString ("F2", _nfi), "#07");
3199                         Assert.AreEqual ("1.08", 1.075.ToString ("F2", _nfi), "#08");
3200                         Assert.AreEqual ("1.09", 1.085.ToString ("F2", _nfi), "#09");
3201                         Assert.AreEqual ("1.10", 1.095.ToString ("F2", _nfi), "#10");
3202                 }
3203
3204                 [Test]
3205                 public void Test12025 ()
3206                 {
3207                         Assert.AreEqual ("1.00000000000001", 1.000000000000005.ToString ("F14", _nfi), "#01");
3208                         Assert.AreEqual ("1.00000000000002", 1.000000000000015.ToString ("F14", _nfi), "#02");
3209                         Assert.AreEqual ("1.00000000000003", 1.000000000000025.ToString ("F14", _nfi), "#03");
3210                         Assert.AreEqual ("1.00000000000004", 1.000000000000035.ToString ("F14", _nfi), "#04");
3211                         Assert.AreEqual ("1.00000000000005", 1.000000000000045.ToString ("F14", _nfi), "#05");
3212                         Assert.AreEqual ("1.00000000000006", 1.000000000000055.ToString ("F14", _nfi), "#06");
3213                         Assert.AreEqual ("1.00000000000007", 1.000000000000065.ToString ("F14", _nfi), "#07");
3214                         Assert.AreEqual ("1.00000000000008", 1.000000000000075.ToString ("F14", _nfi), "#08");
3215                         Assert.AreEqual ("1.00000000000009", 1.000000000000085.ToString ("F14", _nfi), "#09");
3216                         Assert.AreEqual ("1.00000000000010", 1.000000000000095.ToString ("F14", _nfi), "#10");
3217                 }
3218
3219                 [Test]
3220                 public void Test12026 ()
3221                 {
3222                         Assert.AreEqual ("1.000000000000000", 1.0000000000000005.ToString ("F15", _nfi), "#01");
3223                         Assert.AreEqual ("1.000000000000000", 1.0000000000000015.ToString ("F15", _nfi), "#02");
3224                         Assert.AreEqual ("1.000000000000000", 1.0000000000000025.ToString ("F15", _nfi), "#03");
3225                         Assert.AreEqual ("1.000000000000000", 1.0000000000000035.ToString ("F15", _nfi), "#04");
3226                         Assert.AreEqual ("1.000000000000000", 1.0000000000000045.ToString ("F15", _nfi), "#05");
3227                         Assert.AreEqual ("1.000000000000010", 1.0000000000000055.ToString ("F15", _nfi), "#06");
3228                         Assert.AreEqual ("1.000000000000010", 1.0000000000000065.ToString ("F15", _nfi), "#07");
3229                         Assert.AreEqual ("1.000000000000010", 1.0000000000000075.ToString ("F15", _nfi), "#08");
3230                         Assert.AreEqual ("1.000000000000010", 1.0000000000000085.ToString ("F15", _nfi), "#09");
3231                         Assert.AreEqual ("1.000000000000010", 1.0000000000000095.ToString ("F15", _nfi), "#10");
3232                 }
3233
3234                 [Test]
3235                 public void Test12027 ()
3236                 {
3237                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000005.ToString ("F16", _nfi), "#01");
3238                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000015.ToString ("F16", _nfi), "#02");
3239                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000025.ToString ("F16", _nfi), "#03");
3240                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000035.ToString ("F16", _nfi), "#04");
3241                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000045.ToString ("F16", _nfi), "#05");
3242                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000055.ToString ("F16", _nfi), "#06");
3243                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000065.ToString ("F16", _nfi), "#07");
3244                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000075.ToString ("F16", _nfi), "#08");
3245                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000085.ToString ("F16", _nfi), "#09");
3246                         Assert.AreEqual ("1.0000000000000000", 1.00000000000000095.ToString ("F16", _nfi), "#10");
3247                 }
3248
3249                 [Test]
3250                 public void Test12028 ()
3251                 {
3252                         Assert.AreEqual ("1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F0", _nfi), "#01");
3253                         Assert.AreEqual ("1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F12", _nfi), "#02");
3254                         Assert.AreEqual ("1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F13", _nfi), "#03");
3255                         Assert.AreEqual ("1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F14", _nfi), "#04");
3256                         Assert.AreEqual ("1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F15", _nfi), "#05");
3257                         Assert.AreEqual ("1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F99", _nfi), "#06");
3258                         Assert.AreEqual ("F101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F100", _nfi), "#07");
3259                 }
3260
3261                 [Test]
3262                 public void Test12029 ()
3263                 {
3264                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3265                         nfi.NumberDecimalSeparator = "#";
3266                         Assert.AreEqual ("-99999999#90", (-99999999.9).ToString ("F", nfi), "#01");
3267                 }
3268
3269                 [Test]
3270                 public void Test12030 ()
3271                 {
3272                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3273                         nfi.NegativeSign = "+";
3274                         nfi.PositiveSign = "-";
3275
3276                         Assert.AreEqual ("1.00", 1.0.ToString ("F", nfi), "#01");
3277                         Assert.AreEqual ("0.00", 0.0.ToString ("F", nfi), "#02");
3278                         Assert.AreEqual ("+1.00", (-1.0).ToString ("F", nfi), "#03");
3279                 }
3280
3281                 [Test]
3282                 public void Test12031 ()
3283                 {
3284                         Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("F99", _nfi) , "#01");
3285                         Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("F99", _nfi) , "#02");
3286                         Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("F99", _nfi) , "#03");
3287                 }
3288
3289                 // Test13000- Double and G
3290                 [Test]
3291                 public void Test13000 ()
3292                 {
3293                         Assert.AreEqual ("0", 0.0.ToString ("G", _nfi), "#01");
3294                         Assert.AreEqual ("0", (-0.0).ToString ("G", _nfi), "#01.1");
3295                         Assert.AreEqual ("0", 0.0.ToString ("g", _nfi), "#02");
3296                         Assert.AreEqual ("-1.79769313486232E+308", Double.MinValue.ToString ("G", _nfi), "#03");
3297                         Assert.AreEqual ("-1.79769313486232e+308", Double.MinValue.ToString ("g", _nfi), "#04");
3298                         Assert.AreEqual ("1.79769313486232E+308", Double.MaxValue.ToString ("G", _nfi), "#05");
3299                         Assert.AreEqual ("1.79769313486232e+308", Double.MaxValue.ToString ("g", _nfi), "#06");
3300                 }
3301
3302                 [Test]
3303                 public void Test13001 ()
3304                 {
3305                         Assert.AreEqual ("G ", 0.0.ToString ("G ", _nfi), "#01");
3306                         Assert.AreEqual (" G", 0.0.ToString (" G", _nfi), "#02");
3307                         Assert.AreEqual (" G ", 0.0.ToString (" G ", _nfi), "#03");
3308                 }
3309
3310                 [Test]
3311                 public void Test13002 ()
3312                 {
3313                         Assert.AreEqual ("-G ", (-1.0).ToString ("G ", _nfi), "#01");
3314                         Assert.AreEqual ("- G", (-1.0).ToString (" G", _nfi), "#02");
3315                         Assert.AreEqual ("- G ", (-1.0).ToString (" G ", _nfi), "#03");
3316                 }
3317
3318                 [Test]
3319                 public void Test13003 ()
3320                 {
3321                         Assert.AreEqual ("0", 0.0.ToString ("G0", _nfi), "#01");
3322                         Assert.AreEqual ("0", 0.0.ToString ("G16", _nfi), "#02");
3323                         Assert.AreEqual ("0", 0.0.ToString ("G17", _nfi), "#03");
3324                         Assert.AreEqual ("0", 0.0.ToString ("G99", _nfi), "#04");
3325                         Assert.AreEqual ("G100", 0.0.ToString ("G100", _nfi), "#05");
3326                 }
3327
3328                 [Test]
3329                 public void Test13004 ()
3330                 {
3331                         Assert.AreEqual ("1.79769313486232E+308", Double.MaxValue.ToString ("G0", _nfi), "#01");
3332                         Assert.AreEqual ("1.797693134862316E+308", Double.MaxValue.ToString ("G16", _nfi), "#02");
3333                         Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("G17", _nfi), "#03");
3334                         Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("G99", _nfi), "#04");
3335                         Assert.AreEqual ("G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G100", _nfi), "#05");
3336                 }
3337
3338                 [Test]
3339                 public void Test13005 ()
3340                 {
3341                         Assert.AreEqual ("-1.79769313486232E+308", Double.MinValue.ToString ("G0", _nfi), "#01");
3342                         Assert.AreEqual ("-1.797693134862316E+308", Double.MinValue.ToString ("G16", _nfi), "#02");
3343                         Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("G17", _nfi), "#03");
3344                         Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("G99", _nfi), "#04");
3345                         Assert.AreEqual ("-G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G100", _nfi), "#05");
3346                 }
3347
3348                 [Test]
3349                 public void Test13006 ()
3350                 {
3351                         Assert.AreEqual ("GF", 0.0.ToString ("GF", _nfi), "#01");
3352                         Assert.AreEqual ("G0F", 0.0.ToString ("G0F", _nfi), "#02");
3353                         Assert.AreEqual ("G0xF", 0.0.ToString ("G0xF", _nfi), "#03");
3354                 }
3355
3356                 [Test]
3357                 public void Test13007 ()
3358                 {
3359                         Assert.AreEqual ("GF", Double.MaxValue.ToString ("GF", _nfi), "#01");
3360                         Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("G0F", _nfi), "#02");
3361                         Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("G0xF", _nfi), "#03");
3362                 }
3363
3364                 [Test]
3365                 public void Test13008 ()
3366                 {
3367                         Assert.AreEqual ("-GF", Double.MinValue.ToString ("GF", _nfi), "#01");
3368                         Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("G0F", _nfi), "#02");
3369                         Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("G0xF", _nfi), "#03");
3370                 }
3371
3372                 [Test]
3373                 public void Test13009 ()
3374                 {
3375                         Assert.AreEqual ("0", 0.0.ToString ("G0000000000000000000000000000000000000017", _nfi), "#01");
3376                         Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("G0000000000000000000000000000000000000017", _nfi), "#02");
3377                         Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("G0000000000000000000000000000000000000017", _nfi), "#03");
3378                 }
3379
3380                 [Test]
3381                 public void Test13010 ()
3382                 {
3383                         Assert.AreEqual ("+G", 0.0.ToString ("+G", _nfi), "#01");
3384                         Assert.AreEqual ("G+", 0.0.ToString ("G+", _nfi), "#02");
3385                         Assert.AreEqual ("+G+", 0.0.ToString ("+G+", _nfi), "#03");
3386                 }
3387
3388                 [Test]
3389                 public void Test13011 ()
3390                 {
3391                         Assert.AreEqual ("+G", Double.MaxValue.ToString ("+G", _nfi), "#01");
3392                         Assert.AreEqual ("G+", Double.MaxValue.ToString ("G+", _nfi), "#02");
3393                         Assert.AreEqual ("+G+", Double.MaxValue.ToString ("+G+", _nfi), "#03");
3394                 }
3395
3396                 [Test]
3397                 public void Test13012 ()
3398                 {
3399                         Assert.AreEqual ("-+G", Double.MinValue.ToString ("+G", _nfi), "#01");
3400                         Assert.AreEqual ("-G+", Double.MinValue.ToString ("G+", _nfi), "#02");
3401                         Assert.AreEqual ("-+G+", Double.MinValue.ToString ("+G+", _nfi), "#03");
3402                 }
3403
3404                 [Test]
3405                 public void Test13013 ()
3406                 {
3407                         Assert.AreEqual ("-G", 0.0.ToString ("-G", _nfi), "#01");
3408                         Assert.AreEqual ("G-", 0.0.ToString ("G-", _nfi), "#02");
3409                         Assert.AreEqual ("-G-", 0.0.ToString ("-G-", _nfi), "#03");
3410                 }
3411
3412                 [Test]
3413                 public void Test13014 ()
3414                 {
3415                         Assert.AreEqual ("-G", Double.MaxValue.ToString ("-G", _nfi), "#01");
3416                         Assert.AreEqual ("G-", Double.MaxValue.ToString ("G-", _nfi), "#02");
3417                         Assert.AreEqual ("-G-", Double.MaxValue.ToString ("-G-", _nfi), "#03");
3418                 }
3419
3420                 [Test]
3421                 public void Test13015 ()
3422                 {
3423                         Assert.AreEqual ("--G", Double.MinValue.ToString ("-G", _nfi), "#01");
3424                         Assert.AreEqual ("-G-", Double.MinValue.ToString ("G-", _nfi), "#02");
3425                         Assert.AreEqual ("--G-", Double.MinValue.ToString ("-G-", _nfi), "#03");
3426                 }
3427
3428                 [Test]
3429                 public void Test13016 ()
3430                 {
3431                         Assert.AreEqual ("G+0", 0.0.ToString ("G+0", _nfi), "#01");
3432                         Assert.AreEqual ("G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G+0", _nfi), "#02");
3433                         Assert.AreEqual ("-G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G+0", _nfi), "#03");
3434                 }
3435
3436                 [Test]
3437                 public void Test13017 ()
3438                 {
3439                         Assert.AreEqual ("G+9", 0.0.ToString ("G+9", _nfi), "#01");
3440                         Assert.AreEqual ("G+9", Double.MaxValue.ToString ("G+9", _nfi), "#02");
3441                         Assert.AreEqual ("-G+9", Double.MinValue.ToString ("G+9", _nfi), "#03");
3442                 }
3443
3444                 [Test]
3445                 public void Test13018 ()
3446                 {
3447                         Assert.AreEqual ("G-9", 0.0.ToString ("G-9", _nfi), "#01");
3448                         Assert.AreEqual ("G-9", Double.MaxValue.ToString ("G-9", _nfi), "#02");
3449                         Assert.AreEqual ("-G-9", Double.MinValue.ToString ("G-9", _nfi), "#03");
3450                 }
3451
3452                 [Test]
3453                 public void Test13019 ()
3454                 {
3455                         Assert.AreEqual ("G0", 0.0.ToString ("G0,", _nfi), "#01");
3456                         Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0,", _nfi), "#02");
3457                         Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0,", _nfi), "#03");
3458                 }
3459
3460                 [Test]
3461                 public void Test13020 ()
3462                 {
3463                         Assert.AreEqual ("G0", 0.0.ToString ("G0.", _nfi), "#01");
3464                         Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0.", _nfi), "#02");
3465                         Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0.", _nfi), "#03");
3466                 }
3467
3468                 [Test]
3469                 public void Test13021 ()
3470                 {
3471                         Assert.AreEqual ("G0.0", 0.0.ToString ("G0.0", _nfi), "#01");
3472                         Assert.AreEqual ("G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("G0.0", _nfi), "#02");
3473                         Assert.AreEqual ("-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("G0.0", _nfi), "#03");
3474                 }
3475
3476                 [Test]
3477                 public void Test13022 ()
3478                 {
3479                         Assert.AreEqual ("G09", 0.0.ToString ("G0.9", _nfi), "#01");
3480                         Assert.AreEqual ("G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("G0.9", _nfi), "#02");
3481                         Assert.AreEqual ("-G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("G0.9", _nfi), "#03");
3482                 }
3483
3484                 [Test]
3485                 public void Test13023 ()
3486                 {
3487                         Assert.AreEqual ("0.5", 0.5.ToString ("G1", _nfi), "#01");
3488                         Assert.AreEqual ("2", 1.5.ToString ("G1", _nfi), "#02");
3489                         Assert.AreEqual ("3", 2.5.ToString ("G1", _nfi), "#03");
3490                         Assert.AreEqual ("4", 3.5.ToString ("G1", _nfi), "#04");
3491                         Assert.AreEqual ("5", 4.5.ToString ("G1", _nfi), "#05");
3492                         Assert.AreEqual ("6", 5.5.ToString ("G1", _nfi), "#06");
3493                         Assert.AreEqual ("7", 6.5.ToString ("G1", _nfi), "#07");
3494                         Assert.AreEqual ("8", 7.5.ToString ("G1", _nfi), "#08");
3495                         Assert.AreEqual ("9", 8.5.ToString ("G1", _nfi), "#09");
3496                         Assert.AreEqual ("1E+01", 9.5.ToString ("G1", _nfi), "#10");
3497                 }
3498
3499                 [Test]
3500                 public void Test13024_CarryPropagation ()
3501                 {
3502                         Double d = 1.15;
3503                         Assert.AreEqual ("1", d.ToString ("G1", _nfi), "#01");
3504                         // NumberStore converts 1.15 into 1.14999...91 (1 in index 17)
3505                         // so the call to NumberToString doesn't result in 1.2 but in 1.1
3506                         // which seems "somewhat" normal considering the #17 results,
3507                         Assert.AreEqual ("1.2", d.ToString ("G2", _nfi), "#02");
3508                         Assert.AreEqual ("1.15", d.ToString ("G3", _nfi), "#03");
3509                         Assert.AreEqual ("1.15", d.ToString ("G4", _nfi), "#04");
3510                         Assert.AreEqual ("1.15", d.ToString ("G5", _nfi), "#05");
3511                         Assert.AreEqual ("1.15", d.ToString ("G6", _nfi), "#06");
3512                         Assert.AreEqual ("1.15", d.ToString ("G7", _nfi), "#07");
3513                         Assert.AreEqual ("1.15", d.ToString ("G8", _nfi), "#08");
3514                         Assert.AreEqual ("1.15", d.ToString ("G9", _nfi), "#09");
3515                         Assert.AreEqual ("1.15", d.ToString ("G10", _nfi), "#10");
3516                         Assert.AreEqual ("1.15", d.ToString ("G11", _nfi), "#11");
3517                         Assert.AreEqual ("1.15", d.ToString ("G12", _nfi), "#12");
3518                         Assert.AreEqual ("1.15", d.ToString ("G13", _nfi), "#13");
3519                         Assert.AreEqual ("1.15", d.ToString ("G14", _nfi), "#14");
3520                         Assert.AreEqual ("1.15", d.ToString ("G15", _nfi), "#15");
3521                         Assert.AreEqual ("1.15", d.ToString ("G16", _nfi), "#16");
3522                         Assert.AreEqual ("1.1499999999999999", d.ToString ("G17", _nfi), "#17");
3523                 }
3524
3525                 [Test]
3526                 public void Test13024 ()
3527                 {
3528                         Assert.AreEqual ("1.1", 1.05.ToString ("G2", _nfi), "#01");
3529                         Assert.AreEqual ("1.2", 1.15.ToString ("G2", _nfi), "#02");
3530                         Assert.AreEqual ("1.3", 1.25.ToString ("G2", _nfi), "#03");
3531                         Assert.AreEqual ("1.4", 1.35.ToString ("G2", _nfi), "#04");
3532                         Assert.AreEqual ("1.5", 1.45.ToString ("G2", _nfi), "#05");
3533                         Assert.AreEqual ("1.6", 1.55.ToString ("G2", _nfi), "#06");
3534                         Assert.AreEqual ("1.7", 1.65.ToString ("G2", _nfi), "#07");
3535                         Assert.AreEqual ("1.8", 1.75.ToString ("G2", _nfi), "#08");
3536                         Assert.AreEqual ("1.9", 1.85.ToString ("G2", _nfi), "#09");
3537                         Assert.AreEqual ("2", 1.95.ToString ("G2", _nfi), "#10");
3538                 }
3539
3540                 [Test]
3541                 public void Test13025 ()
3542                 {
3543                         Assert.AreEqual ("10", 10.05.ToString ("G2", _nfi), "#01");
3544                         Assert.AreEqual ("10", 10.15.ToString ("G2", _nfi), "#02");
3545                         Assert.AreEqual ("10", 10.25.ToString ("G2", _nfi), "#03");
3546                         Assert.AreEqual ("10", 10.35.ToString ("G2", _nfi), "#04");
3547                         Assert.AreEqual ("10", 10.45.ToString ("G2", _nfi), "#05");
3548                         Assert.AreEqual ("11", 10.55.ToString ("G2", _nfi), "#06");
3549                         Assert.AreEqual ("11", 10.65.ToString ("G2", _nfi), "#07");
3550                         Assert.AreEqual ("11", 10.75.ToString ("G2", _nfi), "#08");
3551                         Assert.AreEqual ("11", 10.85.ToString ("G2", _nfi), "#09");
3552                         Assert.AreEqual ("11", 10.95.ToString ("G2", _nfi), "#10");
3553                 }
3554
3555                 [Test]
3556                 public void Test13026 ()
3557                 {
3558                         Assert.AreEqual ("1.00000000000001", 1.000000000000005.ToString ("G15", _nfi), "#01");
3559                         Assert.AreEqual ("1.00000000000002", 1.000000000000015.ToString ("G15", _nfi), "#02");
3560                         Assert.AreEqual ("1.00000000000003", 1.000000000000025.ToString ("G15", _nfi), "#03");
3561                         Assert.AreEqual ("1.00000000000004", 1.000000000000035.ToString ("G15", _nfi), "#04");
3562                         Assert.AreEqual ("1.00000000000005", 1.000000000000045.ToString ("G15", _nfi), "#05");
3563                         Assert.AreEqual ("1.00000000000006", 1.000000000000055.ToString ("G15", _nfi), "#06");
3564                         Assert.AreEqual ("1.00000000000007", 1.000000000000065.ToString ("G15", _nfi), "#07");
3565                         Assert.AreEqual ("1.00000000000008", 1.000000000000075.ToString ("G15", _nfi), "#08");
3566                         Assert.AreEqual ("1.00000000000009", 1.000000000000085.ToString ("G15", _nfi), "#09");
3567                         Assert.AreEqual ("1.0000000000001", 1.000000000000095.ToString ("G15", _nfi), "#10");
3568                 }
3569
3570                 [Test]
3571                 public void Test13027 ()
3572                 {
3573                         Assert.AreEqual ("1", 1.0000000000000005.ToString ("G16", _nfi), "#01");
3574                         Assert.AreEqual ("1.000000000000002", 1.0000000000000015.ToString ("G16", _nfi), "#02");
3575                         Assert.AreEqual ("1.000000000000002", 1.0000000000000025.ToString ("G16", _nfi), "#03");
3576                         Assert.AreEqual ("1.000000000000004", 1.0000000000000035.ToString ("G16", _nfi), "#04");
3577                         Assert.AreEqual ("1.000000000000004", 1.0000000000000045.ToString ("G16", _nfi), "#05");
3578                         Assert.AreEqual ("1.000000000000006", 1.0000000000000055.ToString ("G16", _nfi), "#06");
3579                         Assert.AreEqual ("1.000000000000006", 1.0000000000000065.ToString ("G16", _nfi), "#07");
3580                         Assert.AreEqual ("1.000000000000008", 1.0000000000000075.ToString ("G16", _nfi), "#08");
3581                         Assert.AreEqual ("1.000000000000008", 1.0000000000000085.ToString ("G16", _nfi), "#09");
3582                         Assert.AreEqual ("1.00000000000001", 1.0000000000000095.ToString ("G16", _nfi), "#10");
3583                 }
3584
3585                 [Test]
3586                 public void Test13028 ()
3587                 {
3588                         Assert.AreEqual ("1", 1.00000000000000005.ToString ("G17", _nfi), "#01");
3589                         Assert.AreEqual ("1.0000000000000002", 1.00000000000000015.ToString ("G17", _nfi), "#02");
3590                         Assert.AreEqual ("1.0000000000000002", 1.00000000000000025.ToString ("G17", _nfi), "#03");
3591                         Assert.AreEqual ("1.0000000000000004", 1.00000000000000035.ToString ("G17", _nfi), "#04");
3592                         Assert.AreEqual ("1.0000000000000004", 1.00000000000000045.ToString ("G17", _nfi), "#05");
3593                         Assert.AreEqual ("1.0000000000000004", 1.00000000000000055.ToString ("G17", _nfi), "#06");
3594                         Assert.AreEqual ("1.0000000000000007", 1.00000000000000065.ToString ("G17", _nfi), "#07");
3595                         Assert.AreEqual ("1.0000000000000007", 1.00000000000000075.ToString ("G17", _nfi), "#08");
3596                         Assert.AreEqual ("1.0000000000000009", 1.00000000000000085.ToString ("G17", _nfi), "#09");
3597                         Assert.AreEqual ("1.0000000000000009", 1.00000000000000095.ToString ("G17", _nfi), "#10");
3598                 }
3599
3600                 [Test]
3601                 public void Test13029 ()
3602                 {
3603                         Assert.AreEqual ("1", 1.000000000000000005.ToString ("G18", _nfi), "#01");
3604                         Assert.AreEqual ("1", 1.000000000000000015.ToString ("G18", _nfi), "#02");
3605                         Assert.AreEqual ("1", 1.000000000000000025.ToString ("G18", _nfi), "#03");
3606                         Assert.AreEqual ("1", 1.000000000000000035.ToString ("G18", _nfi), "#04");
3607                         Assert.AreEqual ("1", 1.000000000000000045.ToString ("G18", _nfi), "#05");
3608                         Assert.AreEqual ("1", 1.000000000000000055.ToString ("G18", _nfi), "#06");
3609                         Assert.AreEqual ("1", 1.000000000000000065.ToString ("G18", _nfi), "#07");
3610                         Assert.AreEqual ("1", 1.000000000000000075.ToString ("G18", _nfi), "#08");
3611                         Assert.AreEqual ("1", 1.000000000000000085.ToString ("G18", _nfi), "#09");
3612                         Assert.AreEqual ("1", 1.000000000000000095.ToString ("G18", _nfi), "#10");
3613                 }
3614
3615                 [Test]
3616                 public void Test13030 ()
3617                 {
3618                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3619                         nfi.NumberDecimalSeparator = "#";
3620                         Assert.AreEqual ("-99999999#9", (-99999999.9).ToString ("G", nfi), "#01");
3621                 }
3622
3623                 [Test]
3624                 public void Test13031 ()
3625                 {
3626                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3627                         nfi.NegativeSign = "+";
3628                         nfi.PositiveSign = "-";
3629
3630                         Assert.AreEqual ("1", 1.0.ToString ("G", nfi), "#01");
3631                         Assert.AreEqual ("0", 0.0.ToString ("G", nfi), "#02");
3632                         Assert.AreEqual ("+1", (-1.0).ToString ("G", nfi), "#03");
3633                 }
3634
3635                 [Test]
3636                 public void Test13032 ()
3637                 {
3638                         Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("G99", _nfi) , "#01");
3639                         Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("G99", _nfi) , "#02");
3640                         Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("G99", _nfi) , "#03");
3641                 }
3642
3643                 [Test]
3644                 public void Test13033 ()
3645                 {
3646                         Assert.AreEqual ("0.0001", 0.0001.ToString ("G", _nfi), "#01");
3647                         Assert.AreEqual ("1E-05", 0.00001.ToString ("G", _nfi), "#02");
3648                         Assert.AreEqual ("0.0001", 0.0001.ToString ("G0", _nfi), "#03");
3649                         Assert.AreEqual ("1E-05", 0.00001.ToString ("G0", _nfi), "#04");
3650                         Assert.AreEqual ("100000000000000", 100000000000000.0.ToString ("G", _nfi), "#05");
3651                         Assert.AreEqual ("1E+15", 1000000000000000.0.ToString ("G", _nfi), "#06");
3652                         Assert.AreEqual ("1000000000000000", 1000000000000000.0.ToString ("G16", _nfi), "#07");
3653                 }
3654
3655                 // Test14000- Double and N
3656                 [Test]
3657                 public void Test14000 ()
3658                 {
3659                         Assert.AreEqual ("0.00", 0.0.ToString ("N", _nfi), "#01");
3660                         Assert.AreEqual ("0.00", 0.0.ToString ("n", _nfi), "#02");
3661                         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");
3662                         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");
3663                         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");
3664                         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");
3665                 }
3666
3667                 [Test]
3668                 public void Test14001 ()
3669                 {
3670                         Assert.AreEqual ("N ", 0.0.ToString ("N ", _nfi), "#01");
3671                         Assert.AreEqual (" N", 0.0.ToString (" N", _nfi), "#02");
3672                         Assert.AreEqual (" N ", 0.0.ToString (" N ", _nfi), "#03");
3673                 }
3674
3675                 [Test]
3676                 public void Test14002 ()
3677                 {
3678                         Assert.AreEqual ("-N ", (-1.0).ToString ("N ", _nfi), "#01");
3679                         Assert.AreEqual ("- N", (-1.0).ToString (" N", _nfi), "#02");
3680                         Assert.AreEqual ("- N ", (-1.0).ToString (" N ", _nfi), "#03");
3681                 }
3682
3683                 [Test]
3684                 public void Test14003 ()
3685                 {
3686                         Assert.AreEqual ("0", 0.0.ToString ("N0", _nfi), "#01");
3687                         Assert.AreEqual ("0.0000000000000000", 0.0.ToString ("N16", _nfi), "#02");
3688                         Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("N17", _nfi), "#03");
3689                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("N99", _nfi), "#04");
3690                         Assert.AreEqual ("N100", 0.0.ToString ("N100", _nfi), "#05");
3691                 }
3692
3693                 [Test]
3694                 public void Test14004 ()
3695                 {
3696                         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");
3697                         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");
3698                         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");
3699                         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");
3700                         Assert.AreEqual ("N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N100", _nfi), "#05");
3701                 }
3702
3703                 [Test]
3704                 public void Test14005 ()
3705                 {
3706                         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");
3707                         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");
3708                         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");
3709                         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");
3710                         Assert.AreEqual ("-N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N100", _nfi), "#05");
3711                 }
3712
3713                 [Test]
3714                 public void Test14006 ()
3715                 {
3716                         Assert.AreEqual ("NF", 0.0.ToString ("NF", _nfi), "#01");
3717                         Assert.AreEqual ("N0F", 0.0.ToString ("N0F", _nfi), "#02");
3718                         Assert.AreEqual ("N0xF", 0.0.ToString ("N0xF", _nfi), "#03");
3719                 }
3720
3721                 [Test]
3722                 public void Test14007 ()
3723                 {
3724                         Assert.AreEqual ("NF", Double.MaxValue.ToString ("NF", _nfi), "#01");
3725                         Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("N0F", _nfi), "#02");
3726                         Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("N0xF", _nfi), "#03");
3727                 }
3728
3729                 [Test]
3730                 public void Test14008 ()
3731                 {
3732                         Assert.AreEqual ("-NF", Double.MinValue.ToString ("NF", _nfi), "#01");
3733                         Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("N0F", _nfi), "#02");
3734                         Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("N0xF", _nfi), "#03");
3735                 }
3736
3737                 [Test]
3738                 public void Test14009 ()
3739                 {
3740                         Assert.AreEqual ("0.00000000000000000", 0.0.ToString ("N0000000000000000000000000000000000000017", _nfi), "#01");
3741                         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");
3742                         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");
3743                 }
3744
3745                 [Test]
3746                 public void Test14010 ()
3747                 {
3748                         Assert.AreEqual ("+N", 0.0.ToString ("+N", _nfi), "#01");
3749                         Assert.AreEqual ("N+", 0.0.ToString ("N+", _nfi), "#02");
3750                         Assert.AreEqual ("+N+", 0.0.ToString ("+N+", _nfi), "#03");
3751                 }
3752
3753                 [Test]
3754                 public void Test14011 ()
3755                 {
3756                         Assert.AreEqual ("+N", Double.MaxValue.ToString ("+N", _nfi), "#01");
3757                         Assert.AreEqual ("N+", Double.MaxValue.ToString ("N+", _nfi), "#02");
3758                         Assert.AreEqual ("+N+", Double.MaxValue.ToString ("+N+", _nfi), "#03");
3759                 }
3760
3761                 [Test]
3762                 public void Test14012 ()
3763                 {
3764                         Assert.AreEqual ("-+N", Double.MinValue.ToString ("+N", _nfi), "#01");
3765                         Assert.AreEqual ("-N+", Double.MinValue.ToString ("N+", _nfi), "#02");
3766                         Assert.AreEqual ("-+N+", Double.MinValue.ToString ("+N+", _nfi), "#03");
3767                 }
3768
3769                 [Test]
3770                 public void Test14013 ()
3771                 {
3772                         Assert.AreEqual ("-N", 0.0.ToString ("-N", _nfi), "#01");
3773                         Assert.AreEqual ("N-", 0.0.ToString ("N-", _nfi), "#02");
3774                         Assert.AreEqual ("-N-", 0.0.ToString ("-N-", _nfi), "#03");
3775                 }
3776
3777                 [Test]
3778                 public void Test14014 ()
3779                 {
3780                         Assert.AreEqual ("-N", Double.MaxValue.ToString ("-N", _nfi), "#01");
3781                         Assert.AreEqual ("N-", Double.MaxValue.ToString ("N-", _nfi), "#02");
3782                         Assert.AreEqual ("-N-", Double.MaxValue.ToString ("-N-", _nfi), "#03");
3783                 }
3784
3785                 [Test]
3786                 public void Test14015 ()
3787                 {
3788                         Assert.AreEqual ("--N", Double.MinValue.ToString ("-N", _nfi), "#01");
3789                         Assert.AreEqual ("-N-", Double.MinValue.ToString ("N-", _nfi), "#02");
3790                         Assert.AreEqual ("--N-", Double.MinValue.ToString ("-N-", _nfi), "#03");
3791                 }
3792
3793                 [Test]
3794                 public void Test14016 ()
3795                 {
3796                         Assert.AreEqual ("N+0", 0.0.ToString ("N+0", _nfi), "#01");
3797                         Assert.AreEqual ("N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N+0", _nfi), "#02");
3798                         Assert.AreEqual ("-N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N+0", _nfi), "#03");
3799                 }
3800
3801                 [Test]
3802                 public void Test14017 ()
3803                 {
3804                         Assert.AreEqual ("N+9", 0.0.ToString ("N+9", _nfi), "#01");
3805                         Assert.AreEqual ("N+9", Double.MaxValue.ToString ("N+9", _nfi), "#02");
3806                         Assert.AreEqual ("-N+9", Double.MinValue.ToString ("N+9", _nfi), "#03");
3807                 }
3808
3809                 [Test]
3810                 public void Test14018 ()
3811                 {
3812                         Assert.AreEqual ("N-9", 0.0.ToString ("N-9", _nfi), "#01");
3813                         Assert.AreEqual ("N-9", Double.MaxValue.ToString ("N-9", _nfi), "#02");
3814                         Assert.AreEqual ("-N-9", Double.MinValue.ToString ("N-9", _nfi), "#03");
3815                 }
3816
3817                 [Test]
3818                 public void Test14019 ()
3819                 {
3820                         Assert.AreEqual ("N0", 0.0.ToString ("N0,", _nfi), "#01");
3821                         Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0,", _nfi), "#02");
3822                         Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0,", _nfi), "#03");
3823                 }
3824
3825                 [Test]
3826                 public void Test14020 ()
3827                 {
3828                         Assert.AreEqual ("N0", 0.0.ToString ("N0.", _nfi), "#01");
3829                         Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0.", _nfi), "#02");
3830                         Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0.", _nfi), "#03");
3831                 }
3832
3833                 [Test]
3834                 public void Test14021 ()
3835                 {
3836                         Assert.AreEqual ("N0.0", 0.0.ToString ("N0.0", _nfi), "#01");
3837                         Assert.AreEqual ("N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("N0.0", _nfi), "#02");
3838                         Assert.AreEqual ("-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("N0.0", _nfi), "#03");
3839                 }
3840
3841                 [Test]
3842                 public void Test14022 ()
3843                 {
3844                         Assert.AreEqual ("N09", 0.0.ToString ("N0.9", _nfi), "#01");
3845                         Assert.AreEqual ("N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("N0.9", _nfi), "#02");
3846                         Assert.AreEqual ("-N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("N0.9", _nfi), "#03");
3847                 }
3848
3849                 [Test]
3850                 public void Test14023 ()
3851                 {
3852                         Assert.AreEqual ("999.1", 999.05.ToString ("N1", _nfi), "#01");
3853                         Assert.AreEqual ("999.2", 999.15.ToString ("N1", _nfi), "#02");
3854                         Assert.AreEqual ("999.3", 999.25.ToString ("N1", _nfi), "#03");
3855                         Assert.AreEqual ("999.4", 999.35.ToString ("N1", _nfi), "#04");
3856                         Assert.AreEqual ("999.5", 999.45.ToString ("N1", _nfi), "#05");
3857                         Assert.AreEqual ("999.6", 999.55.ToString ("N1", _nfi), "#06");
3858                         Assert.AreEqual ("999.7", 999.65.ToString ("N1", _nfi), "#07");
3859                         Assert.AreEqual ("999.8", 999.75.ToString ("N1", _nfi), "#08");
3860                         Assert.AreEqual ("999.9", 999.85.ToString ("N1", _nfi), "#09");
3861                         Assert.AreEqual ("1,000.0", 999.95.ToString ("N1", _nfi), "#10");
3862                 }
3863
3864                 [Test]
3865                 public void Test14024 ()
3866                 {
3867                         Assert.AreEqual ("999.91", 999.905.ToString ("N2", _nfi), "#01");
3868                         Assert.AreEqual ("999.92", 999.915.ToString ("N2", _nfi), "#02");
3869                         Assert.AreEqual ("999.93", 999.925.ToString ("N2", _nfi), "#03");
3870                         Assert.AreEqual ("999.94", 999.935.ToString ("N2", _nfi), "#04");
3871                         Assert.AreEqual ("999.95", 999.945.ToString ("N2", _nfi), "#05");
3872                         Assert.AreEqual ("999.96", 999.955.ToString ("N2", _nfi), "#06");
3873                         Assert.AreEqual ("999.97", 999.965.ToString ("N2", _nfi), "#07");
3874                         Assert.AreEqual ("999.98", 999.975.ToString ("N2", _nfi), "#08");
3875                         Assert.AreEqual ("999.99", 999.985.ToString ("N2", _nfi), "#09");
3876                         Assert.AreEqual ("1,000.00", 999.995.ToString ("N2", _nfi), "#10");
3877                 }
3878
3879                 [Test]
3880                 public void Test14025 ()
3881                 {
3882                         Assert.AreEqual ("999.99999999991", 999.999999999905.ToString ("N11", _nfi), "#01");
3883                         Assert.AreEqual ("999.99999999992", 999.999999999915.ToString ("N11", _nfi), "#02");
3884                         Assert.AreEqual ("999.99999999993", 999.999999999925.ToString ("N11", _nfi), "#03");
3885                         Assert.AreEqual ("999.99999999994", 999.999999999935.ToString ("N11", _nfi), "#04");
3886                         Assert.AreEqual ("999.99999999995", 999.999999999945.ToString ("N11", _nfi), "#05");
3887                         Assert.AreEqual ("999.99999999996", 999.999999999955.ToString ("N11", _nfi), "#06");
3888                         Assert.AreEqual ("999.99999999997", 999.999999999965.ToString ("N11", _nfi), "#07");
3889                         Assert.AreEqual ("999.99999999998", 999.999999999975.ToString ("N11", _nfi), "#08");
3890                         Assert.AreEqual ("999.99999999999", 999.999999999985.ToString ("N11", _nfi), "#09");
3891                         Assert.AreEqual ("1,000.00000000000", 999.999999999995.ToString ("N11", _nfi), "#10");
3892                 }
3893
3894                 [Test]
3895                 public void Test14026 ()
3896                 {
3897                         Assert.AreEqual ("999.999999999990", 999.9999999999905.ToString ("N12", _nfi), "#01");
3898                         Assert.AreEqual ("999.999999999991", 999.9999999999915.ToString ("N12", _nfi), "#02");
3899                         Assert.AreEqual ("999.999999999993", 999.9999999999925.ToString ("N12", _nfi), "#03");
3900                         Assert.AreEqual ("999.999999999994", 999.9999999999935.ToString ("N12", _nfi), "#04");
3901                         Assert.AreEqual ("999.999999999995", 999.9999999999945.ToString ("N12", _nfi), "#05");
3902                         Assert.AreEqual ("999.999999999995", 999.9999999999955.ToString ("N12", _nfi), "#06");
3903                         Assert.AreEqual ("999.999999999996", 999.9999999999965.ToString ("N12", _nfi), "#07");
3904                         Assert.AreEqual ("999.999999999998", 999.9999999999975.ToString ("N12", _nfi), "#08");
3905                         Assert.AreEqual ("999.999999999999", 999.9999999999985.ToString ("N12", _nfi), "#09");
3906                         Assert.AreEqual ("1,000.000000000000", 999.9999999999995.ToString ("N12", _nfi), "#10");
3907                 }
3908
3909                 [Test]
3910                 public void Test14027 ()
3911                 {
3912                         Assert.AreEqual ("999.9999999999990", 999.99999999999905.ToString ("N13", _nfi), "#01");
3913                         Assert.AreEqual ("999.9999999999990", 999.99999999999915.ToString ("N13", _nfi), "#02");
3914                         Assert.AreEqual ("999.9999999999990", 999.99999999999925.ToString ("N13", _nfi), "#03");
3915                         Assert.AreEqual ("999.9999999999990", 999.99999999999935.ToString ("N13", _nfi), "#04");
3916                         Assert.AreEqual ("999.9999999999990", 999.99999999999945.ToString ("N13", _nfi), "#05");
3917                         Assert.AreEqual ("1,000.0000000000000", 999.99999999999955.ToString ("N13", _nfi), "#06");
3918                         Assert.AreEqual ("1,000.0000000000000", 999.99999999999965.ToString ("N13", _nfi), "#07");
3919                         Assert.AreEqual ("1,000.0000000000000", 999.99999999999975.ToString ("N13", _nfi), "#08");
3920                         Assert.AreEqual ("1,000.0000000000000", 999.99999999999985.ToString ("N13", _nfi), "#09");
3921                         Assert.AreEqual ("1,000.0000000000000", 999.99999999999995.ToString ("N13", _nfi), "#10");
3922                 }
3923
3924                 [Test]
3925                 public void Test14028 ()
3926                 {
3927                         Assert.AreEqual ("1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi), "#01");
3928                         Assert.AreEqual ("1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi), "#02");
3929                         Assert.AreEqual ("1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi), "#03");
3930                         Assert.AreEqual ("1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi), "#04");
3931                         Assert.AreEqual ("1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi), "#05");
3932                         Assert.AreEqual ("1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi), "#06");
3933                         Assert.AreEqual ("N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100", _nfi), "#07");
3934                 }
3935
3936                 [Test]
3937                 public void Test14029 ()
3938                 {
3939                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3940                         nfi.NumberDecimalSeparator = "#";
3941                         Assert.AreEqual ("-99,999,999#90", (-99999999.9).ToString ("N", nfi), "#01");
3942                 }
3943
3944                 [Test]
3945                 public void Test14030 ()
3946                 {
3947                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3948                         nfi.NegativeSign = "+";
3949                         nfi.PositiveSign = "-";
3950
3951                         Assert.AreEqual ("1,000.00", 1000.0.ToString ("N", nfi), "#01");
3952                         Assert.AreEqual ("0.00", 0.0.ToString ("N", nfi), "#02");
3953                         Assert.AreEqual ("+1,000.00", (-1000.0).ToString ("N", nfi), "#03");
3954                 }
3955
3956                 [Test]
3957                 public void Test14031 ()
3958                 {
3959                         Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi) , "#01");
3960                         Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi) , "#02");
3961                         Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("N99", _nfi) , "#03");
3962                 }
3963
3964                 // Test15000- Double and P
3965                 [Test]
3966                 public void Test15000 ()
3967                 {
3968                         Assert.AreEqual ("0.00 %", 0.0.ToString ("P", _nfi), "#01");
3969                         Assert.AreEqual ("0.00 %", 0.0.ToString ("p", _nfi), "#02");
3970                         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");
3971                         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");
3972                         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");
3973                         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");
3974                 }
3975
3976                 [Test]
3977                 public void Test15001 ()
3978                 {
3979                         Assert.AreEqual ("P ", 0.0.ToString ("P ", _nfi), "#01");
3980                         Assert.AreEqual (" P", 0.0.ToString (" P", _nfi), "#02");
3981                         Assert.AreEqual (" P ", 0.0.ToString (" P ", _nfi), "#03");
3982                 }
3983
3984                 [Test]
3985                 public void Test15002 ()
3986                 {
3987                         Assert.AreEqual ("-P ", (-1.0).ToString ("P ", _nfi), "#01");
3988                         Assert.AreEqual ("- P", (-1.0).ToString (" P", _nfi), "#02");
3989                         Assert.AreEqual ("- P ", (-1.0).ToString (" P ", _nfi), "#03");
3990                 }
3991
3992                 [Test]
3993                 public void Test15003 ()
3994                 {
3995                         Assert.AreEqual ("0 %", 0.0.ToString ("P0", _nfi), "#01");
3996                         Assert.AreEqual ("0.0000000000000000 %", 0.0.ToString ("P16", _nfi), "#02");
3997                         Assert.AreEqual ("0.00000000000000000 %", 0.0.ToString ("P17", _nfi), "#03");
3998                         Assert.AreEqual ("0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.0.ToString ("P99", _nfi), "#04");
3999                         Assert.AreEqual ("P100", 0.0.ToString ("P100", _nfi), "#05");
4000                 }
4001
4002                 [Test]
4003                 public void Test15004 ()
4004                 {
4005                         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");
4006                         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");
4007                         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");
4008                         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");
4009                         Assert.AreEqual ("P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi), "#05");
4010                 }
4011
4012                 [Test]
4013                 public void Test15005 ()
4014                 {
4015                         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");
4016                         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");
4017                         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");
4018                         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");
4019                         Assert.AreEqual ("P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi), "#05");
4020                 }
4021
4022                 [Test]
4023                 public void Test15006 ()
4024                 {
4025                         Assert.AreEqual ("PF", 0.0.ToString ("PF", _nfi), "#01");
4026                         Assert.AreEqual ("P0F", 0.0.ToString ("P0F", _nfi), "#02");
4027                         Assert.AreEqual ("P0xF", 0.0.ToString ("P0xF", _nfi), "#03");
4028                 }
4029
4030                 [Test]
4031                 public void Test15007 ()
4032                 {
4033                         Assert.AreEqual ("PF", Double.MaxValue.ToString ("PF", _nfi), "#01");
4034                         Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("P0F", _nfi), "#02");
4035                         Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("P0xF", _nfi), "#03");
4036                 }
4037
4038                 [Test]
4039                 public void Test15008 ()
4040                 {
4041                         Assert.AreEqual ("-PF", Double.MinValue.ToString ("PF", _nfi), "#01");
4042                         Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("P0F", _nfi), "#02");
4043                         Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("P0xF", _nfi), "#03");
4044                 }
4045
4046                 [Test]
4047                 public void Test15009 ()
4048                 {
4049                         Assert.AreEqual ("0.00000000000000000 %", 0.0.ToString ("P0000000000000000000000000000000000000017", _nfi), "#01");
4050                         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");
4051                         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");
4052                 }
4053
4054                 [Test]
4055                 public void Test15010 ()
4056                 {
4057                         Assert.AreEqual ("+P", 0.0.ToString ("+P", _nfi), "#01");
4058                         Assert.AreEqual ("P+", 0.0.ToString ("P+", _nfi), "#02");
4059                         Assert.AreEqual ("+P+", 0.0.ToString ("+P+", _nfi), "#03");
4060                 }
4061
4062                 [Test]
4063                 public void Test15011 ()
4064                 {
4065                         Assert.AreEqual ("+P", Double.MaxValue.ToString ("+P", _nfi), "#01");
4066                         Assert.AreEqual ("P+", Double.MaxValue.ToString ("P+", _nfi), "#02");
4067                         Assert.AreEqual ("+P+", Double.MaxValue.ToString ("+P+", _nfi), "#03");
4068                 }
4069
4070                 [Test]
4071                 public void Test15012 ()
4072                 {
4073                         Assert.AreEqual ("-+P", Double.MinValue.ToString ("+P", _nfi), "#01");
4074                         Assert.AreEqual ("-P+", Double.MinValue.ToString ("P+", _nfi), "#02");
4075                         Assert.AreEqual ("-+P+", Double.MinValue.ToString ("+P+", _nfi), "#03");
4076                 }
4077
4078                 [Test]
4079                 public void Test15013 ()
4080                 {
4081                         Assert.AreEqual ("-P", 0.0.ToString ("-P", _nfi), "#01");
4082                         Assert.AreEqual ("P-", 0.0.ToString ("P-", _nfi), "#02");
4083                         Assert.AreEqual ("-P-", 0.0.ToString ("-P-", _nfi), "#03");
4084                 }
4085
4086                 [Test]
4087                 public void Test15014 ()
4088                 {
4089                         Assert.AreEqual ("-P", Double.MaxValue.ToString ("-P", _nfi), "#01");
4090                         Assert.AreEqual ("P-", Double.MaxValue.ToString ("P-", _nfi), "#02");
4091                         Assert.AreEqual ("-P-", Double.MaxValue.ToString ("-P-", _nfi), "#03");
4092                 }
4093
4094                 [Test]
4095                 public void Test15015 ()
4096                 {
4097                         Assert.AreEqual ("--P", Double.MinValue.ToString ("-P", _nfi), "#01");
4098                         Assert.AreEqual ("-P-", Double.MinValue.ToString ("P-", _nfi), "#02");
4099                         Assert.AreEqual ("--P-", Double.MinValue.ToString ("-P-", _nfi), "#03");
4100                 }
4101
4102                 [Test]
4103                 public void Test15016 ()
4104                 {
4105                         Assert.AreEqual ("P+0", 0.0.ToString ("P+0", _nfi), "#01");
4106                         Assert.AreEqual ("P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P+0", _nfi), "#02");
4107                         Assert.AreEqual ("-P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P+0", _nfi), "#03");
4108                 }
4109
4110                 [Test]
4111                 public void Test15017 ()
4112                 {
4113                         Assert.AreEqual ("P+9", 0.0.ToString ("P+9", _nfi), "#01");
4114                         Assert.AreEqual ("P+9", Double.MaxValue.ToString ("P+9", _nfi), "#02");
4115                         Assert.AreEqual ("-P+9", Double.MinValue.ToString ("P+9", _nfi), "#03");
4116                 }
4117
4118                 [Test]
4119                 public void Test15018 ()
4120                 {
4121                         Assert.AreEqual ("P-9", 0.0.ToString ("P-9", _nfi), "#01");
4122                         Assert.AreEqual ("P-9", Double.MaxValue.ToString ("P-9", _nfi), "#02");
4123                         Assert.AreEqual ("-P-9", Double.MinValue.ToString ("P-9", _nfi), "#03");
4124                 }
4125
4126                 [Test]
4127                 public void Test15019 ()
4128                 {
4129                         Assert.AreEqual ("P0", 0.0.ToString ("P0,", _nfi), "#01");
4130                         Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0,", _nfi), "#02");
4131                         Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0,", _nfi), "#03");
4132                 }
4133
4134                 [Test]
4135                 public void Test15020 ()
4136                 {
4137                         Assert.AreEqual ("P0", 0.0.ToString ("P0.", _nfi), "#01");
4138                         Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0.", _nfi), "#02");
4139                         Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0.", _nfi), "#03");
4140                 }
4141
4142                 [Test]
4143                 public void Test15021 ()
4144                 {
4145                         Assert.AreEqual ("P0.0", 0.0.ToString ("P0.0", _nfi), "#01");
4146                         Assert.AreEqual ("P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("P0.0", _nfi), "#02");
4147                         Assert.AreEqual ("-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("P0.0", _nfi), "#03");
4148                 }
4149
4150                 [Test]
4151                 public void Test15022 ()
4152                 {
4153                         Assert.AreEqual ("P09", 0.0.ToString ("P0.9", _nfi), "#01");
4154                         Assert.AreEqual ("P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("P0.9", _nfi), "#02");
4155                         Assert.AreEqual ("-P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("P0.9", _nfi), "#03");
4156                 }
4157
4158                 [Test]
4159                 public void Test15023 ()
4160                 {
4161                         Assert.AreEqual ("999.1 %", 9.9905.ToString ("P1", _nfi), "#01");
4162                         Assert.AreEqual ("999.2 %", 9.9915.ToString ("P1", _nfi), "#02");
4163                         Assert.AreEqual ("999.3 %", 9.9925.ToString ("P1", _nfi), "#03");
4164                         Assert.AreEqual ("999.4 %", 9.9935.ToString ("P1", _nfi), "#04");
4165                         Assert.AreEqual ("999.5 %", 9.9945.ToString ("P1", _nfi), "#05");
4166                         Assert.AreEqual ("999.6 %", 9.9955.ToString ("P1", _nfi), "#06");
4167                         Assert.AreEqual ("999.7 %", 9.9965.ToString ("P1", _nfi), "#07");
4168                         Assert.AreEqual ("999.8 %", 9.9975.ToString ("P1", _nfi), "#08");
4169                         Assert.AreEqual ("999.9 %", 9.9985.ToString ("P1", _nfi), "#09");
4170                         Assert.AreEqual ("1,000.0 %", 9.9995.ToString ("P1", _nfi), "#10");
4171                 }
4172
4173                 [Test]
4174                 public void Test15024 ()
4175                 {
4176                         Assert.AreEqual ("999.91 %", 9.99905.ToString ("P2", _nfi), "#01");
4177                         Assert.AreEqual ("999.92 %", 9.99915.ToString ("P2", _nfi), "#02");
4178                         Assert.AreEqual ("999.93 %", 9.99925.ToString ("P2", _nfi), "#03");
4179                         Assert.AreEqual ("999.94 %", 9.99935.ToString ("P2", _nfi), "#04");
4180                         Assert.AreEqual ("999.95 %", 9.99945.ToString ("P2", _nfi), "#05");
4181                         Assert.AreEqual ("999.96 %", 9.99955.ToString ("P2", _nfi), "#06");
4182                         Assert.AreEqual ("999.97 %", 9.99965.ToString ("P2", _nfi), "#07");
4183                         Assert.AreEqual ("999.98 %", 9.99975.ToString ("P2", _nfi), "#08");
4184                         Assert.AreEqual ("999.99 %", 9.99985.ToString ("P2", _nfi), "#09");
4185                         Assert.AreEqual ("1,000.00 %", 9.99995.ToString ("P2", _nfi), "#10");
4186                 }
4187
4188                 [Test]
4189                 public void Test15025 ()
4190                 {
4191                         Assert.AreEqual ("999.99999999991 %", 9.99999999999905.ToString ("P11", _nfi), "#01");
4192                         Assert.AreEqual ("999.99999999992 %", 9.99999999999915.ToString ("P11", _nfi), "#02");
4193                         Assert.AreEqual ("999.99999999993 %", 9.99999999999925.ToString ("P11", _nfi), "#03");
4194                         Assert.AreEqual ("999.99999999994 %", 9.99999999999935.ToString ("P11", _nfi), "#04");
4195                         Assert.AreEqual ("999.99999999995 %", 9.99999999999945.ToString ("P11", _nfi), "#05");
4196                         Assert.AreEqual ("999.99999999996 %", 9.99999999999955.ToString ("P11", _nfi), "#06");
4197                         Assert.AreEqual ("999.99999999997 %", 9.99999999999965.ToString ("P11", _nfi), "#07");
4198                         Assert.AreEqual ("999.99999999998 %", 9.99999999999975.ToString ("P11", _nfi), "#08");
4199                         Assert.AreEqual ("999.99999999999 %", 9.99999999999985.ToString ("P11", _nfi), "#09");
4200                         Assert.AreEqual ("1,000.00000000000 %", 9.99999999999995.ToString ("P11", _nfi), "#10");
4201                 }
4202
4203                 [Test]
4204                 public void Test15026 ()
4205                 {
4206                         Assert.AreEqual ("999.999999999991 %", 9.999999999999905.ToString ("P12", _nfi), "#01");
4207                         Assert.AreEqual ("999.999999999991 %", 9.999999999999915.ToString ("P12", _nfi), "#02");
4208                         Assert.AreEqual ("999.999999999993 %", 9.999999999999925.ToString ("P12", _nfi), "#03");
4209                         Assert.AreEqual ("999.999999999993 %", 9.999999999999935.ToString ("P12", _nfi), "#04");
4210                         Assert.AreEqual ("999.999999999994 %", 9.999999999999945.ToString ("P12", _nfi), "#05");
4211                         Assert.AreEqual ("999.999999999996 %", 9.999999999999955.ToString ("P12", _nfi), "#06");
4212                         Assert.AreEqual ("999.999999999996 %", 9.999999999999965.ToString ("P12", _nfi), "#07");
4213                         Assert.AreEqual ("999.999999999998 %", 9.999999999999975.ToString ("P12", _nfi), "#08");
4214                         Assert.AreEqual ("999.999999999999 %", 9.999999999999985.ToString ("P12", _nfi), "#09");
4215                         Assert.AreEqual ("999.999999999999 %", 9.999999999999995.ToString ("P12", _nfi), "#10");
4216                 }
4217
4218                 [Test]
4219                 public void Test15027 ()
4220                 {
4221                         Assert.AreEqual ("999.9999999999990 %", 9.9999999999999905.ToString ("P13", _nfi), "#01");
4222                         Assert.AreEqual ("999.9999999999990 %", 9.9999999999999915.ToString ("P13", _nfi), "#02");
4223                         Assert.AreEqual ("999.9999999999990 %", 9.9999999999999925.ToString ("P13", _nfi), "#03");
4224                         Assert.AreEqual ("999.9999999999990 %", 9.9999999999999935.ToString ("P13", _nfi), "#04");
4225                         Assert.AreEqual ("999.9999999999990 %", 9.9999999999999945.ToString ("P13", _nfi), "#05");
4226                         Assert.AreEqual ("999.9999999999990 %", 9.9999999999999955.ToString ("P13", _nfi), "#06");
4227                         Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999965.ToString ("P13", _nfi), "#07");
4228                         Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999975.ToString ("P13", _nfi), "#08");
4229                         Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999985.ToString ("P13", _nfi), "#09");
4230                         Assert.AreEqual ("1,000.0000000000000 %", 9.9999999999999995.ToString ("P13", _nfi), "#10");
4231                 }
4232
4233                 [Test]
4234                 public void Test15028 ()
4235                 {
4236                         Assert.AreEqual ("1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi), "#01");
4237                         Assert.AreEqual ("1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi), "#02");
4238                         Assert.AreEqual ("1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi), "#03");
4239                         Assert.AreEqual ("1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi), "#04");
4240                         Assert.AreEqual ("1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi), "#05");
4241                         Assert.AreEqual ("1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi), "#06");
4242                         Assert.AreEqual ("N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100"), "#07");
4243                 }
4244
4245                 [Test]
4246                 public void Test15029 ()
4247                 {
4248                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
4249                         nfi.PercentDecimalSeparator = "#";
4250                         Assert.AreEqual ("-9,999,999,990#00 %", (-99999999.9).ToString ("P", nfi), "#01");
4251                 }
4252
4253                 [Test]
4254                 public void Test15030 ()
4255                 {
4256                         NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
4257                         nfi.NegativeSign = "+";
4258                         nfi.PositiveSign = "-";
4259
4260                         Assert.AreEqual ("1,000.00 %", 10.0.ToString ("P", nfi), "#01");
4261                         Assert.AreEqual ("0.00 %", 0.0.ToString ("P", nfi), "#02");
4262                         Assert.AreEqual ("+1,000.00 %", (-10.0).ToString ("P", nfi), "#03");
4263                 }
4264
4265                 [Test]
4266                 public void Test15031 ()
4267                 {
4268                         Assert.AreEqual ("Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi) , "#01");
4269                         Assert.AreEqual ("-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi) , "#02");
4270                         Assert.AreEqual ("NaN", (0.0 / 0.0).ToString ("N99", _nfi) , "#03");
4271                 }
4272
4273                 // TestRoundtrip for double and single
4274                 [Test]
4275                 public void TestRoundtrip()
4276                 {
4277                         Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("R", _nfi), "#01");
4278                         Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("r", _nfi), "#02");
4279                         Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("R0", _nfi), "#03");
4280                         Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("r0", _nfi), "#04");
4281                         Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("R99", _nfi), "#05");
4282                         Assert.AreEqual ("1.2345678901234567", 1.2345678901234567890.ToString ("r99", _nfi), "#06");
4283                         Assert.AreEqual ("-1.7976931348623157E+308", Double.MinValue.ToString ("R"), "#07");
4284                         Assert.AreEqual ("1.7976931348623157E+308", Double.MaxValue.ToString ("R"), "#08");
4285                         Assert.AreEqual ("-1.7976931348623147E+308", (-1.7976931348623147E+308).ToString("R"), "#09");
4286                         Assert.AreEqual ("-3.40282347E+38", Single.MinValue.ToString("R"), "#10");
4287                         Assert.AreEqual ("3.40282347E+38", Single.MaxValue.ToString("R"), "#11");
4288                 }
4289
4290                 // Tests arithmetic overflow in double.ToString exposed by Bug #383531
4291                 [Test]
4292                 public void TestToStringOverflow()
4293                 {
4294                         // Test all the possible double exponents with the maximal mantissa
4295             long dblPattern = 0xfffffffffffff; // all 1s significand
4296
4297             for (long exp = 0; exp < 4096; exp++) {
4298                 double val = BitConverter.Int64BitsToDouble((long)(dblPattern | (exp << 52)));
4299                 string strRes = val.ToString("R", NumberFormatInfo.InvariantInfo);
4300                                 double rndTripVal = Double.Parse(strRes);
4301                                 Assert.AreEqual (val, rndTripVal, "Iter#" + exp);
4302             }
4303                 }
4304
4305                 // Test17000 - Double and X
4306                 [Test]
4307                 [ExpectedException (typeof (FormatException))]
4308                 public void Test17000 ()
4309                 {
4310                         Assert.AreEqual ("", 0.0.ToString ("X99", _nfi) , "#01");
4311                 }
4312         }
4313 }