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