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