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

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