2 // MonoTests.System.NumberFormatterTest
5 // akiramei (mei@work.email.ne.jp)
11 using System.Globalization;
12 using System.Threading;
15 using NUnit.Framework;
17 namespace MonoTests.System
20 public class NumberFormatterTest
22 CultureInfo old_culture;
23 NumberFormatInfo _nfi;
28 old_culture = Thread.CurrentThread.CurrentCulture;
29 Thread.CurrentThread.CurrentCulture = new CultureInfo ("en-US", false);
30 _nfi = NumberFormatInfo.InvariantInfo.Clone () as NumberFormatInfo;
34 public void TearDown ()
36 Thread.CurrentThread.CurrentCulture = old_culture;
39 // Test00000- Int32 and D
41 public void Test00000 ()
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");
52 public void Test00001 ()
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");
60 public void Test00002 ()
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");
68 public void Test00003 ()
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");
78 public void Test00004 ()
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");
88 public void Test00005 ()
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");
98 public void Test00006 ()
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");
106 public void Test00007 ()
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");
114 public void Test00008 ()
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");
122 public void Test00009 ()
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");
130 public void Test00010 ()
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");
138 public void Test00011 ()
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");
146 public void Test00012 ()
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");
154 public void Test00013 ()
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");
162 public void Test00014 ()
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");
170 public void Test00015 ()
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");
178 public void Test00016 ()
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");
186 public void Test00017 ()
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");
194 public void Test00018 ()
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");
202 public void Test00019 ()
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");
210 public void Test00020 ()
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");
218 public void Test00021 ()
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");
226 public void Test00022 ()
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");
233 // Test01000- Int32 and E
235 public void Test01000 ()
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");
246 public void Test01001 ()
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");
254 public void Test01002 ()
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");
262 public void Test01003 ()
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");
272 public void Test01004 ()
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");
282 public void Test01005 ()
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");
292 public void Test01006 ()
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");
300 public void Test01007 ()
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");
308 public void Test01008 ()
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");
316 public void Test01009 ()
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");
324 public void Test01010 ()
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");
332 public void Test01011 ()
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");
340 public void Test01012 ()
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");
348 public void Test01013 ()
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");
356 public void Test01014 ()
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");
364 public void Test01015 ()
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");
372 public void Test01016 ()
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");
380 public void Test01017 ()
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");
388 public void Test01018 ()
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");
396 public void Test01019 ()
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");
404 public void Test01020 ()
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");
412 public void Test01021 ()
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");
420 public void Test01022 ()
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");
428 public void Test01023 ()
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");
443 public void Test01024 ()
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");
458 public void Test01025 ()
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");
473 public void Test01026 ()
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");
488 public void Test01027 ()
490 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
491 nfi.NumberDecimalSeparator = "#";
492 Assert.AreEqual ("-1#000000E+008", (-99999999).ToString ("E", nfi), "#01");
496 public void Test01028 ()
498 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
499 nfi.NegativeSign = "+";
500 nfi.PositiveSign = "-";
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");
507 // Test02000- Int32 and F
509 public void Test02000 ()
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");
520 public void Test02001 ()
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");
528 public void Test02002 ()
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");
536 public void Test02003 ()
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");
546 public void Test02004 ()
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");
556 public void Test02005 ()
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");
566 public void Test02006 ()
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");
574 public void Test02007 ()
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");
582 public void Test02008 ()
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");
590 public void Test02009 ()
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");
598 public void Test02010 ()
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");
606 public void Test02011 ()
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");
614 public void Test02012 ()
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");
622 public void Test02013 ()
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");
630 public void Test02014 ()
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");
638 public void Test02015 ()
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");
646 public void Test02016 ()
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");
654 public void Test02017 ()
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");
662 public void Test02018 ()
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");
670 public void Test02019 ()
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");
678 public void Test02020 ()
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");
686 public void Test02021 ()
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");
694 public void Test02022 ()
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");
702 public void Test02023 ()
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");
714 public void Test02024 ()
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");
728 public void Test02025 ()
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");
739 public void Test02026 ()
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");
750 public void Test02027 ()
752 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
753 nfi.NumberDecimalSeparator = "#";
754 Assert.AreEqual ("1#00",1.ToString ("F", nfi), "#01");
757 // Test03000 - Int32 and G
759 public void Test03000 ()
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");
770 public void Test03001 ()
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");
778 public void Test03002 ()
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");
786 public void Test03003 ()
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");
796 public void Test03004 ()
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");
806 public void Test03005 ()
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");
816 public void Test03006 ()
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");
824 public void Test03007 ()
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");
832 public void Test03008 ()
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");
840 public void Test03009 ()
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");
848 public void Test03010 ()
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");
856 public void Test03011 ()
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");
864 public void Test03012 ()
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");
872 public void Test03013 ()
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");
880 public void Test03014 ()
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");
888 public void Test03015 ()
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");
896 public void Test03016 ()
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");
904 public void Test03017 ()
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");
912 public void Test03018 ()
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");
920 public void Test03019 ()
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");
928 public void Test03020 ()
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");
936 public void Test03021 ()
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");
944 public void Test03022 ()
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");
952 public void Test03023 ()
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");
964 public void Test03024 ()
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");
978 public void Test03025 ()
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");
989 public void Test03026 ()
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");
1000 public void Test03027 ()
1002 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1003 nfi.NumberDecimalSeparator = "#";
1004 Assert.AreEqual ("1#2E+02",123.ToString ("G2", nfi), "#01");
1007 // Test04000 - Int32 and N
1009 public void Test04000 ()
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");
1020 public void Test04001 ()
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");
1028 public void Test04002 ()
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");
1036 public void Test04003 ()
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");
1046 public void Test04004 ()
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");
1056 public void Test04005 ()
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");
1066 public void Test04006 ()
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");
1074 public void Test04007 ()
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");
1082 public void Test04008 ()
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");
1090 public void Test04009 ()
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");
1098 public void Test04010 ()
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");
1106 public void Test04011 ()
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");
1114 public void Test04012 ()
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");
1122 public void Test04013 ()
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");
1130 public void Test04014 ()
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");
1138 public void Test04015 ()
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");
1146 public void Test04016 ()
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");
1154 public void Test04017 ()
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");
1162 public void Test04018 ()
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");
1170 public void Test04019 ()
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");
1178 public void Test04020 ()
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");
1186 public void Test04021 ()
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");
1194 public void Test04022 ()
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");
1202 public void Test04023 ()
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");
1214 public void Test04024 ()
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");
1228 public void Test04025 ()
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");
1239 public void Test04026 ()
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");
1250 public void Test04027 ()
1252 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1253 nfi.NumberDecimalSeparator = "#";
1254 Assert.AreEqual ("123#0",123.ToString ("N1", nfi), "#01");
1258 public void Test04028 ()
1260 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1261 nfi.NumberGroupSeparator = "-";
1262 Assert.AreEqual ("-2-147-483-648.0",Int32.MinValue.ToString ("N1", nfi), "#01");
1266 public void Test04029 ()
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");
1282 public void Test04030 ()
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");
1304 public void Test04031 ()
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");
1311 // Test05000 - Int32 and P
1313 public void Test05000 ()
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");
1324 public void Test05001 ()
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");
1332 public void Test05002 ()
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");
1340 public void Test05003 ()
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");
1350 public void Test05004 ()
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");
1360 public void Test05005 ()
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");
1370 public void Test05006 ()
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");
1378 public void Test05007 ()
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");
1386 public void Test05008 ()
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");
1394 public void Test05009 ()
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");
1402 public void Test05010 ()
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");
1410 public void Test05011 ()
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");
1418 public void Test05012 ()
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");
1426 public void Test05013 ()
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");
1434 public void Test05014 ()
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");
1442 public void Test05015 ()
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");
1450 public void Test05016 ()
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");
1458 public void Test05017 ()
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");
1466 public void Test05018 ()
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");
1474 public void Test05019 ()
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");
1482 public void Test05020 ()
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");
1490 public void Test05021 ()
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");
1498 public void Test05022 ()
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");
1506 public void Test05023 ()
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");
1518 public void Test05024 ()
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");
1532 public void Test05025 ()
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");
1543 public void Test05026 ()
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");
1554 public void Test05027 ()
1556 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1557 nfi.PercentDecimalSeparator = "#";
1558 Assert.AreEqual ("12,300#0 %",123.ToString ("P1", nfi), "#01");
1562 public void Test05028 ()
1564 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
1565 nfi.PercentGroupSeparator = "-";
1566 Assert.AreEqual ("-214-748-364-800.0 %",Int32.MinValue.ToString ("P1", nfi), "#01");
1570 public void Test05029 ()
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");
1586 public void Test05030 ()
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");
1608 public void Test05031 ()
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");
1616 public void Test05032 ()
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");
1626 public void Test05033 ()
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");
1636 public void Test05034 ()
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");
1646 public void Test05035 ()
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");
1656 public void Test05036 ()
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");
1666 public void Test05037 ()
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");
1675 // Test06000 - Int32 and R
1677 [ExpectedException (typeof (FormatException))]
1678 public void Test06000 ()
1680 Assert.AreEqual ("0", 0.ToString ("R", _nfi), "#01");
1683 // Test07000- Int32 and X
1685 public void Test07000 ()
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");
1696 public void Test07001 ()
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");
1704 public void Test07002 ()
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");
1712 public void Test07003 ()
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");
1722 public void Test07004 ()
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");
1732 public void Test07005 ()
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");
1742 public void Test07006 ()
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");
1750 public void Test07007 ()
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");
1758 public void Test07008 ()
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");
1766 public void Test07009 ()
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");
1774 public void Test07010 ()
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");
1782 public void Test07011 ()
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");
1790 public void Test07012 ()
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");
1798 public void Test07013 ()
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");
1806 public void Test07014 ()
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");
1814 public void Test07015 ()
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");
1822 public void Test07016 ()
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");
1830 public void Test07017 ()
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");
1838 public void Test07018 ()
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");
1846 public void Test07019 ()
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");
1854 public void Test07020 ()
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");
1862 public void Test07021 ()
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");
1870 public void Test07022 ()
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");
1878 public void Test08000 ()
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");
1885 // Test08000 - Int32 and Custom
1887 public void Test08001 ()
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");
1895 public void Test08002 ()
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");
1903 public void Test08003 ()
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");
1911 public void Test08004 ()
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");
1919 public void Test08005 ()
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");
1927 public void Test08006 ()
1929 Assert.AreEqual ("", 0.ToString (".", _nfi), "#01");
1930 Assert.AreEqual ("", Int32.MaxValue.ToString (".", _nfi), "#02");
1931 Assert.AreEqual ("-", Int32.MinValue.ToString (".", _nfi), "#03");
1935 public void Test08007 ()
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");
1943 public void Test08008 ()
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");
1951 public void Test08009 ()
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");
1959 public void Test08010 ()
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");
1967 public void Test08011 ()
1969 Assert.AreEqual ("", 0.ToString ("##.#.##.###.####", _nfi), "#01");
1970 Assert.AreEqual ("1", 1.ToString ("##.#.##.###.####", _nfi), "#02");
1971 Assert.AreEqual ("-1", (-1).ToString ("##.#.##.###.####", _nfi), "#03");
1975 public void Test08012 ()
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");
1983 public void Test08013 ()
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");
1991 public void Test08014 ()
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");
1999 public void Test08015 ()
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");
2007 public void Test08016 ()
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");
2015 public void Test08017 ()
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");
2023 public void Test08018 ()
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");
2033 public void Test08019 ()
2035 Assert.AreEqual ("-2147483648", Int32.MinValue.ToString (",0000000000", _nfi), "#01");
2039 public void Test08020 ()
2041 Assert.AreEqual ("-0002147484", Int32.MinValue.ToString (",0000000000,", _nfi), "#01");
2045 public void Test08021 ()
2047 Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0,0000000000", _nfi), "#01");
2051 public void Test08022 ()
2053 Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0000000000,0", _nfi), "#01");
2057 public void Test08023 ()
2059 Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0", _nfi), "#01");
2063 public void Test08024 ()
2065 Assert.AreEqual ("-02,147,483,648", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0", _nfi), "#01");
2069 public void Test08025 ()
2071 Assert.AreEqual ("-00,002,147,484", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0,", _nfi), "#01");
2075 public void Test08026 ()
2077 Assert.AreEqual ("-00,002,147,484", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0,", _nfi), "#01");
2081 public void Test08027 ()
2083 Assert.AreEqual ("-", Int32.MinValue.ToString (",", _nfi), "#01");
2087 public void Test08028 ()
2089 Assert.AreEqual ("-2147483648", Int32.MinValue.ToString (",##########", _nfi), "#01");
2093 public void Test08029 ()
2095 Assert.AreEqual ("-2147484", Int32.MinValue.ToString (",##########,", _nfi), "#01");
2099 public void Test08030 ()
2101 Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,##########", _nfi), "#01");
2105 public void Test08031 ()
2107 Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("##########,#", _nfi), "#01");
2111 public void Test08032 ()
2113 Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#", _nfi), "#01");
2117 public void Test08033 ()
2119 Assert.AreEqual ("-2,147,483,648", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#", _nfi), "#01");
2123 public void Test08034 ()
2125 Assert.AreEqual ("-2,147,484", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#,", _nfi), "#01");
2129 public void Test08035 ()
2131 Assert.AreEqual ("-2,147,484", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#,", _nfi), "#01");
2135 public void Test08036 ()
2137 Assert.AreEqual ("-1", (-1000).ToString ("##########,", _nfi), "#01");
2141 public void Test08037 ()
2143 Assert.AreEqual ("", (-100).ToString ("##########,", _nfi), "#01");
2147 public void Test08038 ()
2149 Assert.AreEqual ("-%", Int32.MinValue.ToString ("%", _nfi), "#01");
2153 public void Test08039 ()
2155 Assert.AreEqual ("-214748364800%", Int32.MinValue.ToString ("0%", _nfi), "#01");
2159 public void Test08040 ()
2161 Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString ("%0", _nfi), "#01");
2165 public void Test08041 ()
2167 Assert.AreEqual ("-%21474836480000%", Int32.MinValue.ToString ("%0%", _nfi), "#01");
2171 public void Test08042 ()
2173 Assert.AreEqual ("- % 21474836480000 % ", Int32.MinValue.ToString (" % 0 % ", _nfi), "#01");
2177 public void Test08043 ()
2179 Assert.AreEqual ("-214748365%", Int32.MinValue.ToString ("0%,", _nfi), "#01");
2183 public void Test08044 ()
2185 Assert.AreEqual ("-214748365%", Int32.MinValue.ToString ("0,%", _nfi), "#01");
2189 public void Test08045 ()
2191 Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString (",%0", _nfi), "#01");
2195 public void Test08046 ()
2197 Assert.AreEqual ("-%214748364800", Int32.MinValue.ToString ("%,0", _nfi), "#01");
2201 public void Test08047 ()
2203 Assert.AreEqual ("-2147483648%%%%%%", Int32.MinValue.ToString ("0,,,,%%%%%%", _nfi), "#01");
2207 public void Test08048 ()
2209 Assert.AreEqual ("-2147483648%%%%%%", Int32.MinValue.ToString ("0%%%%%%,,,,", _nfi), "#01");
2213 public void Test08049 ()
2215 Assert.AreEqual ("-%%%%%%2147483648", Int32.MinValue.ToString ("%%%%%%0,,,,", _nfi), "#01");
2219 public void Test08050 ()
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");
2228 public void Test08051 ()
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");
2239 public void Test08052 ()
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");
2250 public void Test08053 ()
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");
2261 public void Test08054 ()
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");
2272 public void Test08055 ()
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");
2283 public void Test08056 ()
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");
2294 public void Test08057 ()
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");
2305 public void Test08058 ()
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");
2316 public void Test08059 ()
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");
2327 public void Test08060 ()
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");
2338 public void Test08061 ()
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");
2349 public void Test08062 ()
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");
2360 public void Test08063 ()
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");
2371 public void Test08064 ()
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");
2382 public void Test08065 ()
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");
2391 public void Test08066 ()
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");
2402 public void Test08067 ()
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");
2413 public void Test08068 ()
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");
2424 public void Test08069 ()
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");
2435 public void Test08070 ()
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");
2446 public void Test08071 ()
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");
2457 public void Test08072 ()
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");
2468 public void Test08073 ()
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");
2479 public void Test08074 ()
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");
2488 public void Test08075 ()
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");
2499 public void Test08076 ()
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");
2510 public void Test08077 ()
2512 Assert.AreEqual ("-", Int32.MinValue.ToString (";", _nfi), "#01");
2513 Assert.AreEqual ("", Int32.MaxValue.ToString (";", _nfi), "#02");
2514 Assert.AreEqual ("",0.ToString (";", _nfi), "#03");
2518 public void Test08078 ()
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");
2526 public void Test08079 ()
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");
2534 public void Test08080 ()
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");
2542 public void Test08081 ()
2544 Assert.AreEqual ("-", Int32.MinValue.ToString (";;", _nfi), "#01");
2545 Assert.AreEqual ("", Int32.MaxValue.ToString (";;", _nfi), "#02");
2546 Assert.AreEqual ("",0.ToString (";;", _nfi), "#03");
2550 public void Test08082 ()
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");
2558 public void Test08083 ()
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");
2566 public void Test08084 ()
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");
2574 public void Test08085 ()
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");
2582 public void Test08086 ()
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");
2590 public void Test08087 ()
2593 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
2594 nfi.NumberDecimalSeparator = "$$$";
2595 Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
2599 public void Test08088 ()
2602 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
2603 nfi.NumberGroupSeparator = "$$$";
2604 Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
2608 public void Test08089 ()
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");
2616 public void Test08090 ()
2619 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
2620 nfi.PercentSymbol = "$$$";
2621 Assert.AreEqual ("-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi), "#01");
2625 public void Test08091 ()
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");
2633 // Test10000- Double and D
2635 [ExpectedException (typeof (FormatException))]
2636 public void Test10000 ()
2638 Assert.AreEqual ("0", 0.0.ToString ("D", _nfi), "#01");
2641 // Test11000- Double and E
2643 public void Test11000 ()
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");
2654 public void Test11001 ()
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");
2662 public void Test11002 ()
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");
2670 public void Test11003 ()
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");
2680 public void Test11004 ()
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");
2690 public void Test11005 ()
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");
2700 public void Test11006 ()
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");
2708 public void Test11007 ()
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");
2716 public void Test11008 ()
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");
2724 public void Test11009 ()
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");
2732 public void Test11010 ()
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");
2740 public void Test11011 ()
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");
2748 public void Test11012 ()
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");
2756 public void Test11013 ()
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");
2764 public void Test11014 ()
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");
2772 public void Test11015 ()
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");
2780 public void Test11016 ()
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");
2788 public void Test11017 ()
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");
2796 public void Test11018 ()
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");
2804 public void Test11019 ()
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");
2812 public void Test11020 ()
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");
2820 public void Test11021 ()
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");
2828 public void Test11022 ()
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");
2836 public void Test11023 ()
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");
2851 public void Test11024 ()
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");
2866 public void Test11025 ()
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");
2881 public void Test11026 ()
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");
2896 public void Test11027 ()
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");
2911 public void Test11028 ()
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");
2926 public void Test11029 ()
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");
2936 public void Test11030 ()
2938 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
2939 nfi.NumberDecimalSeparator = "#";
2940 Assert.AreEqual ("-1#000000E+008", (-99999999.9).ToString ("E", nfi), "#01");
2944 public void Test11031 ()
2946 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
2947 nfi.NegativeSign = "+";
2948 nfi.PositiveSign = "-";
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");
2956 public void TestNaNToString ()
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");
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");
2975 public void Test11032 ()
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");
2982 // Test12000- Double and F
2984 public void Test12000 ()
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");
2995 public void Test12001 ()
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");
3003 public void Test12002 ()
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");
3011 public void Test12003 ()
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");
3021 public void Test12004 ()
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");
3031 public void Test12005 ()
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");
3041 public void Test12006 ()
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");
3049 public void Test12007 ()
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");
3057 public void Test12008 ()
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");
3065 public void Test12009 ()
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");
3073 public void Test12010 ()
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");
3081 public void Test12011 ()
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");
3089 public void Test12012 ()
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");
3097 public void Test12013 ()
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");
3105 public void Test12014 ()
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");
3113 public void Test12015 ()
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");
3121 public void Test12016 ()
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");
3129 public void Test12017 ()
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");
3137 public void Test12018 ()
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");
3145 public void Test12019 ()
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");
3153 public void Test12020 ()
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");
3161 public void Test12021 ()
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");
3169 public void Test12022 ()
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");
3177 public void Test12023 ()
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");
3192 public void Test12024 ()
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");
3207 public void Test12025 ()
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");
3222 public void Test12026 ()
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");
3237 public void Test12027 ()
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");
3252 public void Test12028 ()
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");
3264 public void Test12029 ()
3266 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3267 nfi.NumberDecimalSeparator = "#";
3268 Assert.AreEqual ("-99999999#90", (-99999999.9).ToString ("F", nfi), "#01");
3272 public void Test12030 ()
3274 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3275 nfi.NegativeSign = "+";
3276 nfi.PositiveSign = "-";
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");
3284 public void Test12031 ()
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");
3291 // Test13000- Double and G
3293 public void Test13000 ()
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");
3305 public void Test13001 ()
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");
3313 public void Test13002 ()
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");
3321 public void Test13003 ()
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");
3331 public void Test13004 ()
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");
3341 public void Test13005 ()
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");
3351 public void Test13006 ()
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");
3359 public void Test13007 ()
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");
3367 public void Test13008 ()
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");
3375 public void Test13009 ()
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");
3383 public void Test13010 ()
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");
3391 public void Test13011 ()
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");
3399 public void Test13012 ()
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");
3407 public void Test13013 ()
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");
3415 public void Test13014 ()
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");
3423 public void Test13015 ()
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");
3431 public void Test13016 ()
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");
3439 public void Test13017 ()
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");
3447 public void Test13018 ()
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");
3455 public void Test13019 ()
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");
3463 public void Test13020 ()
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");
3471 public void Test13021 ()
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");
3479 public void Test13022 ()
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");
3487 public void Test13023 ()
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");
3502 public void Test13024_CarryPropagation ()
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");
3528 public void Test13024 ()
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");
3543 public void Test13025 ()
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");
3558 public void Test13026 ()
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");
3573 public void Test13027 ()
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");
3588 public void Test13028 ()
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");
3603 public void Test13029 ()
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");
3618 public void Test13030 ()
3620 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3621 nfi.NumberDecimalSeparator = "#";
3622 Assert.AreEqual ("-99999999#9", (-99999999.9).ToString ("G", nfi), "#01");
3626 public void Test13031 ()
3628 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3629 nfi.NegativeSign = "+";
3630 nfi.PositiveSign = "-";
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");
3638 public void Test13032 ()
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");
3646 public void Test13033 ()
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");
3657 // Test14000- Double and N
3659 public void Test14000 ()
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");
3670 public void Test14001 ()
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");
3678 public void Test14002 ()
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");
3686 public void Test14003 ()
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");
3696 public void Test14004 ()
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");
3706 public void Test14005 ()
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");
3716 public void Test14006 ()
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");
3724 public void Test14007 ()
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");
3732 public void Test14008 ()
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");
3740 public void Test14009 ()
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");
3748 public void Test14010 ()
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");
3756 public void Test14011 ()
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");
3764 public void Test14012 ()
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");
3772 public void Test14013 ()
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");
3780 public void Test14014 ()
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");
3788 public void Test14015 ()
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");
3796 public void Test14016 ()
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");
3804 public void Test14017 ()
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");
3812 public void Test14018 ()
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");
3820 public void Test14019 ()
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");
3828 public void Test14020 ()
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");
3836 public void Test14021 ()
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");
3844 public void Test14022 ()
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");
3852 public void Test14023 ()
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");
3867 public void Test14024 ()
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");
3882 public void Test14025 ()
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");
3897 public void Test14026 ()
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");
3912 public void Test14027 ()
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");
3927 public void Test14028 ()
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");
3939 public void Test14029 ()
3941 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3942 nfi.NumberDecimalSeparator = "#";
3943 Assert.AreEqual ("-99,999,999#90", (-99999999.9).ToString ("N", nfi), "#01");
3947 public void Test14030 ()
3949 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
3950 nfi.NegativeSign = "+";
3951 nfi.PositiveSign = "-";
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");
3959 public void Test14031 ()
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");
3966 [Test (Description = "Bug #659061")]
3967 public void Test14032 ()
3969 NumberFormatInfo nfi = _nfi.Clone () as NumberFormatInfo;
3970 int[] groups = new int [10];
3972 for (int i = 0; i < groups.Length; i++)
3974 nfi.NumberGroupSizes = groups;
3975 Assert.AreEqual ("2,5,5,5,6,6,6.65", (2555666.65).ToString ("N", nfi), "#01");
3977 for (int i = 0; i < groups.Length; i++)
3979 nfi.NumberGroupSizes = groups;
3980 Assert.AreEqual ("2,55,56,66.65", (2555666.65).ToString ("N", nfi), "#02");
3982 for (int i = 0; i < groups.Length; i++)
3984 nfi.NumberGroupSizes = groups;
3985 Assert.AreEqual ("2,555,666.65", (2555666.65).ToString ("N", nfi), "#03");
3987 for (int i = 0; i < groups.Length; i++)
3989 nfi.NumberGroupSizes = groups;
3990 Assert.AreEqual ("255,5666.65", (2555666.65).ToString ("N", nfi), "#04");
3992 for (int i = 0; i < groups.Length; i++)
3994 nfi.NumberGroupSizes = groups;
3995 Assert.AreEqual ("25,55666.65", (2555666.65).ToString ("N", nfi), "#05");
3997 for (int i = 0; i < groups.Length; i++)
3999 nfi.NumberGroupSizes = groups;
4000 Assert.AreEqual ("2,555666.65", (2555666.65).ToString ("N", nfi), "#06");
4002 for (int i = 0; i < groups.Length; i++)
4004 nfi.NumberGroupSizes = groups;
4005 Assert.AreEqual ("2555666.65", (2555666.65).ToString ("N", nfi), "#07");
4007 for (int i = 0; i < groups.Length; i++)
4009 nfi.NumberGroupSizes = groups;
4010 Assert.AreEqual ("2555666.65", (2555666.65).ToString ("N", nfi), "#08");
4014 public void Test14033 ()
4016 NumberFormatInfo nfi = _nfi.Clone () as NumberFormatInfo;
4017 int[] groups = new int [] { 1, 2, 3 };
4019 nfi.NumberGroupSizes = groups;
4020 Assert.AreEqual ("2,555,66,6.65", (2555666.65).ToString ("N", nfi), "#01");
4023 // Test15000- Double and P
4025 public void Test15000 ()
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");
4036 public void Test15001 ()
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");
4044 public void Test15002 ()
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");
4052 public void Test15003 ()
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");
4062 public void Test15004 ()
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");
4072 public void Test15005 ()
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");
4082 public void Test15006 ()
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");
4090 public void Test15007 ()
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");
4098 public void Test15008 ()
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");
4106 public void Test15009 ()
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");
4114 public void Test15010 ()
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");
4122 public void Test15011 ()
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");
4130 public void Test15012 ()
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");
4138 public void Test15013 ()
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");
4146 public void Test15014 ()
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");
4154 public void Test15015 ()
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");
4162 public void Test15016 ()
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");
4170 public void Test15017 ()
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");
4178 public void Test15018 ()
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");
4186 public void Test15019 ()
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");
4194 public void Test15020 ()
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");
4202 public void Test15021 ()
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");
4210 public void Test15022 ()
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");
4218 public void Test15023 ()
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");
4233 public void Test15024 ()
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");
4248 public void Test15025 ()
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");
4263 public void Test15026 ()
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");
4278 public void Test15027 ()
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");
4293 public void Test15028 ()
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");
4305 public void Test15029 ()
4307 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
4308 nfi.PercentDecimalSeparator = "#";
4309 Assert.AreEqual ("-9,999,999,990#00 %", (-99999999.9).ToString ("P", nfi), "#01");
4313 public void Test15030 ()
4315 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
4316 nfi.NegativeSign = "+";
4317 nfi.PositiveSign = "-";
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");
4325 public void Test15031 ()
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");
4332 // TestRoundtrip for double and single
4334 public void TestRoundtrip()
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");
4349 // Tests arithmetic overflow in double.ToString exposed by Bug #383531
4351 public void TestToStringOverflow()
4353 // Test all the possible double exponents with the maximal mantissa
4354 long dblPattern = 0xfffffffffffff; // all 1s significand
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);
4364 // Test17000 - Double and X
4366 [ExpectedException (typeof (FormatException))]
4367 public void Test17000 ()
4369 Assert.AreEqual ("", 0.0.ToString ("X99", _nfi) , "#01");
4373 public void Test18000 ()
4375 string formatString = "p 00.0000\\';n 0000.00\\';0.#\\'";
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");
4383 public void TestInvariantThreading ()
4385 Thread[] th = new Thread[4];
4386 bool failed = false;
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") {
4401 foreach (Thread t in th) {
4405 Assert.IsFalse (failed);