2 // MonoTests.System.NumberFormatterTest
\r
5 // akiramei (mei@work.email.ne.jp)
\r
11 using System.Globalization;
\r
12 using NUnit.Framework;
\r
14 namespace MonoTests.System {
\r
16 public class NumberFormatterTest : TestCase {
\r
18 NumberFormatInfo _nfi;
\r
20 protected override void SetUp () {
\r
21 _nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
\r
24 // Test00000- Int32 and D
\r
26 public void Test00000 () {
\r
27 AssertEquals ("#01", "0", 0.ToString ("D", _nfi));
\r
28 AssertEquals ("#02", "0", 0.ToString ("d", _nfi));
\r
29 AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("D", _nfi));
\r
30 AssertEquals ("#04", "-2147483648", Int32.MinValue.ToString ("d", _nfi));
\r
31 AssertEquals ("#05", "2147483647", Int32.MaxValue.ToString ("D", _nfi));
\r
32 AssertEquals ("#06", "2147483647", Int32.MaxValue.ToString ("d", _nfi));
\r
36 public void Test00001 () {
\r
37 AssertEquals ("#01", "D ", 0.ToString ("D ", _nfi));
\r
38 AssertEquals ("#02", " D", 0.ToString (" D", _nfi));
\r
39 AssertEquals ("#03", " D ", 0.ToString (" D ", _nfi));
\r
43 public void Test00002 () {
\r
44 AssertEquals ("#01", "-D ", (-1).ToString ("D ", _nfi));
\r
45 AssertEquals ("#02", "- D", (-1).ToString (" D", _nfi));
\r
46 AssertEquals ("#03", "- D ", (-1).ToString (" D ", _nfi));
\r
50 public void Test00003 () {
\r
51 AssertEquals ("#01", "0", 0.ToString ("D0", _nfi));
\r
52 AssertEquals ("#02", "0000000000", 0.ToString ("D10", _nfi));
\r
53 AssertEquals ("#03", "00000000000", 0.ToString ("D11", _nfi));
\r
54 AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("D99", _nfi));
\r
55 AssertEquals ("#05", "D100", 0.ToString ("D100", _nfi));
\r
59 public void Test00004 () {
\r
60 AssertEquals ("#01", "2147483647", Int32.MaxValue.ToString ("D0", _nfi));
\r
61 AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("D10", _nfi));
\r
62 AssertEquals ("#03", "02147483647", Int32.MaxValue.ToString ("D11", _nfi));
\r
63 AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483647", Int32.MaxValue.ToString ("D99", _nfi));
\r
64 AssertEquals ("#05", "D12147483647", Int32.MaxValue.ToString ("D100", _nfi));
\r
68 public void Test00005 () {
\r
69 AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString ("D0", _nfi));
\r
70 AssertEquals ("#02", "-2147483648", Int32.MinValue.ToString ("D10", _nfi));
\r
71 AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("D11", _nfi));
\r
72 AssertEquals ("#04", "-000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002147483648", Int32.MinValue.ToString ("D99", _nfi));
\r
73 AssertEquals ("#05", "-D12147483648", Int32.MinValue.ToString ("D100", _nfi));
\r
77 public void Test00006 () {
\r
78 AssertEquals ("#01", "DF", 0.ToString ("DF", _nfi));
\r
79 AssertEquals ("#02", "D0F", 0.ToString ("D0F", _nfi));
\r
80 AssertEquals ("#03", "D0xF", 0.ToString ("D0xF", _nfi));
\r
84 public void Test00007 () {
\r
85 AssertEquals ("#01", "DF", Int32.MaxValue.ToString ("DF", _nfi));
\r
86 AssertEquals ("#02", "D2147483647F", Int32.MaxValue.ToString ("D0F", _nfi));
\r
87 AssertEquals ("#03", "D2147483647xF", Int32.MaxValue.ToString ("D0xF", _nfi));
\r
91 public void Test00008 () {
\r
92 AssertEquals ("#01", "-DF", Int32.MinValue.ToString ("DF", _nfi));
\r
93 AssertEquals ("#02", "-D2147483648F", Int32.MinValue.ToString ("D0F", _nfi));
\r
94 AssertEquals ("#03", "-D2147483648xF", Int32.MinValue.ToString ("D0xF", _nfi));
\r
98 public void Test00009 () {
\r
99 AssertEquals ("#01", "00000000000", 0.ToString ("D0000000000000000000000000000000000000011", _nfi));
\r
100 AssertEquals ("#02", "02147483647", Int32.MaxValue.ToString ("D0000000000000000000000000000000000000011", _nfi));
\r
101 AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("D0000000000000000000000000000000000000011", _nfi));
\r
105 public void Test00010 () {
\r
106 AssertEquals ("#01", "+D", 0.ToString ("+D", _nfi));
\r
107 AssertEquals ("#02", "D+", 0.ToString ("D+", _nfi));
\r
108 AssertEquals ("#03", "+D+", 0.ToString ("+D+", _nfi));
\r
112 public void Test00011 () {
\r
113 AssertEquals ("#01", "+D", Int32.MaxValue.ToString ("+D", _nfi));
\r
114 AssertEquals ("#02", "D+", Int32.MaxValue.ToString ("D+", _nfi));
\r
115 AssertEquals ("#03", "+D+", Int32.MaxValue.ToString ("+D+", _nfi));
\r
119 public void Test00012 () {
\r
120 AssertEquals ("#01", "-+D", Int32.MinValue.ToString ("+D", _nfi));
\r
121 AssertEquals ("#02", "-D+", Int32.MinValue.ToString ("D+", _nfi));
\r
122 AssertEquals ("#03", "-+D+", Int32.MinValue.ToString ("+D+", _nfi));
\r
126 public void Test00013 () {
\r
127 AssertEquals ("#01", "-D", 0.ToString ("-D", _nfi));
\r
128 AssertEquals ("#02", "D-", 0.ToString ("D-", _nfi));
\r
129 AssertEquals ("#03", "-D-", 0.ToString ("-D-", _nfi));
\r
133 public void Test00014 () {
\r
134 AssertEquals ("#01", "-D", Int32.MaxValue.ToString ("-D", _nfi));
\r
135 AssertEquals ("#02", "D-", Int32.MaxValue.ToString ("D-", _nfi));
\r
136 AssertEquals ("#03", "-D-", Int32.MaxValue.ToString ("-D-", _nfi));
\r
140 public void Test00015 () {
\r
141 AssertEquals ("#01", "--D", Int32.MinValue.ToString ("-D", _nfi));
\r
142 AssertEquals ("#02", "-D-", Int32.MinValue.ToString ("D-", _nfi));
\r
143 AssertEquals ("#03", "--D-", Int32.MinValue.ToString ("-D-", _nfi));
\r
147 public void Test00016 () {
\r
148 AssertEquals ("#01", "D+0", 0.ToString ("D+0", _nfi));
\r
149 AssertEquals ("#02", "D+2147483647", Int32.MaxValue.ToString ("D+0", _nfi));
\r
150 AssertEquals ("#03", "-D+2147483648", Int32.MinValue.ToString ("D+0", _nfi));
\r
154 public void Test00017 () {
\r
155 AssertEquals ("#01", "D+9", 0.ToString ("D+9", _nfi));
\r
156 AssertEquals ("#02", "D+9", Int32.MaxValue.ToString ("D+9", _nfi));
\r
157 AssertEquals ("#03", "-D+9", Int32.MinValue.ToString ("D+9", _nfi));
\r
161 public void Test00018 () {
\r
162 AssertEquals ("#01", "D-9", 0.ToString ("D-9", _nfi));
\r
163 AssertEquals ("#02", "D-9", Int32.MaxValue.ToString ("D-9", _nfi));
\r
164 AssertEquals ("#03", "-D-9", Int32.MinValue.ToString ("D-9", _nfi));
\r
168 public void Test00019 () {
\r
169 AssertEquals ("#01", "D0", 0.ToString ("D0,", _nfi));
\r
170 AssertEquals ("#02", "D2147484", Int32.MaxValue.ToString ("D0,", _nfi));
\r
171 AssertEquals ("#03", "-D2147484", Int32.MinValue.ToString ("D0,", _nfi));
\r
175 public void Test00020 () {
\r
176 AssertEquals ("#01", "D0", 0.ToString ("D0.", _nfi));
\r
177 AssertEquals ("#02", "D2147483647", Int32.MaxValue.ToString ("D0.", _nfi));
\r
178 AssertEquals ("#03", "-D2147483648", Int32.MinValue.ToString ("D0.", _nfi));
\r
182 public void Test00021 () {
\r
183 AssertEquals ("#01", "D0.0", 0.ToString ("D0.0", _nfi));
\r
184 AssertEquals ("#02", "D2147483647.0", Int32.MaxValue.ToString ("D0.0", _nfi));
\r
185 AssertEquals ("#03", "-D2147483648.0", Int32.MinValue.ToString ("D0.0", _nfi));
\r
189 public void Test00022 () {
\r
190 AssertEquals ("#01", "D09", 0.ToString ("D0.9", _nfi));
\r
191 AssertEquals ("#02", "D21474836479", Int32.MaxValue.ToString ("D0.9", _nfi));
\r
192 AssertEquals ("#03", "-D21474836489", Int32.MinValue.ToString ("D0.9", _nfi));
\r
195 // Test01000- Int32 and E
\r
197 public void Test01000 () {
\r
198 AssertEquals ("#01", "0.000000E+000", 0.ToString ("E", _nfi));
\r
199 AssertEquals ("#02", "0.000000e+000", 0.ToString ("e", _nfi));
\r
200 AssertEquals ("#03", "-2.147484E+009", Int32.MinValue.ToString ("E", _nfi));
\r
201 AssertEquals ("#04", "-2.147484e+009", Int32.MinValue.ToString ("e", _nfi));
\r
202 AssertEquals ("#05", "2.147484E+009", Int32.MaxValue.ToString ("E", _nfi));
\r
203 AssertEquals ("#06", "2.147484e+009", Int32.MaxValue.ToString ("e", _nfi));
\r
207 public void Test01001 () {
\r
208 AssertEquals ("#01", "E ", 0.ToString ("E ", _nfi));
\r
209 AssertEquals ("#02", " E", 0.ToString (" E", _nfi));
\r
210 AssertEquals ("#03", " E ", 0.ToString (" E ", _nfi));
\r
214 public void Test01002 () {
\r
215 AssertEquals ("#01", "-E ", (-1).ToString ("E ", _nfi));
\r
216 AssertEquals ("#02", "- E", (-1).ToString (" E", _nfi));
\r
217 AssertEquals ("#03", "- E ", (-1).ToString (" E ", _nfi));
\r
221 public void Test01003 () {
\r
222 AssertEquals ("#01", "0E+000", 0.ToString ("E0", _nfi));
\r
223 AssertEquals ("#02", "0.000000000E+000", 0.ToString ("E9", _nfi));
\r
224 AssertEquals ("#03", "0.0000000000E+000", 0.ToString ("E10", _nfi));
\r
225 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.ToString ("E99", _nfi));
\r
226 AssertEquals ("#05", "E100", 0.ToString ("E100", _nfi));
\r
230 public void Test01004 () {
\r
231 AssertEquals ("#01", "2E+009", Int32.MaxValue.ToString ("E0", _nfi));
\r
232 AssertEquals ("#02", "2.147483647E+009", Int32.MaxValue.ToString ("E9", _nfi));
\r
233 AssertEquals ("#03", "2.1474836470E+009", Int32.MaxValue.ToString ("E10", _nfi));
\r
234 AssertEquals ("#04", "2.147483647000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MaxValue.ToString ("E99", _nfi));
\r
235 AssertEquals ("#05", "E12147483647", Int32.MaxValue.ToString ("E100", _nfi));
\r
239 public void Test01005 () {
\r
240 AssertEquals ("#01", "-2E+009", Int32.MinValue.ToString ("E0", _nfi));
\r
241 AssertEquals ("#02", "-2.147483648E+009", Int32.MinValue.ToString ("E9", _nfi));
\r
242 AssertEquals ("#03", "-2.1474836480E+009", Int32.MinValue.ToString ("E10", _nfi));
\r
243 AssertEquals ("#04", "-2.147483648000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+009", Int32.MinValue.ToString ("E99", _nfi));
\r
244 AssertEquals ("#05", "-E12147483648", Int32.MinValue.ToString ("E100", _nfi));
\r
248 public void Test01006 () {
\r
249 AssertEquals ("#01", "EF", 0.ToString ("EF", _nfi));
\r
250 AssertEquals ("#02", "E0F", 0.ToString ("E0F", _nfi));
\r
251 AssertEquals ("#03", "E0xF", 0.ToString ("E0xF", _nfi));
\r
255 public void Test01007 () {
\r
256 AssertEquals ("#01", "EF", Int32.MaxValue.ToString ("EF", _nfi));
\r
257 AssertEquals ("#02", "E0F", Int32.MaxValue.ToString ("E0F", _nfi));
\r
258 AssertEquals ("#03", "E0xF", Int32.MaxValue.ToString ("E0xF", _nfi));
\r
262 public void Test01008 () {
\r
263 AssertEquals ("#01", "-EF", Int32.MinValue.ToString ("EF", _nfi));
\r
264 AssertEquals ("#02", "E0F", Int32.MinValue.ToString ("E0F", _nfi));
\r
265 AssertEquals ("#03", "E0xF", Int32.MinValue.ToString ("E0xF", _nfi));
\r
269 public void Test01009 () {
\r
270 AssertEquals ("#01", "0.0000000000E+000", 0.ToString ("E0000000000000000000000000000000000000010", _nfi));
\r
271 AssertEquals ("#02", "2.1474836470E+009", Int32.MaxValue.ToString ("E0000000000000000000000000000000000000010", _nfi));
\r
272 AssertEquals ("#03", "-2.1474836480E+009", Int32.MinValue.ToString ("E0000000000000000000000000000000000000010", _nfi));
\r
276 public void Test01010 () {
\r
277 AssertEquals ("#01", "+E", 0.ToString ("+E", _nfi));
\r
278 AssertEquals ("#02", "E+", 0.ToString ("E+", _nfi));
\r
279 AssertEquals ("#03", "+E+", 0.ToString ("+E+", _nfi));
\r
283 public void Test01011 () {
\r
284 AssertEquals ("#01", "+E", Int32.MaxValue.ToString ("+E", _nfi));
\r
285 AssertEquals ("#02", "E+", Int32.MaxValue.ToString ("E+", _nfi));
\r
286 AssertEquals ("#03", "+E+", Int32.MaxValue.ToString ("+E+", _nfi));
\r
290 public void Test01012 () {
\r
291 AssertEquals ("#01", "-+E", Int32.MinValue.ToString ("+E", _nfi));
\r
292 AssertEquals ("#02", "-E+", Int32.MinValue.ToString ("E+", _nfi));
\r
293 AssertEquals ("#03", "-+E+", Int32.MinValue.ToString ("+E+", _nfi));
\r
297 public void Test01013 () {
\r
298 AssertEquals ("#01", "-E", 0.ToString ("-E", _nfi));
\r
299 AssertEquals ("#02", "E-", 0.ToString ("E-", _nfi));
\r
300 AssertEquals ("#03", "-E-", 0.ToString ("-E-", _nfi));
\r
304 public void Test01014 () {
\r
305 AssertEquals ("#01", "-E", Int32.MaxValue.ToString ("-E", _nfi));
\r
306 AssertEquals ("#02", "E-", Int32.MaxValue.ToString ("E-", _nfi));
\r
307 AssertEquals ("#03", "-E-", Int32.MaxValue.ToString ("-E-", _nfi));
\r
311 public void Test01015 () {
\r
312 AssertEquals ("#01", "--E", Int32.MinValue.ToString ("-E", _nfi));
\r
313 AssertEquals ("#02", "-E-", Int32.MinValue.ToString ("E-", _nfi));
\r
314 AssertEquals ("#03", "--E-", Int32.MinValue.ToString ("-E-", _nfi));
\r
318 public void Test01016 () {
\r
319 AssertEquals ("#01", "E+0", 0.ToString ("E+0", _nfi));
\r
320 AssertEquals ("#02", "E+0", Int32.MaxValue.ToString ("E+0", _nfi));
\r
321 AssertEquals ("#03", "E+0", Int32.MinValue.ToString ("E+0", _nfi));
\r
325 public void Test01017 () {
\r
326 AssertEquals ("#01", "E+9", 0.ToString ("E+9", _nfi));
\r
327 AssertEquals ("#02", "E+9", Int32.MaxValue.ToString ("E+9", _nfi));
\r
328 AssertEquals ("#03", "-E+9", Int32.MinValue.ToString ("E+9", _nfi));
\r
332 public void Test01018 () {
\r
333 AssertEquals ("#01", "E-9", 0.ToString ("E-9", _nfi));
\r
334 AssertEquals ("#02", "E-9", Int32.MaxValue.ToString ("E-9", _nfi));
\r
335 AssertEquals ("#03", "-E-9", Int32.MinValue.ToString ("E-9", _nfi));
\r
339 public void Test01019 () {
\r
340 AssertEquals ("#01", "E0", 0.ToString ("E0,", _nfi));
\r
341 AssertEquals ("#02", "E0", Int32.MaxValue.ToString ("E0,", _nfi));
\r
342 AssertEquals ("#03", "E0", Int32.MinValue.ToString ("E0,", _nfi));
\r
346 public void Test01020 () {
\r
347 AssertEquals ("#01", "E0", 0.ToString ("E0.", _nfi));
\r
348 AssertEquals ("#02", "E0", Int32.MaxValue.ToString ("E0.", _nfi));
\r
349 AssertEquals ("#03", "E0", Int32.MinValue.ToString ("E0.", _nfi));
\r
353 public void Test01021 () {
\r
354 AssertEquals ("#01", "E0.0", 0.ToString ("E0.0", _nfi));
\r
355 AssertEquals ("#02", "E10.2", Int32.MaxValue.ToString ("E0.0", _nfi));
\r
356 AssertEquals ("#03", "-E10.2", Int32.MinValue.ToString ("E0.0", _nfi));
\r
360 public void Test01022 () {
\r
361 AssertEquals ("#01", "E09", 0.ToString ("E0.9", _nfi));
\r
362 AssertEquals ("#02", "E09", Int32.MaxValue.ToString ("E0.9", _nfi));
\r
363 AssertEquals ("#03", "E09", Int32.MinValue.ToString ("E0.9", _nfi));
\r
367 public void Test01023 () {
\r
368 AssertEquals ("#01", "9.999999E+007", 99999990.ToString ("E", _nfi));
\r
369 AssertEquals ("#02", "9.999999E+007", 99999991.ToString ("E", _nfi));
\r
370 AssertEquals ("#03", "9.999999E+007", 99999992.ToString ("E", _nfi));
\r
371 AssertEquals ("#04", "9.999999E+007", 99999993.ToString ("E", _nfi));
\r
372 AssertEquals ("#05", "9.999999E+007", 99999994.ToString ("E", _nfi));
\r
373 AssertEquals ("#06", "1.000000E+008", 99999995.ToString ("E", _nfi));
\r
374 AssertEquals ("#07", "1.000000E+008", 99999996.ToString ("E", _nfi));
\r
375 AssertEquals ("#08", "1.000000E+008", 99999997.ToString ("E", _nfi));
\r
376 AssertEquals ("#09", "1.000000E+008", 99999998.ToString ("E", _nfi));
\r
377 AssertEquals ("#10", "1.000000E+008", 99999999.ToString ("E", _nfi));
\r
381 public void Test01024 () {
\r
382 AssertEquals ("#01", "-9.999999E+007", (-99999990).ToString ("E", _nfi));
\r
383 AssertEquals ("#02", "-9.999999E+007", (-99999991).ToString ("E", _nfi));
\r
384 AssertEquals ("#03", "-9.999999E+007", (-99999992).ToString ("E", _nfi));
\r
385 AssertEquals ("#04", "-9.999999E+007", (-99999993).ToString ("E", _nfi));
\r
386 AssertEquals ("#05", "-9.999999E+007", (-99999994).ToString ("E", _nfi));
\r
387 AssertEquals ("#06", "-1.000000E+008", (-99999995).ToString ("E", _nfi));
\r
388 AssertEquals ("#07", "-1.000000E+008", (-99999996).ToString ("E", _nfi));
\r
389 AssertEquals ("#08", "-1.000000E+008", (-99999997).ToString ("E", _nfi));
\r
390 AssertEquals ("#09", "-1.000000E+008", (-99999998).ToString ("E", _nfi));
\r
391 AssertEquals ("#10", "-1.000000E+008", (-99999999).ToString ("E", _nfi));
\r
395 public void Test01025 () {
\r
396 AssertEquals ("#01", "9.999998E+007", 99999980.ToString ("E", _nfi));
\r
397 AssertEquals ("#02", "9.999998E+007", 99999981.ToString ("E", _nfi));
\r
398 AssertEquals ("#03", "9.999998E+007", 99999982.ToString ("E", _nfi));
\r
399 AssertEquals ("#04", "9.999998E+007", 99999983.ToString ("E", _nfi));
\r
400 AssertEquals ("#05", "9.999998E+007", 99999984.ToString ("E", _nfi));
\r
401 AssertEquals ("#06", "9.999999E+007", 99999985.ToString ("E", _nfi));
\r
402 AssertEquals ("#07", "9.999999E+007", 99999986.ToString ("E", _nfi));
\r
403 AssertEquals ("#08", "9.999999E+007", 99999987.ToString ("E", _nfi));
\r
404 AssertEquals ("#09", "9.999999E+007", 99999988.ToString ("E", _nfi));
\r
405 AssertEquals ("#10", "9.999999E+007", 99999989.ToString ("E", _nfi));
\r
409 public void Test01026 () {
\r
410 AssertEquals ("#01", "-9.999998E+007", (-99999980).ToString ("E", _nfi));
\r
411 AssertEquals ("#02", "-9.999998E+007", (-99999981).ToString ("E", _nfi));
\r
412 AssertEquals ("#03", "-9.999998E+007", (-99999982).ToString ("E", _nfi));
\r
413 AssertEquals ("#04", "-9.999998E+007", (-99999983).ToString ("E", _nfi));
\r
414 AssertEquals ("#05", "-9.999998E+007", (-99999984).ToString ("E", _nfi));
\r
415 AssertEquals ("#06", "-9.999999E+007", (-99999985).ToString ("E", _nfi));
\r
416 AssertEquals ("#07", "-9.999999E+007", (-99999986).ToString ("E", _nfi));
\r
417 AssertEquals ("#08", "-9.999999E+007", (-99999987).ToString ("E", _nfi));
\r
418 AssertEquals ("#09", "-9.999999E+007", (-99999988).ToString ("E", _nfi));
\r
419 AssertEquals ("#10", "-9.999999E+007", (-99999989).ToString ("E", _nfi));
\r
423 public void Test01027 () {
\r
424 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
425 nfi.NumberDecimalSeparator = "#";
\r
426 AssertEquals ("#01", "-1#000000E+008", (-99999999).ToString ("E", nfi));
\r
430 public void Test01028 () {
\r
431 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
432 nfi.NegativeSign = "+";
\r
433 nfi.PositiveSign = "-";
\r
435 AssertEquals ("#01", "1.000000E-000", 1.ToString ("E", nfi));
\r
436 AssertEquals ("#02", "0.000000E-000", 0.ToString ("E", nfi));
\r
437 AssertEquals ("#03", "+1.000000E-000", (-1).ToString ("E", nfi));
\r
440 // Test02000- Int32 and F
\r
442 public void Test02000 () {
\r
443 AssertEquals ("#01", "0.00", 0.ToString ("F", _nfi));
\r
444 AssertEquals ("#02", "0.00", 0.ToString ("f", _nfi));
\r
445 AssertEquals ("#03", "-2147483648.00", Int32.MinValue.ToString ("F", _nfi));
\r
446 AssertEquals ("#04", "-2147483648.00", Int32.MinValue.ToString ("f", _nfi));
\r
447 AssertEquals ("#05", "2147483647.00", Int32.MaxValue.ToString ("F", _nfi));
\r
448 AssertEquals ("#06", "2147483647.00", Int32.MaxValue.ToString ("f", _nfi));
\r
452 public void Test02001 () {
\r
453 AssertEquals ("#01", "F ", 0.ToString ("F ", _nfi));
\r
454 AssertEquals ("#02", " F", 0.ToString (" F", _nfi));
\r
455 AssertEquals ("#03", " F ", 0.ToString (" F ", _nfi));
\r
459 public void Test02002 () {
\r
460 AssertEquals ("#01", "-F ", (-1).ToString ("F ", _nfi));
\r
461 AssertEquals ("#02", "- F", (-1).ToString (" F", _nfi));
\r
462 AssertEquals ("#03", "- F ", (-1).ToString (" F ", _nfi));
\r
466 public void Test02003 () {
\r
467 AssertEquals ("#01", "0", 0.ToString ("F0", _nfi));
\r
468 AssertEquals ("#02", "0.000000000", 0.ToString ("F9", _nfi));
\r
469 AssertEquals ("#03", "0.0000000000", 0.ToString ("F10", _nfi));
\r
470 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F99", _nfi));
\r
471 AssertEquals ("#05", "F100", 0.ToString ("F100", _nfi));
\r
475 public void Test02004 () {
\r
476 AssertEquals ("#01", "2147483647", Int32.MaxValue.ToString ("F0", _nfi));
\r
477 AssertEquals ("#02", "2147483647.000000000", Int32.MaxValue.ToString ("F9", _nfi));
\r
478 AssertEquals ("#03", "2147483647.0000000000", Int32.MaxValue.ToString ("F10", _nfi));
\r
479 AssertEquals ("#04", "2147483647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("F99", _nfi));
\r
480 AssertEquals ("#05", "F12147483647", Int32.MaxValue.ToString ("F100", _nfi));
\r
484 public void Test02005 () {
\r
485 AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString ("F0", _nfi));
\r
486 AssertEquals ("#02", "-2147483648.000000000", Int32.MinValue.ToString ("F9", _nfi));
\r
487 AssertEquals ("#03", "-2147483648.0000000000", Int32.MinValue.ToString ("F10", _nfi));
\r
488 AssertEquals ("#04", "-2147483648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("F99", _nfi));
\r
489 AssertEquals ("#05", "-F12147483648", Int32.MinValue.ToString ("F100", _nfi));
\r
493 public void Test02006 () {
\r
494 AssertEquals ("#01", "FF", 0.ToString ("FF", _nfi));
\r
495 AssertEquals ("#02", "F0F", 0.ToString ("F0F", _nfi));
\r
496 AssertEquals ("#03", "F0xF", 0.ToString ("F0xF", _nfi));
\r
500 public void Test02007 () {
\r
501 AssertEquals ("#01", "FF", Int32.MaxValue.ToString ("FF", _nfi));
\r
502 AssertEquals ("#02", "F2147483647F", Int32.MaxValue.ToString ("F0F", _nfi));
\r
503 AssertEquals ("#03", "F2147483647xF", Int32.MaxValue.ToString ("F0xF", _nfi));
\r
507 public void Test02008 () {
\r
508 AssertEquals ("#01", "-FF", Int32.MinValue.ToString ("FF", _nfi));
\r
509 AssertEquals ("#02", "-F2147483648F", Int32.MinValue.ToString ("F0F", _nfi));
\r
510 AssertEquals ("#03", "-F2147483648xF", Int32.MinValue.ToString ("F0xF", _nfi));
\r
514 public void Test02009 () {
\r
515 AssertEquals ("#01", "0.0000000000", 0.ToString ("F0000000000000000000000000000000000000010", _nfi));
\r
516 AssertEquals ("#02", "2147483647.0000000000", Int32.MaxValue.ToString ("F0000000000000000000000000000000000000010", _nfi));
\r
517 AssertEquals ("#03", "-2147483648.0000000000", Int32.MinValue.ToString ("F0000000000000000000000000000000000000010", _nfi));
\r
521 public void Test02010 () {
\r
522 AssertEquals ("#01", "+F", 0.ToString ("+F", _nfi));
\r
523 AssertEquals ("#02", "F+", 0.ToString ("F+", _nfi));
\r
524 AssertEquals ("#03", "+F+", 0.ToString ("+F+", _nfi));
\r
528 public void Test02011 () {
\r
529 AssertEquals ("#01", "+F", Int32.MaxValue.ToString ("+F", _nfi));
\r
530 AssertEquals ("#02", "F+", Int32.MaxValue.ToString ("F+", _nfi));
\r
531 AssertEquals ("#03", "+F+", Int32.MaxValue.ToString ("+F+", _nfi));
\r
535 public void Test02012 () {
\r
536 AssertEquals ("#01", "-+F", Int32.MinValue.ToString ("+F", _nfi));
\r
537 AssertEquals ("#02", "-F+", Int32.MinValue.ToString ("F+", _nfi));
\r
538 AssertEquals ("#03", "-+F+", Int32.MinValue.ToString ("+F+", _nfi));
\r
542 public void Test02013 () {
\r
543 AssertEquals ("#01", "-F", 0.ToString ("-F", _nfi));
\r
544 AssertEquals ("#02", "F-", 0.ToString ("F-", _nfi));
\r
545 AssertEquals ("#03", "-F-", 0.ToString ("-F-", _nfi));
\r
549 public void Test02014 () {
\r
550 AssertEquals ("#01", "-F", Int32.MaxValue.ToString ("-F", _nfi));
\r
551 AssertEquals ("#02", "F-", Int32.MaxValue.ToString ("F-", _nfi));
\r
552 AssertEquals ("#03", "-F-", Int32.MaxValue.ToString ("-F-", _nfi));
\r
556 public void Test02015 () {
\r
557 AssertEquals ("#01", "--F", Int32.MinValue.ToString ("-F", _nfi));
\r
558 AssertEquals ("#02", "-F-", Int32.MinValue.ToString ("F-", _nfi));
\r
559 AssertEquals ("#03", "--F-", Int32.MinValue.ToString ("-F-", _nfi));
\r
563 public void Test02016 () {
\r
564 AssertEquals ("#01", "F+0", 0.ToString ("F+0", _nfi));
\r
565 AssertEquals ("#02", "F+2147483647", Int32.MaxValue.ToString ("F+0", _nfi));
\r
566 AssertEquals ("#03", "-F+2147483648", Int32.MinValue.ToString ("F+0", _nfi));
\r
570 public void Test02017 () {
\r
571 AssertEquals ("#01", "F+9", 0.ToString ("F+9", _nfi));
\r
572 AssertEquals ("#02", "F+9", Int32.MaxValue.ToString ("F+9", _nfi));
\r
573 AssertEquals ("#03", "-F+9", Int32.MinValue.ToString ("F+9", _nfi));
\r
577 public void Test02018 () {
\r
578 AssertEquals ("#01", "F-9", 0.ToString ("F-9", _nfi));
\r
579 AssertEquals ("#02", "F-9", Int32.MaxValue.ToString ("F-9", _nfi));
\r
580 AssertEquals ("#03", "-F-9", Int32.MinValue.ToString ("F-9", _nfi));
\r
584 public void Test02019 () {
\r
585 AssertEquals ("#01", "F0", 0.ToString ("F0,", _nfi));
\r
586 AssertEquals ("#02", "F2147484", Int32.MaxValue.ToString ("F0,", _nfi));
\r
587 AssertEquals ("#03", "-F2147484", Int32.MinValue.ToString ("F0,", _nfi));
\r
591 public void Test02020 () {
\r
592 AssertEquals ("#01", "F0", 0.ToString ("F0.", _nfi));
\r
593 AssertEquals ("#02", "F2147483647", Int32.MaxValue.ToString ("F0.", _nfi));
\r
594 AssertEquals ("#03", "-F2147483648", Int32.MinValue.ToString ("F0.", _nfi));
\r
598 public void Test02021 () {
\r
599 AssertEquals ("#01", "F0.0", 0.ToString ("F0.0", _nfi));
\r
600 AssertEquals ("#02", "F2147483647.0", Int32.MaxValue.ToString ("F0.0", _nfi));
\r
601 AssertEquals ("#03", "-F2147483648.0", Int32.MinValue.ToString ("F0.0", _nfi));
\r
605 public void Test02022 () {
\r
606 AssertEquals ("#01", "F09", 0.ToString ("F0.9", _nfi));
\r
607 AssertEquals ("#02", "F21474836479", Int32.MaxValue.ToString ("F0.9", _nfi));
\r
608 AssertEquals ("#03", "-F21474836489", Int32.MinValue.ToString ("F0.9", _nfi));
\r
612 public void Test02023 () {
\r
613 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
614 nfi.NumberDecimalDigits = 0;
\r
615 AssertEquals ("#01", "0", 0.ToString ("F", nfi));
\r
616 nfi.NumberDecimalDigits = 1;
\r
617 AssertEquals ("#02", "0.0", 0.ToString ("F", nfi));
\r
618 nfi.NumberDecimalDigits = 99;
\r
619 AssertEquals ("#03", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("F", nfi));
\r
623 public void Test02024 () {
\r
624 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
625 nfi.NegativeSign = "";
\r
626 AssertEquals ("#01", "2147483648.00", Int32.MinValue.ToString ("F", nfi));
\r
627 nfi.NegativeSign = "-";
\r
628 AssertEquals ("#02", "-2147483648.00", Int32.MinValue.ToString ("F", nfi));
\r
629 nfi.NegativeSign = "+";
\r
630 AssertEquals ("#03", "+2147483648.00", Int32.MinValue.ToString ("F", nfi));
\r
631 nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
\r
632 AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648.00", Int32.MinValue.ToString ("F", nfi));
\r
636 public void Test02025 () {
\r
637 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
638 nfi.NegativeSign = "-";
\r
639 nfi.PositiveSign = "+";
\r
640 AssertEquals ("#01", "-1.00", (-1).ToString ("F", nfi));
\r
641 AssertEquals ("#02", "0.00", 0.ToString ("F", nfi));
\r
642 AssertEquals ("#03", "1.00",1.ToString ("F", nfi));
\r
646 public void Test02026 () {
\r
647 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
648 nfi.NegativeSign = "+";
\r
649 nfi.PositiveSign = "-";
\r
650 AssertEquals ("#01", "+1.00", (-1).ToString ("F", nfi));
\r
651 AssertEquals ("#02", "0.00", 0.ToString ("F", nfi));
\r
652 AssertEquals ("#03", "1.00",1.ToString ("F", nfi));
\r
656 public void Test02027 () {
\r
657 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
658 nfi.NumberDecimalSeparator = "#";
\r
659 AssertEquals ("#01", "1#00",1.ToString ("F", nfi));
\r
662 // Test03000 - Int32 and G
\r
664 public void Test03000 () {
\r
665 AssertEquals ("#01", "0", 0.ToString ("G", _nfi));
\r
666 AssertEquals ("#02", "0", 0.ToString ("g", _nfi));
\r
667 AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("G", _nfi));
\r
668 AssertEquals ("#04", "-2147483648", Int32.MinValue.ToString ("g", _nfi));
\r
669 AssertEquals ("#05", "2147483647", Int32.MaxValue.ToString ("G", _nfi));
\r
670 AssertEquals ("#06", "2147483647", Int32.MaxValue.ToString ("g", _nfi));
\r
674 public void Test03001 () {
\r
675 AssertEquals ("#01", "G ", 0.ToString ("G ", _nfi));
\r
676 AssertEquals ("#02", " G", 0.ToString (" G", _nfi));
\r
677 AssertEquals ("#03", " G ", 0.ToString (" G ", _nfi));
\r
681 public void Test03002 () {
\r
682 AssertEquals ("#01", "-G ", (-1).ToString ("G ", _nfi));
\r
683 AssertEquals ("#02", "- G", (-1).ToString (" G", _nfi));
\r
684 AssertEquals ("#03", "- G ", (-1).ToString (" G ", _nfi));
\r
688 public void Test03003 () {
\r
689 AssertEquals ("#01", "0", 0.ToString ("G0", _nfi));
\r
690 AssertEquals ("#02", "0", 0.ToString ("G9", _nfi));
\r
691 AssertEquals ("#03", "0", 0.ToString ("G10", _nfi));
\r
692 AssertEquals ("#04", "0", 0.ToString ("G99", _nfi));
\r
693 AssertEquals ("#05", "G100", 0.ToString ("G100", _nfi));
\r
697 public void Test03004 () {
\r
698 AssertEquals ("#01", "2147483647", Int32.MaxValue.ToString ("G0", _nfi));
\r
699 AssertEquals ("#02", "2.14748365E+09", Int32.MaxValue.ToString ("G9", _nfi));
\r
700 AssertEquals ("#03", "2147483647", Int32.MaxValue.ToString ("G10", _nfi));
\r
701 AssertEquals ("#04", "2147483647", Int32.MaxValue.ToString ("G99", _nfi));
\r
702 AssertEquals ("#05", "G12147483647", Int32.MaxValue.ToString ("G100", _nfi));
\r
706 public void Test03005 () {
\r
707 AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString ("G0", _nfi));
\r
708 AssertEquals ("#02", "-2.14748365E+09", Int32.MinValue.ToString ("G9", _nfi));
\r
709 AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("G10", _nfi));
\r
710 AssertEquals ("#04", "-2147483648", Int32.MinValue.ToString ("G99", _nfi));
\r
711 AssertEquals ("#05", "-G12147483648", Int32.MinValue.ToString ("G100", _nfi));
\r
715 public void Test03006 () {
\r
716 AssertEquals ("#01", "GF", 0.ToString ("GF", _nfi));
\r
717 AssertEquals ("#02", "G0F", 0.ToString ("G0F", _nfi));
\r
718 AssertEquals ("#03", "G0xF", 0.ToString ("G0xF", _nfi));
\r
722 public void Test03007 () {
\r
723 AssertEquals ("#01", "GF", Int32.MaxValue.ToString ("GF", _nfi));
\r
724 AssertEquals ("#02", "G2147483647F", Int32.MaxValue.ToString ("G0F", _nfi));
\r
725 AssertEquals ("#03", "G2147483647xF", Int32.MaxValue.ToString ("G0xF", _nfi));
\r
729 public void Test03008 () {
\r
730 AssertEquals ("#01", "-GF", Int32.MinValue.ToString ("GF", _nfi));
\r
731 AssertEquals ("#02", "-G2147483648F", Int32.MinValue.ToString ("G0F", _nfi));
\r
732 AssertEquals ("#03", "-G2147483648xF", Int32.MinValue.ToString ("G0xF", _nfi));
\r
736 public void Test03009 () {
\r
737 AssertEquals ("#01", "0", 0.ToString ("G0000000000000000000000000000000000000010", _nfi));
\r
738 AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("G0000000000000000000000000000000000000010", _nfi));
\r
739 AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("G0000000000000000000000000000000000000010", _nfi));
\r
743 public void Test03010 () {
\r
744 AssertEquals ("#01", "+G", 0.ToString ("+G", _nfi));
\r
745 AssertEquals ("#02", "G+", 0.ToString ("G+", _nfi));
\r
746 AssertEquals ("#03", "+G+", 0.ToString ("+G+", _nfi));
\r
750 public void Test03011 () {
\r
751 AssertEquals ("#01", "+G", Int32.MaxValue.ToString ("+G", _nfi));
\r
752 AssertEquals ("#02", "G+", Int32.MaxValue.ToString ("G+", _nfi));
\r
753 AssertEquals ("#03", "+G+", Int32.MaxValue.ToString ("+G+", _nfi));
\r
757 public void Test03012 () {
\r
758 AssertEquals ("#01", "-+G", Int32.MinValue.ToString ("+G", _nfi));
\r
759 AssertEquals ("#02", "-G+", Int32.MinValue.ToString ("G+", _nfi));
\r
760 AssertEquals ("#03", "-+G+", Int32.MinValue.ToString ("+G+", _nfi));
\r
764 public void Test03013 () {
\r
765 AssertEquals ("#01", "-G", 0.ToString ("-G", _nfi));
\r
766 AssertEquals ("#02", "G-", 0.ToString ("G-", _nfi));
\r
767 AssertEquals ("#03", "-G-", 0.ToString ("-G-", _nfi));
\r
771 public void Test03014 () {
\r
772 AssertEquals ("#01", "-G", Int32.MaxValue.ToString ("-G", _nfi));
\r
773 AssertEquals ("#02", "G-", Int32.MaxValue.ToString ("G-", _nfi));
\r
774 AssertEquals ("#03", "-G-", Int32.MaxValue.ToString ("-G-", _nfi));
\r
778 public void Test03015 () {
\r
779 AssertEquals ("#01", "--G", Int32.MinValue.ToString ("-G", _nfi));
\r
780 AssertEquals ("#02", "-G-", Int32.MinValue.ToString ("G-", _nfi));
\r
781 AssertEquals ("#03", "--G-", Int32.MinValue.ToString ("-G-", _nfi));
\r
785 public void Test03016 () {
\r
786 AssertEquals ("#01", "G+0", 0.ToString ("G+0", _nfi));
\r
787 AssertEquals ("#02", "G+2147483647", Int32.MaxValue.ToString ("G+0", _nfi));
\r
788 AssertEquals ("#03", "-G+2147483648", Int32.MinValue.ToString ("G+0", _nfi));
\r
792 public void Test03017 () {
\r
793 AssertEquals ("#01", "G+9", 0.ToString ("G+9", _nfi));
\r
794 AssertEquals ("#02", "G+9", Int32.MaxValue.ToString ("G+9", _nfi));
\r
795 AssertEquals ("#03", "-G+9", Int32.MinValue.ToString ("G+9", _nfi));
\r
799 public void Test03018 () {
\r
800 AssertEquals ("#01", "G-9", 0.ToString ("G-9", _nfi));
\r
801 AssertEquals ("#02", "G-9", Int32.MaxValue.ToString ("G-9", _nfi));
\r
802 AssertEquals ("#03", "-G-9", Int32.MinValue.ToString ("G-9", _nfi));
\r
806 public void Test03019 () {
\r
807 AssertEquals ("#01", "G0", 0.ToString ("G0,", _nfi));
\r
808 AssertEquals ("#02", "G2147484", Int32.MaxValue.ToString ("G0,", _nfi));
\r
809 AssertEquals ("#03", "-G2147484", Int32.MinValue.ToString ("G0,", _nfi));
\r
813 public void Test03020 () {
\r
814 AssertEquals ("#01", "G0", 0.ToString ("G0.", _nfi));
\r
815 AssertEquals ("#02", "G2147483647", Int32.MaxValue.ToString ("G0.", _nfi));
\r
816 AssertEquals ("#03", "-G2147483648", Int32.MinValue.ToString ("G0.", _nfi));
\r
820 public void Test03021 () {
\r
821 AssertEquals ("#01", "G0.0", 0.ToString ("G0.0", _nfi));
\r
822 AssertEquals ("#02", "G2147483647.0", Int32.MaxValue.ToString ("G0.0", _nfi));
\r
823 AssertEquals ("#03", "-G2147483648.0", Int32.MinValue.ToString ("G0.0", _nfi));
\r
827 public void Test03022 () {
\r
828 AssertEquals ("#01", "G09", 0.ToString ("G0.9", _nfi));
\r
829 AssertEquals ("#02", "G21474836479", Int32.MaxValue.ToString ("G0.9", _nfi));
\r
830 AssertEquals ("#03", "-G21474836489", Int32.MinValue.ToString ("G0.9", _nfi));
\r
834 public void Test03023 () {
\r
835 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
836 nfi.NumberDecimalDigits = 0;
\r
837 AssertEquals ("#01", "0", 0.ToString ("G", nfi));
\r
838 nfi.NumberDecimalDigits = 1;
\r
839 AssertEquals ("#02", "0", 0.ToString ("G", nfi));
\r
840 nfi.NumberDecimalDigits = 99;
\r
841 AssertEquals ("#03", "0", 0.ToString ("G", nfi));
\r
845 public void Test03024 () {
\r
846 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
847 nfi.NegativeSign = "";
\r
848 AssertEquals ("#01", "2147483648", Int32.MinValue.ToString ("G", nfi));
\r
849 nfi.NegativeSign = "-";
\r
850 AssertEquals ("#02", "-2147483648", Int32.MinValue.ToString ("G", nfi));
\r
851 nfi.NegativeSign = "+";
\r
852 AssertEquals ("#03", "+2147483648", Int32.MinValue.ToString ("G", nfi));
\r
853 nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
\r
854 AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2147483648", Int32.MinValue.ToString ("G", nfi));
\r
858 public void Test03025 () {
\r
859 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
860 nfi.NegativeSign = "-";
\r
861 nfi.PositiveSign = "+";
\r
862 AssertEquals ("#01", "-1", (-1).ToString ("G", nfi));
\r
863 AssertEquals ("#02", "0", 0.ToString ("G", nfi));
\r
864 AssertEquals ("#03", "1",1.ToString ("G", nfi));
\r
868 public void Test03026 () {
\r
869 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
870 nfi.NegativeSign = "+";
\r
871 nfi.PositiveSign = "-";
\r
872 AssertEquals ("#01", "+1", (-1).ToString ("G", nfi));
\r
873 AssertEquals ("#02", "0", 0.ToString ("G", nfi));
\r
874 AssertEquals ("#03", "1",1.ToString ("G", nfi));
\r
878 public void Test03027 () {
\r
879 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
880 nfi.NumberDecimalSeparator = "#";
\r
881 AssertEquals ("#01", "1#2E+02",123.ToString ("G2", nfi));
\r
884 // Test04000 - Int32 and N
\r
886 public void Test04000 () {
\r
887 AssertEquals ("#01", "0.00", 0.ToString ("N", _nfi));
\r
888 AssertEquals ("#02", "0.00", 0.ToString ("n", _nfi));
\r
889 AssertEquals ("#03", "-2,147,483,648.00", Int32.MinValue.ToString ("N", _nfi));
\r
890 AssertEquals ("#04", "-2,147,483,648.00", Int32.MinValue.ToString ("n", _nfi));
\r
891 AssertEquals ("#05", "2,147,483,647.00", Int32.MaxValue.ToString ("N", _nfi));
\r
892 AssertEquals ("#06", "2,147,483,647.00", Int32.MaxValue.ToString ("n", _nfi));
\r
896 public void Test04001 () {
\r
897 AssertEquals ("#01", "N ", 0.ToString ("N ", _nfi));
\r
898 AssertEquals ("#02", " N", 0.ToString (" N", _nfi));
\r
899 AssertEquals ("#03", " N ", 0.ToString (" N ", _nfi));
\r
903 public void Test04002 () {
\r
904 AssertEquals ("#01", "-N ", (-1).ToString ("N ", _nfi));
\r
905 AssertEquals ("#02", "- N", (-1).ToString (" N", _nfi));
\r
906 AssertEquals ("#03", "- N ", (-1).ToString (" N ", _nfi));
\r
910 public void Test04003 () {
\r
911 AssertEquals ("#01", "0", 0.ToString ("N0", _nfi));
\r
912 AssertEquals ("#02", "0.000000000", 0.ToString ("N9", _nfi));
\r
913 AssertEquals ("#03", "0.0000000000", 0.ToString ("N10", _nfi));
\r
914 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N99", _nfi));
\r
915 AssertEquals ("#05", "N100", 0.ToString ("N100", _nfi));
\r
919 public void Test04004 () {
\r
920 AssertEquals ("#01", "2,147,483,647", Int32.MaxValue.ToString ("N0", _nfi));
\r
921 AssertEquals ("#02", "2,147,483,647.000000000", Int32.MaxValue.ToString ("N9", _nfi));
\r
922 AssertEquals ("#03", "2,147,483,647.0000000000", Int32.MaxValue.ToString ("N10", _nfi));
\r
923 AssertEquals ("#04", "2,147,483,647.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MaxValue.ToString ("N99", _nfi));
\r
924 AssertEquals ("#05", "N12147483647", Int32.MaxValue.ToString ("N100", _nfi));
\r
928 public void Test04005 () {
\r
929 AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("N0", _nfi));
\r
930 AssertEquals ("#02", "-2,147,483,648.000000000", Int32.MinValue.ToString ("N9", _nfi));
\r
931 AssertEquals ("#03", "-2,147,483,648.0000000000", Int32.MinValue.ToString ("N10", _nfi));
\r
932 AssertEquals ("#04", "-2,147,483,648.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Int32.MinValue.ToString ("N99", _nfi));
\r
933 AssertEquals ("#05", "-N12147483648", Int32.MinValue.ToString ("N100", _nfi));
\r
937 public void Test04006 () {
\r
938 AssertEquals ("#01", "NF", 0.ToString ("NF", _nfi));
\r
939 AssertEquals ("#02", "N0F", 0.ToString ("N0F", _nfi));
\r
940 AssertEquals ("#03", "N0xF", 0.ToString ("N0xF", _nfi));
\r
944 public void Test04007 () {
\r
945 AssertEquals ("#01", "NF", Int32.MaxValue.ToString ("NF", _nfi));
\r
946 AssertEquals ("#02", "N2147483647F", Int32.MaxValue.ToString ("N0F", _nfi));
\r
947 AssertEquals ("#03", "N2147483647xF", Int32.MaxValue.ToString ("N0xF", _nfi));
\r
951 public void Test04008 () {
\r
952 AssertEquals ("#01", "-NF", Int32.MinValue.ToString ("NF", _nfi));
\r
953 AssertEquals ("#02", "-N2147483648F", Int32.MinValue.ToString ("N0F", _nfi));
\r
954 AssertEquals ("#03", "-N2147483648xF", Int32.MinValue.ToString ("N0xF", _nfi));
\r
958 public void Test04009 () {
\r
959 AssertEquals ("#01", "0.0000000000", 0.ToString ("N0000000000000000000000000000000000000010", _nfi));
\r
960 AssertEquals ("#02", "2,147,483,647.0000000000", Int32.MaxValue.ToString ("N0000000000000000000000000000000000000010", _nfi));
\r
961 AssertEquals ("#03", "-2,147,483,648.0000000000", Int32.MinValue.ToString ("N0000000000000000000000000000000000000010", _nfi));
\r
965 public void Test04010 () {
\r
966 AssertEquals ("#01", "+N", 0.ToString ("+N", _nfi));
\r
967 AssertEquals ("#02", "N+", 0.ToString ("N+", _nfi));
\r
968 AssertEquals ("#03", "+N+", 0.ToString ("+N+", _nfi));
\r
972 public void Test04011 () {
\r
973 AssertEquals ("#01", "+N", Int32.MaxValue.ToString ("+N", _nfi));
\r
974 AssertEquals ("#02", "N+", Int32.MaxValue.ToString ("N+", _nfi));
\r
975 AssertEquals ("#03", "+N+", Int32.MaxValue.ToString ("+N+", _nfi));
\r
979 public void Test04012 () {
\r
980 AssertEquals ("#01", "-+N", Int32.MinValue.ToString ("+N", _nfi));
\r
981 AssertEquals ("#02", "-N+", Int32.MinValue.ToString ("N+", _nfi));
\r
982 AssertEquals ("#03", "-+N+", Int32.MinValue.ToString ("+N+", _nfi));
\r
986 public void Test04013 () {
\r
987 AssertEquals ("#01", "-N", 0.ToString ("-N", _nfi));
\r
988 AssertEquals ("#02", "N-", 0.ToString ("N-", _nfi));
\r
989 AssertEquals ("#03", "-N-", 0.ToString ("-N-", _nfi));
\r
993 public void Test04014 () {
\r
994 AssertEquals ("#01", "-N", Int32.MaxValue.ToString ("-N", _nfi));
\r
995 AssertEquals ("#02", "N-", Int32.MaxValue.ToString ("N-", _nfi));
\r
996 AssertEquals ("#03", "-N-", Int32.MaxValue.ToString ("-N-", _nfi));
\r
1000 public void Test04015 () {
\r
1001 AssertEquals ("#01", "--N", Int32.MinValue.ToString ("-N", _nfi));
\r
1002 AssertEquals ("#02", "-N-", Int32.MinValue.ToString ("N-", _nfi));
\r
1003 AssertEquals ("#03", "--N-", Int32.MinValue.ToString ("-N-", _nfi));
\r
1007 public void Test04016 () {
\r
1008 AssertEquals ("#01", "N+0", 0.ToString ("N+0", _nfi));
\r
1009 AssertEquals ("#02", "N+2147483647", Int32.MaxValue.ToString ("N+0", _nfi));
\r
1010 AssertEquals ("#03", "-N+2147483648", Int32.MinValue.ToString ("N+0", _nfi));
\r
1014 public void Test04017 () {
\r
1015 AssertEquals ("#01", "N+9", 0.ToString ("N+9", _nfi));
\r
1016 AssertEquals ("#02", "N+9", Int32.MaxValue.ToString ("N+9", _nfi));
\r
1017 AssertEquals ("#03", "-N+9", Int32.MinValue.ToString ("N+9", _nfi));
\r
1021 public void Test04018 () {
\r
1022 AssertEquals ("#01", "N-9", 0.ToString ("N-9", _nfi));
\r
1023 AssertEquals ("#02", "N-9", Int32.MaxValue.ToString ("N-9", _nfi));
\r
1024 AssertEquals ("#03", "-N-9", Int32.MinValue.ToString ("N-9", _nfi));
\r
1028 public void Test04019 () {
\r
1029 AssertEquals ("#01", "N0", 0.ToString ("N0,", _nfi));
\r
1030 AssertEquals ("#02", "N2147484", Int32.MaxValue.ToString ("N0,", _nfi));
\r
1031 AssertEquals ("#03", "-N2147484", Int32.MinValue.ToString ("N0,", _nfi));
\r
1035 public void Test04020 () {
\r
1036 AssertEquals ("#01", "N0", 0.ToString ("N0.", _nfi));
\r
1037 AssertEquals ("#02", "N2147483647", Int32.MaxValue.ToString ("N0.", _nfi));
\r
1038 AssertEquals ("#03", "-N2147483648", Int32.MinValue.ToString ("N0.", _nfi));
\r
1042 public void Test04021 () {
\r
1043 AssertEquals ("#01", "N0.0", 0.ToString ("N0.0", _nfi));
\r
1044 AssertEquals ("#02", "N2147483647.0", Int32.MaxValue.ToString ("N0.0", _nfi));
\r
1045 AssertEquals ("#03", "-N2147483648.0", Int32.MinValue.ToString ("N0.0", _nfi));
\r
1049 public void Test04022 () {
\r
1050 AssertEquals ("#01", "N09", 0.ToString ("N0.9", _nfi));
\r
1051 AssertEquals ("#02", "N21474836479", Int32.MaxValue.ToString ("N0.9", _nfi));
\r
1052 AssertEquals ("#03", "-N21474836489", Int32.MinValue.ToString ("N0.9", _nfi));
\r
1056 public void Test04023 () {
\r
1057 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1058 nfi.NumberDecimalDigits = 0;
\r
1059 AssertEquals ("#01", "0", 0.ToString ("N", nfi));
\r
1060 nfi.NumberDecimalDigits = 1;
\r
1061 AssertEquals ("#02", "0.0", 0.ToString ("N", nfi));
\r
1062 nfi.NumberDecimalDigits = 99;
\r
1063 AssertEquals ("#03", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("N", nfi));
\r
1067 public void Test04024 () {
\r
1068 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1069 nfi.NegativeSign = "";
\r
1070 AssertEquals ("#01", "2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));
\r
1071 nfi.NegativeSign = "-";
\r
1072 AssertEquals ("#02", "-2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));
\r
1073 nfi.NegativeSign = "+";
\r
1074 AssertEquals ("#03", "+2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));
\r
1075 nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
\r
1076 AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ2,147,483,648.00", Int32.MinValue.ToString ("N", nfi));
\r
1080 public void Test04025 () {
\r
1081 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1082 nfi.NegativeSign = "-";
\r
1083 nfi.PositiveSign = "+";
\r
1084 AssertEquals ("#01", "-1.00", (-1).ToString ("N", nfi));
\r
1085 AssertEquals ("#02", "0.00", 0.ToString ("N", nfi));
\r
1086 AssertEquals ("#03", "1.00",1.ToString ("N", nfi));
\r
1090 public void Test04026 () {
\r
1091 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1092 nfi.NegativeSign = "+";
\r
1093 nfi.PositiveSign = "-";
\r
1094 AssertEquals ("#01", "+1.00", (-1).ToString ("N", nfi));
\r
1095 AssertEquals ("#02", "0.00", 0.ToString ("N", nfi));
\r
1096 AssertEquals ("#03", "1.00",1.ToString ("N", nfi));
\r
1100 public void Test04027 () {
\r
1101 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1102 nfi.NumberDecimalSeparator = "#";
\r
1103 AssertEquals ("#01", "123#0",123.ToString ("N1", nfi));
\r
1107 public void Test04028 () {
\r
1108 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1109 nfi.NumberGroupSeparator = "-";
\r
1110 AssertEquals ("#01", "-2-147-483-648.0",Int32.MinValue.ToString ("N1", nfi));
\r
1114 public void Test04029 () {
\r
1115 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1116 nfi.NumberGroupSizes = new int [] {};
\r
1117 AssertEquals ("#01", "-2147483648.0",Int32.MinValue.ToString ("N1", nfi));
\r
1118 nfi.NumberGroupSizes = new int [] {0};
\r
1119 AssertEquals ("#02", "-2147483648.0",Int32.MinValue.ToString ("N1", nfi));
\r
1120 nfi.NumberGroupSizes = new int [] {1};
\r
1121 AssertEquals ("#03", "-2,1,4,7,4,8,3,6,4,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1122 nfi.NumberGroupSizes = new int [] {3};
\r
1123 AssertEquals ("#04", "-2,147,483,648.0",Int32.MinValue.ToString ("N1", nfi));
\r
1124 nfi.NumberGroupSizes = new int [] {9};
\r
1125 AssertEquals ("#05", "-2,147483648.0",Int32.MinValue.ToString ("N1", nfi));
\r
1129 public void Test04030 () {
\r
1130 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1131 nfi.NumberGroupSizes = new int [] {1,2};
\r
1132 AssertEquals ("#01", "-2,14,74,83,64,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1133 nfi.NumberGroupSizes = new int [] {1,2,3};
\r
1134 AssertEquals ("#02", "-2,147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1135 nfi.NumberGroupSizes = new int [] {1,2,3,4};
\r
1136 AssertEquals ("#03", "-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1137 nfi.NumberGroupSizes = new int [] {1,2,1,2,1,2,1};
\r
1138 AssertEquals ("#04", "-2,14,7,48,3,64,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1139 nfi.NumberGroupSizes = new int [] {1,0};
\r
1140 AssertEquals ("#05", "-214748364,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1141 nfi.NumberGroupSizes = new int [] {1,2,0};
\r
1142 AssertEquals ("#06", "-2147483,64,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1143 nfi.NumberGroupSizes = new int [] {1,2,3,0};
\r
1144 AssertEquals ("#07", "-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1145 nfi.NumberGroupSizes = new int [] {1,2,3,4,0};
\r
1146 AssertEquals ("#08", "-2147,483,64,8.0",Int32.MinValue.ToString ("N1", nfi));
\r
1150 public void Test04031 () {
\r
1151 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1152 nfi.NegativeSign = "1234567890";
\r
1153 AssertEquals ("#01", "12345678902,147,483,648.00", Int32.MinValue.ToString ("N", nfi));
\r
1156 // Test05000 - Int32 and P
\r
1158 public void Test05000 () {
\r
1159 AssertEquals ("#01", "0.00 %", 0.ToString ("P", _nfi));
\r
1160 AssertEquals ("#02", "0.00 %", 0.ToString ("p", _nfi));
\r
1161 AssertEquals ("#03", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", _nfi));
\r
1162 AssertEquals ("#04", "-214,748,364,800.00 %", Int32.MinValue.ToString ("p", _nfi));
\r
1163 AssertEquals ("#05", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", _nfi));
\r
1164 AssertEquals ("#06", "214,748,364,700.00 %", Int32.MaxValue.ToString ("p", _nfi));
\r
1168 public void Test05001 () {
\r
1169 AssertEquals ("#01", "P ", 0.ToString ("P ", _nfi));
\r
1170 AssertEquals ("#02", " P", 0.ToString (" P", _nfi));
\r
1171 AssertEquals ("#03", " P ", 0.ToString (" P ", _nfi));
\r
1175 public void Test05002 () {
\r
1176 AssertEquals ("#01", "-P ", (-1).ToString ("P ", _nfi));
\r
1177 AssertEquals ("#02", "- P", (-1).ToString (" P", _nfi));
\r
1178 AssertEquals ("#03", "- P ", (-1).ToString (" P ", _nfi));
\r
1182 public void Test05003 () {
\r
1183 AssertEquals ("#01", "0 %", 0.ToString ("P0", _nfi));
\r
1184 AssertEquals ("#02", "0.000000000 %", 0.ToString ("P9", _nfi));
\r
1185 AssertEquals ("#03", "0.0000000000 %", 0.ToString ("P10", _nfi));
\r
1186 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P99", _nfi));
\r
1187 AssertEquals ("#05", "P100", 0.ToString ("P100", _nfi));
\r
1191 public void Test05004 () {
\r
1192 AssertEquals ("#01", "214,748,364,700 %", Int32.MaxValue.ToString ("P0", _nfi));
\r
1193 AssertEquals ("#02", "214,748,364,700.000000000 %", Int32.MaxValue.ToString ("P9", _nfi));
\r
1194 AssertEquals ("#03", "214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P10", _nfi));
\r
1195 AssertEquals ("#04", "214,748,364,700.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MaxValue.ToString ("P99", _nfi));
\r
1196 AssertEquals ("#05", "P12147483647", Int32.MaxValue.ToString ("P100", _nfi));
\r
1200 public void Test05005 () {
\r
1201 AssertEquals ("#01", "-214,748,364,800 %", Int32.MinValue.ToString ("P0", _nfi));
\r
1202 AssertEquals ("#02", "-214,748,364,800.000000000 %", Int32.MinValue.ToString ("P9", _nfi));
\r
1203 AssertEquals ("#03", "-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P10", _nfi));
\r
1204 AssertEquals ("#04", "-214,748,364,800.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Int32.MinValue.ToString ("P99", _nfi));
\r
1205 AssertEquals ("#05", "-P12147483648", Int32.MinValue.ToString ("P100", _nfi));
\r
1209 public void Test05006 () {
\r
1210 AssertEquals ("#01", "PF", 0.ToString ("PF", _nfi));
\r
1211 AssertEquals ("#02", "P0F", 0.ToString ("P0F", _nfi));
\r
1212 AssertEquals ("#03", "P0xF", 0.ToString ("P0xF", _nfi));
\r
1216 public void Test05007 () {
\r
1217 AssertEquals ("#01", "PF", Int32.MaxValue.ToString ("PF", _nfi));
\r
1218 AssertEquals ("#02", "P2147483647F", Int32.MaxValue.ToString ("P0F", _nfi));
\r
1219 AssertEquals ("#03", "P2147483647xF", Int32.MaxValue.ToString ("P0xF", _nfi));
\r
1223 public void Test05008 () {
\r
1224 AssertEquals ("#01", "-PF", Int32.MinValue.ToString ("PF", _nfi));
\r
1225 AssertEquals ("#02", "-P2147483648F", Int32.MinValue.ToString ("P0F", _nfi));
\r
1226 AssertEquals ("#03", "-P2147483648xF", Int32.MinValue.ToString ("P0xF", _nfi));
\r
1230 public void Test05009 () {
\r
1231 AssertEquals ("#01", "0.0000000000 %", 0.ToString ("P0000000000000000000000000000000000000010", _nfi));
\r
1232 AssertEquals ("#02", "214,748,364,700.0000000000 %", Int32.MaxValue.ToString ("P0000000000000000000000000000000000000010", _nfi));
\r
1233 AssertEquals ("#03", "-214,748,364,800.0000000000 %", Int32.MinValue.ToString ("P0000000000000000000000000000000000000010", _nfi));
\r
1237 public void Test05010 () {
\r
1238 AssertEquals ("#01", "+P", 0.ToString ("+P", _nfi));
\r
1239 AssertEquals ("#02", "P+", 0.ToString ("P+", _nfi));
\r
1240 AssertEquals ("#03", "+P+", 0.ToString ("+P+", _nfi));
\r
1244 public void Test05011 () {
\r
1245 AssertEquals ("#01", "+P", Int32.MaxValue.ToString ("+P", _nfi));
\r
1246 AssertEquals ("#02", "P+", Int32.MaxValue.ToString ("P+", _nfi));
\r
1247 AssertEquals ("#03", "+P+", Int32.MaxValue.ToString ("+P+", _nfi));
\r
1251 public void Test05012 () {
\r
1252 AssertEquals ("#01", "-+P", Int32.MinValue.ToString ("+P", _nfi));
\r
1253 AssertEquals ("#02", "-P+", Int32.MinValue.ToString ("P+", _nfi));
\r
1254 AssertEquals ("#03", "-+P+", Int32.MinValue.ToString ("+P+", _nfi));
\r
1258 public void Test05013 () {
\r
1259 AssertEquals ("#01", "-P", 0.ToString ("-P", _nfi));
\r
1260 AssertEquals ("#02", "P-", 0.ToString ("P-", _nfi));
\r
1261 AssertEquals ("#03", "-P-", 0.ToString ("-P-", _nfi));
\r
1265 public void Test05014 () {
\r
1266 AssertEquals ("#01", "-P", Int32.MaxValue.ToString ("-P", _nfi));
\r
1267 AssertEquals ("#02", "P-", Int32.MaxValue.ToString ("P-", _nfi));
\r
1268 AssertEquals ("#03", "-P-", Int32.MaxValue.ToString ("-P-", _nfi));
\r
1272 public void Test05015 () {
\r
1273 AssertEquals ("#01", "--P", Int32.MinValue.ToString ("-P", _nfi));
\r
1274 AssertEquals ("#02", "-P-", Int32.MinValue.ToString ("P-", _nfi));
\r
1275 AssertEquals ("#03", "--P-", Int32.MinValue.ToString ("-P-", _nfi));
\r
1279 public void Test05016 () {
\r
1280 AssertEquals ("#01", "P+0", 0.ToString ("P+0", _nfi));
\r
1281 AssertEquals ("#02", "P+2147483647", Int32.MaxValue.ToString ("P+0", _nfi));
\r
1282 AssertEquals ("#03", "-P+2147483648", Int32.MinValue.ToString ("P+0", _nfi));
\r
1286 public void Test05017 () {
\r
1287 AssertEquals ("#01", "P+9", 0.ToString ("P+9", _nfi));
\r
1288 AssertEquals ("#02", "P+9", Int32.MaxValue.ToString ("P+9", _nfi));
\r
1289 AssertEquals ("#03", "-P+9", Int32.MinValue.ToString ("P+9", _nfi));
\r
1293 public void Test05018 () {
\r
1294 AssertEquals ("#01", "P-9", 0.ToString ("P-9", _nfi));
\r
1295 AssertEquals ("#02", "P-9", Int32.MaxValue.ToString ("P-9", _nfi));
\r
1296 AssertEquals ("#03", "-P-9", Int32.MinValue.ToString ("P-9", _nfi));
\r
1300 public void Test05019 () {
\r
1301 AssertEquals ("#01", "P0", 0.ToString ("P0,", _nfi));
\r
1302 AssertEquals ("#02", "P2147484", Int32.MaxValue.ToString ("P0,", _nfi));
\r
1303 AssertEquals ("#03", "-P2147484", Int32.MinValue.ToString ("P0,", _nfi));
\r
1307 public void Test05020 () {
\r
1308 AssertEquals ("#01", "P0", 0.ToString ("P0.", _nfi));
\r
1309 AssertEquals ("#02", "P2147483647", Int32.MaxValue.ToString ("P0.", _nfi));
\r
1310 AssertEquals ("#03", "-P2147483648", Int32.MinValue.ToString ("P0.", _nfi));
\r
1314 public void Test05021 () {
\r
1315 AssertEquals ("#01", "P0.0", 0.ToString ("P0.0", _nfi));
\r
1316 AssertEquals ("#02", "P2147483647.0", Int32.MaxValue.ToString ("P0.0", _nfi));
\r
1317 AssertEquals ("#03", "-P2147483648.0", Int32.MinValue.ToString ("P0.0", _nfi));
\r
1321 public void Test05022 () {
\r
1322 AssertEquals ("#01", "P09", 0.ToString ("P0.9", _nfi));
\r
1323 AssertEquals ("#02", "P21474836479", Int32.MaxValue.ToString ("P0.9", _nfi));
\r
1324 AssertEquals ("#03", "-P21474836489", Int32.MinValue.ToString ("P0.9", _nfi));
\r
1328 public void Test05023 () {
\r
1329 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1330 nfi.PercentDecimalDigits = 0;
\r
1331 AssertEquals ("#01", "0 %", 0.ToString ("P", nfi));
\r
1332 nfi.PercentDecimalDigits = 1;
\r
1333 AssertEquals ("#02", "0.0 %", 0.ToString ("P", nfi));
\r
1334 nfi.PercentDecimalDigits = 99;
\r
1335 AssertEquals ("#03", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.ToString ("P", nfi));
\r
1339 public void Test05024 () {
\r
1340 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1341 nfi.NegativeSign = "";
\r
1342 AssertEquals ("#01", "214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1343 nfi.NegativeSign = "-";
\r
1344 AssertEquals ("#02", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1345 nfi.NegativeSign = "+";
\r
1346 AssertEquals ("#03", "+214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1347 nfi.NegativeSign = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ";
\r
1348 AssertEquals ("#04", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMPOPQRSTUVWXYZ214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1352 public void Test05025 () {
\r
1353 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1354 nfi.NegativeSign = "-";
\r
1355 nfi.PositiveSign = "+";
\r
1356 AssertEquals ("#01", "-100.00 %", (-1).ToString ("P", nfi));
\r
1357 AssertEquals ("#02", "0.00 %", 0.ToString ("P", nfi));
\r
1358 AssertEquals ("#03", "100.00 %",1.ToString ("P", nfi));
\r
1362 public void Test05026 () {
\r
1363 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1364 nfi.NegativeSign = "+";
\r
1365 nfi.PositiveSign = "-";
\r
1366 AssertEquals ("#01", "+100.00 %", (-1).ToString ("P", nfi));
\r
1367 AssertEquals ("#02", "0.00 %", 0.ToString ("P", nfi));
\r
1368 AssertEquals ("#03", "100.00 %",1.ToString ("P", nfi));
\r
1372 public void Test05027 () {
\r
1373 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1374 nfi.PercentDecimalSeparator = "#";
\r
1375 AssertEquals ("#01", "12,300#0 %",123.ToString ("P1", nfi));
\r
1379 public void Test05028 () {
\r
1380 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1381 nfi.PercentGroupSeparator = "-";
\r
1382 AssertEquals ("#01", "-214-748-364-800.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1386 public void Test05029 () {
\r
1387 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1388 nfi.PercentGroupSizes = new int [] {};
\r
1389 AssertEquals ("#01", "-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1390 nfi.PercentGroupSizes = new int [] {0};
\r
1391 AssertEquals ("#02", "-214748364800.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1392 nfi.PercentGroupSizes = new int [] {1};
\r
1393 AssertEquals ("#03", "-2,1,4,7,4,8,3,6,4,8,0,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1394 nfi.PercentGroupSizes = new int [] {3};
\r
1395 AssertEquals ("#04", "-214,748,364,800.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1396 nfi.PercentGroupSizes = new int [] {9};
\r
1397 AssertEquals ("#05", "-214,748364800.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1401 public void Test05030 () {
\r
1402 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1403 nfi.PercentGroupSizes = new int [] {1,2};
\r
1404 AssertEquals ("#01", "-2,14,74,83,64,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1405 nfi.PercentGroupSizes = new int [] {1,2,3};
\r
1406 AssertEquals ("#02", "-214,748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1407 nfi.PercentGroupSizes = new int [] {1,2,3,4};
\r
1408 AssertEquals ("#03", "-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1409 nfi.PercentGroupSizes = new int [] {1,2,1,2,1,2,1};
\r
1410 AssertEquals ("#04", "-2,1,4,74,8,36,4,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1411 nfi.PercentGroupSizes = new int [] {1,0};
\r
1412 AssertEquals ("#05", "-21474836480,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1413 nfi.PercentGroupSizes = new int [] {1,2,0};
\r
1414 AssertEquals ("#06", "-214748364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1415 nfi.PercentGroupSizes = new int [] {1,2,3,0};
\r
1416 AssertEquals ("#07", "-214748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1417 nfi.PercentGroupSizes = new int [] {1,2,3,4,0};
\r
1418 AssertEquals ("#08", "-21,4748,364,80,0.0 %",Int32.MinValue.ToString ("P1", nfi));
\r
1422 public void Test05031 () {
\r
1423 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1424 nfi.NegativeSign = "1234567890";
\r
1425 AssertEquals ("#01", "1234567890214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1429 public void Test05032 () {
\r
1430 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1431 nfi.PercentNegativePattern = 0;
\r
1432 AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1433 AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));
\r
1434 AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));
\r
1438 public void Test05033 () {
\r
1439 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1440 nfi.PercentNegativePattern = 1;
\r
1441 AssertEquals ("#01", "-214,748,364,800.00%", Int32.MinValue.ToString ("P", nfi));
\r
1442 AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));
\r
1443 AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));
\r
1447 public void Test05034 () {
\r
1448 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1449 nfi.PercentNegativePattern = 2;
\r
1450 AssertEquals ("#01", "-%214,748,364,800.00", Int32.MinValue.ToString ("P", nfi));
\r
1451 AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));
\r
1452 AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));
\r
1456 public void Test05035 () {
\r
1457 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1458 nfi.PercentPositivePattern = 0;
\r
1459 AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1460 AssertEquals ("#02", "214,748,364,700.00 %", Int32.MaxValue.ToString ("P", nfi));
\r
1461 AssertEquals ("#03", "0.00 %", 0.ToString ("P", nfi));
\r
1465 public void Test05036 () {
\r
1466 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1467 nfi.PercentPositivePattern = 1;
\r
1468 AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1469 AssertEquals ("#02", "214,748,364,700.00%", Int32.MaxValue.ToString ("P", nfi));
\r
1470 AssertEquals ("#03", "0.00%", 0.ToString ("P", nfi));
\r
1474 public void Test05037 () {
\r
1475 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
1476 nfi.PercentPositivePattern = 2;
\r
1477 AssertEquals ("#01", "-214,748,364,800.00 %", Int32.MinValue.ToString ("P", nfi));
\r
1478 AssertEquals ("#02", "%214,748,364,700.00", Int32.MaxValue.ToString ("P", nfi));
\r
1479 AssertEquals ("#03", "%0.00", 0.ToString ("P", nfi));
\r
1482 // Test06000 - Int32 and R
\r
1484 [ExpectedException (typeof (FormatException))]
\r
1485 public void Test06000 () {
\r
1486 AssertEquals ("#01", "0", 0.ToString ("R", _nfi));
\r
1489 // Test07000- Int32 and X
\r
1491 public void Test07000 () {
\r
1492 AssertEquals ("#01", "0", 0.ToString ("X", _nfi));
\r
1493 AssertEquals ("#02", "0", 0.ToString ("x", _nfi));
\r
1494 AssertEquals ("#03", "80000000", Int32.MinValue.ToString ("X", _nfi));
\r
1495 AssertEquals ("#04", "80000000", Int32.MinValue.ToString ("x", _nfi));
\r
1496 AssertEquals ("#05", "7FFFFFFF", Int32.MaxValue.ToString ("X", _nfi));
\r
1497 AssertEquals ("#06", "7fffffff", Int32.MaxValue.ToString ("x", _nfi));
\r
1501 public void Test07001 () {
\r
1502 AssertEquals ("#01", "X ", 0.ToString ("X ", _nfi));
\r
1503 AssertEquals ("#02", " X", 0.ToString (" X", _nfi));
\r
1504 AssertEquals ("#03", " X ", 0.ToString (" X ", _nfi));
\r
1508 public void Test07002 () {
\r
1509 AssertEquals ("#01", "-X ", (-1).ToString ("X ", _nfi));
\r
1510 AssertEquals ("#02", "- X", (-1).ToString (" X", _nfi));
\r
1511 AssertEquals ("#03", "- X ", (-1).ToString (" X ", _nfi));
\r
1515 public void Test07003 () {
\r
1516 AssertEquals ("#01", "0", 0.ToString ("X0", _nfi));
\r
1517 AssertEquals ("#02", "0000000000", 0.ToString ("X10", _nfi));
\r
1518 AssertEquals ("#03", "00000000000", 0.ToString ("X11", _nfi));
\r
1519 AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.ToString ("X99", _nfi));
\r
1520 AssertEquals ("#05", "X100", 0.ToString ("X100", _nfi));
\r
1524 public void Test07004 () {
\r
1525 AssertEquals ("#01", "7FFFFFFF", Int32.MaxValue.ToString ("X0", _nfi));
\r
1526 AssertEquals ("#02", "007FFFFFFF", Int32.MaxValue.ToString ("X10", _nfi));
\r
1527 AssertEquals ("#03", "0007FFFFFFF", Int32.MaxValue.ToString ("X11", _nfi));
\r
1528 AssertEquals ("#04", "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007FFFFFFF", Int32.MaxValue.ToString ("X99", _nfi));
\r
1529 AssertEquals ("#05", "X12147483647", Int32.MaxValue.ToString ("X100", _nfi));
\r
1533 public void Test07005 () {
\r
1534 AssertEquals ("#01", "80000000", Int32.MinValue.ToString ("X0", _nfi));
\r
1535 AssertEquals ("#02", "0080000000", Int32.MinValue.ToString ("X10", _nfi));
\r
1536 AssertEquals ("#03", "00080000000", Int32.MinValue.ToString ("X11", _nfi));
\r
1537 AssertEquals ("#04", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000", Int32.MinValue.ToString ("X99", _nfi));
\r
1538 AssertEquals ("#05", "-X12147483648", Int32.MinValue.ToString ("X100", _nfi));
\r
1542 public void Test07006 () {
\r
1543 AssertEquals ("#01", "XF", 0.ToString ("XF", _nfi));
\r
1544 AssertEquals ("#02", "X0F", 0.ToString ("X0F", _nfi));
\r
1545 AssertEquals ("#03", "X0xF", 0.ToString ("X0xF", _nfi));
\r
1549 public void Test07007 () {
\r
1550 AssertEquals ("#01", "XF", Int32.MaxValue.ToString ("XF", _nfi));
\r
1551 AssertEquals ("#02", "X2147483647F", Int32.MaxValue.ToString ("X0F", _nfi));
\r
1552 AssertEquals ("#03", "X2147483647xF", Int32.MaxValue.ToString ("X0xF", _nfi));
\r
1556 public void Test07008 () {
\r
1557 AssertEquals ("#01", "-XF", Int32.MinValue.ToString ("XF", _nfi));
\r
1558 AssertEquals ("#02", "-X2147483648F", Int32.MinValue.ToString ("X0F", _nfi));
\r
1559 AssertEquals ("#03", "-X2147483648xF", Int32.MinValue.ToString ("X0xF", _nfi));
\r
1563 public void Test07009 () {
\r
1564 AssertEquals ("#01", "00000000000", 0.ToString ("X0000000000000000000000000000000000000011", _nfi));
\r
1565 AssertEquals ("#02", "0007FFFFFFF", Int32.MaxValue.ToString ("X0000000000000000000000000000000000000011", _nfi));
\r
1566 AssertEquals ("#03", "00080000000", Int32.MinValue.ToString ("X0000000000000000000000000000000000000011", _nfi));
\r
1570 public void Test07010 () {
\r
1571 AssertEquals ("#01", "+X", 0.ToString ("+X", _nfi));
\r
1572 AssertEquals ("#02", "X+", 0.ToString ("X+", _nfi));
\r
1573 AssertEquals ("#03", "+X+", 0.ToString ("+X+", _nfi));
\r
1577 public void Test07011 () {
\r
1578 AssertEquals ("#01", "+X", Int32.MaxValue.ToString ("+X", _nfi));
\r
1579 AssertEquals ("#02", "X+", Int32.MaxValue.ToString ("X+", _nfi));
\r
1580 AssertEquals ("#03", "+X+", Int32.MaxValue.ToString ("+X+", _nfi));
\r
1584 public void Test07012 () {
\r
1585 AssertEquals ("#01", "-+X", Int32.MinValue.ToString ("+X", _nfi));
\r
1586 AssertEquals ("#02", "-X+", Int32.MinValue.ToString ("X+", _nfi));
\r
1587 AssertEquals ("#03", "-+X+", Int32.MinValue.ToString ("+X+", _nfi));
\r
1591 public void Test07013 () {
\r
1592 AssertEquals ("#01", "-X", 0.ToString ("-X", _nfi));
\r
1593 AssertEquals ("#02", "X-", 0.ToString ("X-", _nfi));
\r
1594 AssertEquals ("#03", "-X-", 0.ToString ("-X-", _nfi));
\r
1598 public void Test07014 () {
\r
1599 AssertEquals ("#01", "-X", Int32.MaxValue.ToString ("-X", _nfi));
\r
1600 AssertEquals ("#02", "X-", Int32.MaxValue.ToString ("X-", _nfi));
\r
1601 AssertEquals ("#03", "-X-", Int32.MaxValue.ToString ("-X-", _nfi));
\r
1605 public void Test07015 () {
\r
1606 AssertEquals ("#01", "--X", Int32.MinValue.ToString ("-X", _nfi));
\r
1607 AssertEquals ("#02", "-X-", Int32.MinValue.ToString ("X-", _nfi));
\r
1608 AssertEquals ("#03", "--X-", Int32.MinValue.ToString ("-X-", _nfi));
\r
1612 public void Test07016 () {
\r
1613 AssertEquals ("#01", "X+0", 0.ToString ("X+0", _nfi));
\r
1614 AssertEquals ("#02", "X+2147483647", Int32.MaxValue.ToString ("X+0", _nfi));
\r
1615 AssertEquals ("#03", "-X+2147483648", Int32.MinValue.ToString ("X+0", _nfi));
\r
1619 public void Test07017 () {
\r
1620 AssertEquals ("#01", "X+9", 0.ToString ("X+9", _nfi));
\r
1621 AssertEquals ("#02", "X+9", Int32.MaxValue.ToString ("X+9", _nfi));
\r
1622 AssertEquals ("#03", "-X+9", Int32.MinValue.ToString ("X+9", _nfi));
\r
1626 public void Test07018 () {
\r
1627 AssertEquals ("#01", "X-9", 0.ToString ("X-9", _nfi));
\r
1628 AssertEquals ("#02", "X-9", Int32.MaxValue.ToString ("X-9", _nfi));
\r
1629 AssertEquals ("#03", "-X-9", Int32.MinValue.ToString ("X-9", _nfi));
\r
1633 public void Test07019 () {
\r
1634 AssertEquals ("#01", "X0", 0.ToString ("X0,", _nfi));
\r
1635 AssertEquals ("#02", "X2147484", Int32.MaxValue.ToString ("X0,", _nfi));
\r
1636 AssertEquals ("#03", "-X2147484", Int32.MinValue.ToString ("X0,", _nfi));
\r
1640 public void Test07020 () {
\r
1641 AssertEquals ("#01", "X0", 0.ToString ("X0.", _nfi));
\r
1642 AssertEquals ("#02", "X2147483647", Int32.MaxValue.ToString ("X0.", _nfi));
\r
1643 AssertEquals ("#03", "-X2147483648", Int32.MinValue.ToString ("X0.", _nfi));
\r
1647 public void Test07021 () {
\r
1648 AssertEquals ("#01", "X0.0", 0.ToString ("X0.0", _nfi));
\r
1649 AssertEquals ("#02", "X2147483647.0", Int32.MaxValue.ToString ("X0.0", _nfi));
\r
1650 AssertEquals ("#03", "-X2147483648.0", Int32.MinValue.ToString ("X0.0", _nfi));
\r
1654 public void Test07022 () {
\r
1655 AssertEquals ("#01", "X09", 0.ToString ("X0.9", _nfi));
\r
1656 AssertEquals ("#02", "X21474836479", Int32.MaxValue.ToString ("X0.9", _nfi));
\r
1657 AssertEquals ("#03", "-X21474836489", Int32.MinValue.ToString ("X0.9", _nfi));
\r
1661 public void Test08000 () {
\r
1662 AssertEquals ("#01", "0", 0.ToString ("0", _nfi));
\r
1663 AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("0", _nfi));
\r
1664 AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("0", _nfi));
\r
1667 // Test08000 - Int32 and Custom
\r
1669 public void Test08001 () {
\r
1670 AssertEquals ("#01", "00000000000", 0.ToString ("00000000000", _nfi));
\r
1671 AssertEquals ("#02", "02147483647", Int32.MaxValue.ToString ("00000000000", _nfi));
\r
1672 AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("00000000000", _nfi));
\r
1676 public void Test08002 () {
\r
1677 AssertEquals ("#01", " 00000000000 ", 0.ToString (" 00000000000 ", _nfi));
\r
1678 AssertEquals ("#02", " 02147483647 ", Int32.MaxValue.ToString (" 00000000000 ", _nfi));
\r
1679 AssertEquals ("#03", "- 02147483648 ", Int32.MinValue.ToString (" 00000000000 ", _nfi));
\r
1683 public void Test08003 () {
\r
1684 AssertEquals ("#01", "", 0.ToString ("#", _nfi));
\r
1685 AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("#", _nfi));
\r
1686 AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("#", _nfi));
\r
1690 public void Test08004 () {
\r
1691 AssertEquals ("#01", "", 0.ToString ("##########", _nfi));
\r
1692 AssertEquals ("#02", "2147483647", Int32.MaxValue.ToString ("##########", _nfi));
\r
1693 AssertEquals ("#03", "-2147483648", Int32.MinValue.ToString ("##########", _nfi));
\r
1697 public void Test08005 () {
\r
1698 AssertEquals ("#01", " ", 0.ToString (" ########## ", _nfi));
\r
1699 AssertEquals ("#02", " 2147483647 ", Int32.MaxValue.ToString (" ########## ", _nfi));
\r
1700 AssertEquals ("#03", "- 2147483648 ", Int32.MinValue.ToString (" ########## ", _nfi));
\r
1704 public void Test08006 () {
\r
1705 AssertEquals ("#01", "", 0.ToString (".", _nfi));
\r
1706 AssertEquals ("#02", "", Int32.MaxValue.ToString (".", _nfi));
\r
1707 AssertEquals ("#03", "-", Int32.MinValue.ToString (".", _nfi));
\r
1711 public void Test08007 () {
\r
1712 AssertEquals ("#01", "00000000000", 0.ToString ("00000000000.", _nfi));
\r
1713 AssertEquals ("#02", "02147483647", Int32.MaxValue.ToString ("00000000000.", _nfi));
\r
1714 AssertEquals ("#03", "-02147483648", Int32.MinValue.ToString ("00000000000.", _nfi));
\r
1718 public void Test08008 () {
\r
1719 AssertEquals ("#01", ".00000000000", 0.ToString (".00000000000", _nfi));
\r
1720 AssertEquals ("#02", "2147483647.00000000000", Int32.MaxValue.ToString (".00000000000", _nfi));
\r
1721 AssertEquals ("#03", "-2147483648.00000000000", Int32.MinValue.ToString (".00000000000", _nfi));
\r
1725 public void Test08009 () {
\r
1726 AssertEquals ("#01", "00000000000.00000000000", 0.ToString ("00000000000.00000000000", _nfi));
\r
1727 AssertEquals ("#02", "02147483647.00000000000", Int32.MaxValue.ToString ("00000000000.00000000000", _nfi));
\r
1728 AssertEquals ("#03", "-02147483648.00000000000", Int32.MinValue.ToString ("00000000000.00000000000", _nfi));
\r
1732 public void Test08010 () {
\r
1733 AssertEquals ("#01", "00.0000000000", 0.ToString ("00.0.00.000.0000", _nfi));
\r
1734 AssertEquals ("#02", "01.0000000000", 1.ToString ("00.0.00.000.0000", _nfi));
\r
1735 AssertEquals ("#03", "-01.0000000000", (-1).ToString ("00.0.00.000.0000", _nfi));
\r
1739 public void Test08011 () {
\r
1740 AssertEquals ("#01", "", 0.ToString ("##.#.##.###.####", _nfi));
\r
1741 AssertEquals ("#02", "1", 1.ToString ("##.#.##.###.####", _nfi));
\r
1742 AssertEquals ("#03", "-1", (-1).ToString ("##.#.##.###.####", _nfi));
\r
1745 public void Test08012 () {
\r
1746 AssertEquals ("#01", "00", 0.ToString ("0#.#.##.###.####", _nfi));
\r
1747 AssertEquals ("#02", "01", 1.ToString ("0#.#.##.###.####", _nfi));
\r
1748 AssertEquals ("#03", "-01", (-1).ToString ("0#.#.##.###.####", _nfi));
\r
1751 public void Test08013 () {
\r
1752 AssertEquals ("#01", "0", 0.ToString ("#0.#.##.###.####", _nfi));
\r
1753 AssertEquals ("#02", "1", 1.ToString ("#0.#.##.###.####", _nfi));
\r
1754 AssertEquals ("#03", "-1", (-1).ToString ("#0.#.##.###.####", _nfi));
\r
1757 public void Test08014 () {
\r
1758 AssertEquals ("#01", ".0000000000", 0.ToString ("##.#.##.###.###0", _nfi));
\r
1759 AssertEquals ("#02", "1.0000000000", 1.ToString ("##.#.##.###.###0", _nfi));
\r
1760 AssertEquals ("#03", "-1.0000000000", (-1).ToString ("##.#.##.###.###0", _nfi));
\r
1763 public void Test08015 () {
\r
1764 AssertEquals ("#01", ".000000000", 0.ToString ("##.#.##.###.##0#", _nfi));
\r
1765 AssertEquals ("#02", "1.000000000", 1.ToString ("##.#.##.###.##0#", _nfi));
\r
1766 AssertEquals ("#03", "-1.000000000", (-1).ToString ("##.#.##.###.##0#", _nfi));
\r
1769 public void Test08016 () {
\r
1770 AssertEquals ("#01", ".000000000", 0.ToString ("##.#.##.##0.##0#", _nfi));
\r
1771 AssertEquals ("#02", "1.000000000", 1.ToString ("##.#.##.##0.##0#", _nfi));
\r
1772 AssertEquals ("#03", "-1.000000000", (-1).ToString ("##.#.##.##0.##0#", _nfi));
\r
1775 public void Test08017 () {
\r
1776 AssertEquals ("#01", "0.000000000", 0.ToString ("#0.#.##.##0.##0#", _nfi));
\r
1777 AssertEquals ("#02", "1.000000000", 1.ToString ("#0.#.##.##0.##0#", _nfi));
\r
1778 AssertEquals ("#03", "-1.000000000", (-1).ToString ("#0.#.##.##0.##0#", _nfi));
\r
1781 public void Test08018 () {
\r
1782 AssertEquals ("#01", "-0002147484", Int32.MinValue.ToString ("0000000000,", _nfi));
\r
1783 AssertEquals ("#02", "-0000002147", Int32.MinValue.ToString ("0000000000,,", _nfi));
\r
1784 AssertEquals ("#03", "-0000000002", Int32.MinValue.ToString ("0000000000,,,", _nfi));
\r
1785 AssertEquals ("#04", "0000000000", Int32.MinValue.ToString ("0000000000,,,,", _nfi));
\r
1786 AssertEquals ("#05", "0000000000", Int32.MinValue.ToString ("0000000000,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,", _nfi));
\r
1789 public void Test08019 () {
\r
1790 AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString (",0000000000", _nfi));
\r
1793 public void Test08020 () {
\r
1794 AssertEquals ("#01", "-0002147484", Int32.MinValue.ToString (",0000000000,", _nfi));
\r
1797 public void Test08021 () {
\r
1798 AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString ("0,0000000000", _nfi));
\r
1801 public void Test08022 () {
\r
1802 AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString ("0000000000,0", _nfi));
\r
1805 public void Test08023 () {
\r
1806 AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0", _nfi));
\r
1809 public void Test08024 () {
\r
1810 AssertEquals ("#01", "-02,147,483,648", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0", _nfi));
\r
1813 public void Test08025 () {
\r
1814 AssertEquals ("#01", "-00,002,147,484", Int32.MinValue.ToString ("0,0,0,0,0,0,0,0,0,0,0,", _nfi));
\r
1817 public void Test08026 () {
\r
1818 AssertEquals ("#01", "-00,002,147,484", Int32.MinValue.ToString (",0,0,0,0,0,0,0,0,0,0,0,", _nfi));
\r
1821 public void Test08027 () {
\r
1822 AssertEquals ("#01", "-", Int32.MinValue.ToString (",", _nfi));
\r
1825 public void Test08028 () {
\r
1826 AssertEquals ("#01", "-2147483648", Int32.MinValue.ToString (",##########", _nfi));
\r
1829 public void Test08029 () {
\r
1830 AssertEquals ("#01", "-2147484", Int32.MinValue.ToString (",##########,", _nfi));
\r
1833 public void Test08030 () {
\r
1834 AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("#,##########", _nfi));
\r
1837 public void Test08031 () {
\r
1838 AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("##########,#", _nfi));
\r
1841 public void Test08032 () {
\r
1842 AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#", _nfi));
\r
1845 public void Test08033 () {
\r
1846 AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#", _nfi));
\r
1849 public void Test08034 () {
\r
1850 AssertEquals ("#01", "-2,147,484", Int32.MinValue.ToString ("#,#,#,#,#,#,#,#,#,#,#,", _nfi));
\r
1853 public void Test08035 () {
\r
1854 AssertEquals ("#01", "-2,147,484", Int32.MinValue.ToString (",#,#,#,#,#,#,#,#,#,#,#,", _nfi));
\r
1857 public void Test08036 () {
\r
1858 AssertEquals ("#01", "-1", (-1000).ToString ("##########,", _nfi));
\r
1860 public void Test08037 () {
\r
1861 AssertEquals ("#01", "", (-100).ToString ("##########,", _nfi));
\r
1864 public void Test08038 () {
\r
1865 AssertEquals ("#01", "-%", Int32.MinValue.ToString ("%", _nfi));
\r
1868 public void Test08039 () {
\r
1869 AssertEquals ("#01", "-214748364800%", Int32.MinValue.ToString ("0%", _nfi));
\r
1872 public void Test08040 () {
\r
1873 AssertEquals ("#01", "-%214748364800", Int32.MinValue.ToString ("%0", _nfi));
\r
1876 public void Test08041 () {
\r
1877 AssertEquals ("#01", "-%21474836480000%", Int32.MinValue.ToString ("%0%", _nfi));
\r
1880 public void Test08042 () {
\r
1881 AssertEquals ("#01", "- % 21474836480000 % ", Int32.MinValue.ToString (" % 0 % ", _nfi));
\r
1884 public void Test08043 () {
\r
1885 AssertEquals ("#01", "-214748365%", Int32.MinValue.ToString ("0%,", _nfi));
\r
1888 public void Test08044 () {
\r
1889 AssertEquals ("#01", "-214748365%", Int32.MinValue.ToString ("0,%", _nfi));
\r
1892 public void Test08045 () {
\r
1893 AssertEquals ("#01", "-%214748364800", Int32.MinValue.ToString (",%0", _nfi));
\r
1896 public void Test08046 () {
\r
1897 AssertEquals ("#01", "-%214748364800", Int32.MinValue.ToString ("%,0", _nfi));
\r
1900 public void Test08047 () {
\r
1901 AssertEquals ("#01", "-2147483648%%%%%%", Int32.MinValue.ToString ("0,,,,%%%%%%", _nfi));
\r
1904 public void Test08048 () {
\r
1905 AssertEquals ("#01", "-2147483648%%%%%%", Int32.MinValue.ToString ("0%%%%%%,,,,", _nfi));
\r
1908 public void Test08049 () {
\r
1909 AssertEquals ("#01", "-%%%%%%2147483648", Int32.MinValue.ToString ("%%%%%%0,,,,", _nfi));
\r
1912 public void Test08050 () {
\r
1913 AssertEquals ("#01", "E+0", Int32.MinValue.ToString ("E+0", _nfi));
\r
1914 AssertEquals ("#02", "e+0", Int32.MinValue.ToString ("e+0", _nfi));
\r
1915 AssertEquals ("#03", "E0", Int32.MinValue.ToString ("E-0", _nfi));
\r
1916 AssertEquals ("#04", "e0", Int32.MinValue.ToString ("e-0", _nfi));
\r
1919 public void Test08051 () {
\r
1920 AssertEquals ("#01", "-2E+9", Int32.MinValue.ToString ("0E+0", _nfi));
\r
1921 AssertEquals ("#02", "-2e+9", Int32.MinValue.ToString ("0e+0", _nfi));
\r
1922 AssertEquals ("#03", "-2E9", Int32.MinValue.ToString ("0E-0", _nfi));
\r
1923 AssertEquals ("#04", "-2e9", Int32.MinValue.ToString ("0e-0", _nfi));
\r
1924 AssertEquals ("#05", "-2E9", Int32.MinValue.ToString ("0E0", _nfi));
\r
1925 AssertEquals ("#06", "-2e9", Int32.MinValue.ToString ("0e0", _nfi));
\r
1928 public void Test08052 () {
\r
1929 AssertEquals ("#01", "-2E+9", Int32.MinValue.ToString ("#E+0", _nfi));
\r
1930 AssertEquals ("#02", "-2e+9", Int32.MinValue.ToString ("#e+0", _nfi));
\r
1931 AssertEquals ("#03", "-2E9", Int32.MinValue.ToString ("#E-0", _nfi));
\r
1932 AssertEquals ("#04", "-2e9", Int32.MinValue.ToString ("#e-0", _nfi));
\r
1933 AssertEquals ("#05", "-2E9", Int32.MinValue.ToString ("#E0", _nfi));
\r
1934 AssertEquals ("#06", "-2e9", Int32.MinValue.ToString ("#e0", _nfi));
\r
1937 public void Test08053 () {
\r
1938 AssertEquals ("#01", "-2147483648E+0", Int32.MinValue.ToString ("0000000000E+0", _nfi));
\r
1939 AssertEquals ("#02", "-2147483648e+0", Int32.MinValue.ToString ("0000000000e+0", _nfi));
\r
1940 AssertEquals ("#03", "-2147483648E0", Int32.MinValue.ToString ("0000000000E-0", _nfi));
\r
1941 AssertEquals ("#04", "-2147483648e0", Int32.MinValue.ToString ("0000000000e-0", _nfi));
\r
1942 AssertEquals ("#05", "-2147483648E0", Int32.MinValue.ToString ("0000000000E0", _nfi));
\r
1943 AssertEquals ("#06", "-2147483648e0", Int32.MinValue.ToString ("0000000000e0", _nfi));
\r
1946 public void Test08054 () {
\r
1947 AssertEquals ("#01", "-21474836480E-1", Int32.MinValue.ToString ("00000000000E+0", _nfi));
\r
1948 AssertEquals ("#02", "-21474836480e-1", Int32.MinValue.ToString ("00000000000e+0", _nfi));
\r
1949 AssertEquals ("#03", "-21474836480E-1", Int32.MinValue.ToString ("00000000000E-0", _nfi));
\r
1950 AssertEquals ("#04", "-21474836480e-1", Int32.MinValue.ToString ("00000000000e-0", _nfi));
\r
1951 AssertEquals ("#05", "-21474836480E-1", Int32.MinValue.ToString ("00000000000E0", _nfi));
\r
1952 AssertEquals ("#06", "-21474836480e-1", Int32.MinValue.ToString ("00000000000e0", _nfi));
\r
1955 public void Test08055 () {
\r
1956 AssertEquals ("#01", "-214748365E+1", Int32.MinValue.ToString ("000000000E+0", _nfi));
\r
1957 AssertEquals ("#02", "-214748365e+1", Int32.MinValue.ToString ("000000000e+0", _nfi));
\r
1958 AssertEquals ("#03", "-214748365E1", Int32.MinValue.ToString ("000000000E-0", _nfi));
\r
1959 AssertEquals ("#04", "-214748365e1", Int32.MinValue.ToString ("000000000e-0", _nfi));
\r
1960 AssertEquals ("#05", "-214748365E1", Int32.MinValue.ToString ("000000000E0", _nfi));
\r
1961 AssertEquals ("#06", "-214748365e1", Int32.MinValue.ToString ("000000000e0", _nfi));
\r
1964 public void Test08056 () {
\r
1965 AssertEquals ("#01", "-21474836E+2", Int32.MinValue.ToString ("00000000E+0", _nfi));
\r
1966 AssertEquals ("#02", "-21474836e+2", Int32.MinValue.ToString ("00000000e+0", _nfi));
\r
1967 AssertEquals ("#03", "-21474836E2", Int32.MinValue.ToString ("00000000E-0", _nfi));
\r
1968 AssertEquals ("#04", "-21474836e2", Int32.MinValue.ToString ("00000000e-0", _nfi));
\r
1969 AssertEquals ("#05", "-21474836E2", Int32.MinValue.ToString ("00000000E0", _nfi));
\r
1970 AssertEquals ("#06", "-21474836e2", Int32.MinValue.ToString ("00000000e0", _nfi));
\r
1973 public void Test08057 () {
\r
1974 AssertEquals ("#01", "-2147483648E+00", Int32.MinValue.ToString ("0000000000E+00", _nfi));
\r
1975 AssertEquals ("#02", "-2147483648e+00", Int32.MinValue.ToString ("0000000000e+00", _nfi));
\r
1976 AssertEquals ("#03", "-2147483648E00", Int32.MinValue.ToString ("0000000000E-00", _nfi));
\r
1977 AssertEquals ("#04", "-2147483648e00", Int32.MinValue.ToString ("0000000000e-00", _nfi));
\r
1978 AssertEquals ("#05", "-2147483648E00", Int32.MinValue.ToString ("0000000000E00", _nfi));
\r
1979 AssertEquals ("#06", "-2147483648e00", Int32.MinValue.ToString ("0000000000e00", _nfi));
\r
1982 public void Test08058 () {
\r
1983 AssertEquals ("#01", "-2147483648E+02%", Int32.MinValue.ToString ("0000000000E+00%", _nfi));
\r
1984 AssertEquals ("#02", "-2147483648e+02%", Int32.MinValue.ToString ("0000000000e+00%", _nfi));
\r
1985 AssertEquals ("#03", "-2147483648E02%", Int32.MinValue.ToString ("0000000000E-00%", _nfi));
\r
1986 AssertEquals ("#04", "-2147483648e02%", Int32.MinValue.ToString ("0000000000e-00%", _nfi));
\r
1987 AssertEquals ("#05", "-2147483648E02%", Int32.MinValue.ToString ("0000000000E00%", _nfi));
\r
1988 AssertEquals ("#06", "-2147483648e02%", Int32.MinValue.ToString ("0000000000e00%", _nfi));
\r
1991 public void Test08059 () {
\r
1992 AssertEquals ("#01", "-2147483648E+10%%%%%", Int32.MinValue.ToString ("0000000000E+00%%%%%", _nfi));
\r
1993 AssertEquals ("#02", "-2147483648e+10%%%%%", Int32.MinValue.ToString ("0000000000e+00%%%%%", _nfi));
\r
1994 AssertEquals ("#03", "-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E-00%%%%%", _nfi));
\r
1995 AssertEquals ("#04", "-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e-00%%%%%", _nfi));
\r
1996 AssertEquals ("#05", "-2147483648E10%%%%%", Int32.MinValue.ToString ("0000000000E00%%%%%", _nfi));
\r
1997 AssertEquals ("#06", "-2147483648e10%%%%%", Int32.MinValue.ToString ("0000000000e00%%%%%", _nfi));
\r
2000 public void Test08060 () {
\r
2001 AssertEquals ("#01", "-2147483648E-03", Int32.MinValue.ToString ("0000000000E+00,", _nfi));
\r
2002 AssertEquals ("#02", "-2147483648e-03", Int32.MinValue.ToString ("0000000000e+00,", _nfi));
\r
2003 AssertEquals ("#03", "-2147483648E-03", Int32.MinValue.ToString ("0000000000E-00,", _nfi));
\r
2004 AssertEquals ("#04", "-2147483648e-03", Int32.MinValue.ToString ("0000000000e-00,", _nfi));
\r
2005 AssertEquals ("#05", "-2147483648E-03", Int32.MinValue.ToString ("0000000000E00,", _nfi));
\r
2006 AssertEquals ("#06", "-2147483648e-03", Int32.MinValue.ToString ("0000000000e00,", _nfi));
\r
2009 public void Test08061 () {
\r
2010 AssertEquals ("#01", "-2147483648E-12", Int32.MinValue.ToString ("0000000000E+00,,,,", _nfi));
\r
2011 AssertEquals ("#02", "-2147483648e-12", Int32.MinValue.ToString ("0000000000e+00,,,,", _nfi));
\r
2012 AssertEquals ("#03", "-2147483648E-12", Int32.MinValue.ToString ("0000000000E-00,,,,", _nfi));
\r
2013 AssertEquals ("#04", "-2147483648e-12", Int32.MinValue.ToString ("0000000000e-00,,,,", _nfi));
\r
2014 AssertEquals ("#05", "-2147483648E-12", Int32.MinValue.ToString ("0000000000E00,,,,", _nfi));
\r
2015 AssertEquals ("#06", "-2147483648e-12", Int32.MinValue.ToString ("0000000000e00,,,,", _nfi));
\r
2018 public void Test08062 () {
\r
2019 AssertEquals ("#01", "-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E+00,,,,%%%%", _nfi));
\r
2020 AssertEquals ("#02", "-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e+00,,,,%%%%", _nfi));
\r
2021 AssertEquals ("#03", "-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E-00,,,,%%%%", _nfi));
\r
2022 AssertEquals ("#04", "-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e-00,,,,%%%%", _nfi));
\r
2023 AssertEquals ("#05", "-2147483648E-04%%%%", Int32.MinValue.ToString ("0000000000E00,,,,%%%%", _nfi));
\r
2024 AssertEquals ("#06", "-2147483648e-04%%%%", Int32.MinValue.ToString ("0000000000e00,,,,%%%%", _nfi));
\r
2027 public void Test08063 () {
\r
2028 AssertEquals ("#01", "-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E+00,,,,%%%%", _nfi));
\r
2029 AssertEquals ("#02", "-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e+00,,,,%%%%", _nfi));
\r
2030 AssertEquals ("#03", "-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E-00,,,,%%%%", _nfi));
\r
2031 AssertEquals ("#04", "-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e-00,,,,%%%%", _nfi));
\r
2032 AssertEquals ("#05", "-2147483648E-07%%%%", Int32.MinValue.ToString ("0000000000,E00,,,,%%%%", _nfi));
\r
2033 AssertEquals ("#06", "-2147483648e-07%%%%", Int32.MinValue.ToString ("0000000000,e00,,,,%%%%", _nfi));
\r
2036 public void Test08064 () {
\r
2037 AssertEquals ("#01", "-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E,+00,,,,%%%%", _nfi));
\r
2038 AssertEquals ("#02", "-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e,+00,,,,%%%%", _nfi));
\r
2039 AssertEquals ("#03", "-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E,-00,,,,%%%%", _nfi));
\r
2040 AssertEquals ("#04", "-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e,-00,,,,%%%%", _nfi));
\r
2041 AssertEquals ("#05", "-000,000,214,7E48%%%%", Int32.MinValue.ToString ("0000000000,E,00,,,,%%%%", _nfi));
\r
2042 AssertEquals ("#06", "-000,000,214,7e48%%%%", Int32.MinValue.ToString ("0000000000,e,00,,,,%%%%", _nfi));
\r
2045 public void Test08065 () {
\r
2046 AssertEquals ("#01", "-000,000,214,7E+48%%%%", Int32.MinValue.ToString ("0000000000,E+,00,,,,%%%%", _nfi));
\r
2047 AssertEquals ("#02", "-000,000,214,7e+48%%%%", Int32.MinValue.ToString ("0000000000,e+,00,,,,%%%%", _nfi));
\r
2048 AssertEquals ("#03", "-000,000,214,7E-48%%%%", Int32.MinValue.ToString ("0000000000,E-,00,,,,%%%%", _nfi));
\r
2049 AssertEquals ("#04", "-000,000,214,7e-48%%%%", Int32.MinValue.ToString ("0000000000,e-,00,,,,%%%%", _nfi));
\r
2052 public void Test08066 () {
\r
2053 AssertEquals ("#01", "-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E+0,0,,,,%%%%", _nfi));
\r
2054 AssertEquals ("#02", "-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e+0,0,,,,%%%%", _nfi));
\r
2055 AssertEquals ("#03", "-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E-0,0,,,,%%%%", _nfi));
\r
2056 AssertEquals ("#04", "-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e-0,0,,,,%%%%", _nfi));
\r
2057 AssertEquals ("#05", "-21,474,836,48E-50%%%%", Int32.MinValue.ToString ("0000000000,E0,0,,,,%%%%", _nfi));
\r
2058 AssertEquals ("#06", "-21,474,836,48e-50%%%%", Int32.MinValue.ToString ("0000000000,e0,0,,,,%%%%", _nfi));
\r
2061 public void Test08067 () {
\r
2062 AssertEquals ("#01", "-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,,%%%%", _nfi));
\r
2063 AssertEquals ("#02", "-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,,%%%%", _nfi));
\r
2064 AssertEquals ("#03", "-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,,%%%%", _nfi));
\r
2065 AssertEquals ("#04", "-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,,%%%%", _nfi));
\r
2066 AssertEquals ("#05", "-2147483648E-01,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,,%%%%", _nfi));
\r
2067 AssertEquals ("#06", "-2147483648e-01,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,,%%%%", _nfi));
\r
2070 public void Test08068 () {
\r
2071 AssertEquals ("#01", "-2147483648E+02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,%%%%", _nfi));
\r
2072 AssertEquals ("#02", "-2147483648e+02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,%%%%", _nfi));
\r
2073 AssertEquals ("#03", "-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,%%%%", _nfi));
\r
2074 AssertEquals ("#04", "-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,%%%%", _nfi));
\r
2075 AssertEquals ("#05", "-2147483648E02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,%%%%", _nfi));
\r
2076 AssertEquals ("#06", "-2147483648e02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,%%%%", _nfi));
\r
2079 public void Test08069 () {
\r
2080 AssertEquals ("#01", "-2147483648E+00,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%%", _nfi));
\r
2081 AssertEquals ("#02", "-2147483648e+00,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%%", _nfi));
\r
2082 AssertEquals ("#03", "-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%%", _nfi));
\r
2083 AssertEquals ("#04", "-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%%", _nfi));
\r
2084 AssertEquals ("#05", "-2147483648E00,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%%", _nfi));
\r
2085 AssertEquals ("#06", "-2147483648e00,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%%", _nfi));
\r
2088 public void Test08070 () {
\r
2089 AssertEquals ("#01", "-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E+00\,,,\,\%%%\%", _nfi));
\r
2090 AssertEquals ("#02", "-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e+00\,,,\,\%%%\%", _nfi));
\r
2091 AssertEquals ("#03", "-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E-00\,,,\,\%%%\%", _nfi));
\r
2092 AssertEquals ("#04", "-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e-00\,,,\,\%%%\%", _nfi));
\r
2093 AssertEquals ("#05", "-2147483648E-02,,%%%%", Int32.MinValue.ToString (@"0000000000E00\,,,\,\%%%\%", _nfi));
\r
2094 AssertEquals ("#06", "-2147483648e-02,,%%%%", Int32.MinValue.ToString (@"0000000000e00\,,,\,\%%%\%", _nfi));
\r
2097 public void Test08071 () {
\r
2098 AssertEquals ("#01", @"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,,,\\,\\%%%\\%", _nfi));
\r
2099 AssertEquals ("#02", @"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,,,\\,\\%%%\\%", _nfi));
\r
2100 AssertEquals ("#03", @"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,,,\\,\\%%%\\%", _nfi));
\r
2101 AssertEquals ("#04", @"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,,,\\,\\%%%\\%", _nfi));
\r
2102 AssertEquals ("#05", @"-2147483648E-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,,,\\,\\%%%\\%", _nfi));
\r
2103 AssertEquals ("#06", @"-2147483648e-04\\\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,,,\\,\\%%%\\%", _nfi));
\r
2106 public void Test08072 () {
\r
2107 AssertEquals ("#01", @"-2147483648E+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E+00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2108 AssertEquals ("#02", @"-2147483648e+00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e+00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2109 AssertEquals ("#03", @"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E-00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2110 AssertEquals ("#04", @"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e-00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2111 AssertEquals ("#05", @"-2147483648E00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2112 AssertEquals ("#06", @"-2147483648e00\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2115 public void Test08073 () {
\r
2116 AssertEquals ("#01", @"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E+00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2117 AssertEquals ("#02", @"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e+00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2118 AssertEquals ("#03", @"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E-00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2119 AssertEquals ("#04", @"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e-00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2120 AssertEquals ("#05", @"-0021474836E48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\E00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2121 AssertEquals ("#06", @"-0021474836e48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000\e00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2124 public void Test08074 () {
\r
2125 AssertEquals ("#01", @"-0021474836E+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\+00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2126 AssertEquals ("#02", @"-0021474836e+48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\+00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2127 AssertEquals ("#03", @"-0021474836E-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000E\-00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2128 AssertEquals ("#04", @"-0021474836e-48\,\,\%%%\%", Int32.MinValue.ToString (@"0000000000e\-00\\,\,,\\\,\\%%%\\\%", _nfi));
\r
2131 public void Test08075 () {
\r
2132 AssertEquals ("#01", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,',%'%%%", _nfi));
\r
2133 AssertEquals ("#02", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,',%'%%%", _nfi));
\r
2134 AssertEquals ("#03", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,',%'%%%", _nfi));
\r
2135 AssertEquals ("#04", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,',%'%%%", _nfi));
\r
2136 AssertEquals ("#05", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,',%'%%%", _nfi));
\r
2137 AssertEquals ("#06", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,',%'%%%", _nfi));
\r
2140 public void Test08076 () {
\r
2141 AssertEquals ("#01", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E+00,,,\",%\"%%%", _nfi));
\r
2142 AssertEquals ("#02", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e+00,,,\",%\"%%%", _nfi));
\r
2143 AssertEquals ("#03", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E-00,,,\",%\"%%%", _nfi));
\r
2144 AssertEquals ("#04", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e-00,,,\",%\"%%%", _nfi));
\r
2145 AssertEquals ("#05", "-2147483648E-03,%%%%", Int32.MinValue.ToString ("0000000000E00,,,\",%\"%%%", _nfi));
\r
2146 AssertEquals ("#06", "-2147483648e-03,%%%%", Int32.MinValue.ToString ("0000000000e00,,,\",%\"%%%", _nfi));
\r
2149 public void Test08077 () {
\r
2150 AssertEquals ("#01", "-", Int32.MinValue.ToString (";", _nfi));
\r
2151 AssertEquals ("#02", "", Int32.MaxValue.ToString (";", _nfi));
\r
2152 AssertEquals ("#03", "",0.ToString (";", _nfi));
\r
2155 public void Test08078 () {
\r
2156 AssertEquals ("#01", "-2,147,483,648", Int32.MinValue.ToString ("#,#;", _nfi));
\r
2157 AssertEquals ("#02", "2,147,483,647", Int32.MaxValue.ToString ("#,#;", _nfi));
\r
2158 AssertEquals ("#03", "", 0.ToString ("#,#;", _nfi));
\r
2161 public void Test08079 () {
\r
2162 AssertEquals ("#01", "2,147,483,648", Int32.MinValue.ToString (";#,#", _nfi));
\r
2163 AssertEquals ("#02", "", Int32.MaxValue.ToString (";#,#", _nfi));
\r
2164 AssertEquals ("#03", "", 0.ToString (";#,#", _nfi));
\r
2167 public void Test08080 () {
\r
2168 AssertEquals ("#01", "2,147,483,648", Int32.MinValue.ToString ("0000000000,.0000000000;#,#", _nfi));
\r
2169 AssertEquals ("#02", "0002147483.6470000000", Int32.MaxValue.ToString ("0000000000,.0000000000;#,#", _nfi));
\r
2170 AssertEquals ("#03", "0000000000.0000000000", 0.ToString ("0000000000,.0000000000;#,#", _nfi));
\r
2173 public void Test08081 () {
\r
2174 AssertEquals ("#01", "-", Int32.MinValue.ToString (";;", _nfi));
\r
2175 AssertEquals ("#02", "", Int32.MaxValue.ToString (";;", _nfi));
\r
2176 AssertEquals ("#03", "",0.ToString (";;", _nfi));
\r
2179 public void Test08082 () {
\r
2180 AssertEquals ("#01", "-", Int32.MinValue.ToString (";;0%", _nfi));
\r
2181 AssertEquals ("#02", "", Int32.MaxValue.ToString (";;0%", _nfi));
\r
2182 AssertEquals ("#03", "0%",0.ToString (";;0%", _nfi));
\r
2185 public void Test08083 () {
\r
2186 AssertEquals ("#01", "2147484", Int32.MinValue.ToString (";0,;0%", _nfi));
\r
2187 AssertEquals ("#02", "", Int32.MaxValue.ToString (";0,;0%", _nfi));
\r
2188 AssertEquals ("#03", "0%",0.ToString (";0,;0%", _nfi));
\r
2191 public void Test08084 () {
\r
2192 AssertEquals ("#01", "2147484", Int32.MinValue.ToString ("0E+0;0,;0%", _nfi));
\r
2193 AssertEquals ("#02", "2E+9", Int32.MaxValue.ToString ("0E+0;0,;0%", _nfi));
\r
2194 AssertEquals ("#03", "0%",0.ToString ("0E+0;0,;0%", _nfi));
\r
2197 public void Test08085 () {
\r
2198 AssertEquals ("#01", "214,748,364,80;0%", Int32.MinValue.ToString (@"0E+0;0,\;0%", _nfi));
\r
2199 AssertEquals ("#02", "2E+9", Int32.MaxValue.ToString (@"0E+0;0,\;0%", _nfi));
\r
2200 AssertEquals ("#03", "0E+0",0.ToString (@"0E+0;0,\;0%", _nfi));
\r
2203 public void Test08086 () {
\r
2204 AssertEquals ("#01", "214,748,364,80;0%", Int32.MinValue.ToString ("0E+0;0,\";\"0%", _nfi));
\r
2205 AssertEquals ("#02", "2E+9", Int32.MaxValue.ToString ("0E+0;0,\";\"0%", _nfi));
\r
2206 AssertEquals ("#03", "0E+0",0.ToString ("0E+0;0,\";\"0%", _nfi));
\r
2209 public void Test08087 () {
\r
2211 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
\r
2212 nfi.NumberDecimalSeparator = "$$$";
\r
2213 AssertEquals ("#01", "-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi));
\r
2216 public void Test08088 () {
\r
2218 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
\r
2219 nfi.NumberGroupSeparator = "$$$";
\r
2220 AssertEquals ("#01", "-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi));
\r
2223 public void Test08089 () {
\r
2224 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
\r
2225 nfi.NumberGroupSizes = new int[] {3,2,1,0};
\r
2226 AssertEquals ("#01", "-00000000002147,4,83,648", Int32.MinValue.ToString ("0000000000,0000000000", nfi));
\r
2229 public void Test08090 () {
\r
2231 NumberFormatInfo nfi = NumberFormatInfo.InvariantInfo.Clone() as NumberFormatInfo;
\r
2232 nfi.PercentSymbol = "$$$";
\r
2233 AssertEquals ("#01", "-0000000000$$$2147483648", Int32.MinValue.ToString ("0000000000$$$0000000000", nfi));
\r
2236 public void Test08091 () {
\r
2238 AssertEquals ("#01", "B2147", Int32.MinValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi));
\r
2239 AssertEquals ("#02", "A2147484", Int32.MaxValue.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi));
\r
2240 AssertEquals ("#03", "C0", 0.ToString ("A0,;B0,,;C0,,,;D0,,,,;E0,,,,,", _nfi));
\r
2243 // Test10000- Double and D
\r
2245 [ExpectedException (typeof (FormatException))]
\r
2246 public void Test10000 () {
\r
2247 AssertEquals ("#01", "0", 0.0.ToString ("D", _nfi));
\r
2250 // Test11000- Double and E
\r
2252 public void Test11000 () {
\r
2253 AssertEquals ("#01", "0.000000E+000", 0.0.ToString ("E", _nfi));
\r
2254 AssertEquals ("#02", "0.000000e+000", 0.0.ToString ("e", _nfi));
\r
2255 AssertEquals ("#03", "-1.797693E+308", Double.MinValue.ToString ("E", _nfi));
\r
2256 AssertEquals ("#04", "-1.797693e+308", Double.MinValue.ToString ("e", _nfi));
\r
2257 AssertEquals ("#05", "1.797693E+308", Double.MaxValue.ToString ("E", _nfi));
\r
2258 AssertEquals ("#06", "1.797693e+308", Double.MaxValue.ToString ("e", _nfi));
\r
2262 public void Test11001 () {
\r
2263 AssertEquals ("#01", "E ", 0.0.ToString ("E ", _nfi));
\r
2264 AssertEquals ("#02", " E", 0.0.ToString (" E", _nfi));
\r
2265 AssertEquals ("#03", " E ", 0.0.ToString (" E ", _nfi));
\r
2269 public void Test11002 () {
\r
2270 AssertEquals ("#01", "-E ", (-1.0).ToString ("E ", _nfi));
\r
2271 AssertEquals ("#02", "- E", (-1.0).ToString (" E", _nfi));
\r
2272 AssertEquals ("#03", "- E ", (-1.0).ToString (" E ", _nfi));
\r
2276 public void Test11003 () {
\r
2277 AssertEquals ("#01", "0E+000", 0.0.ToString ("E0", _nfi));
\r
2278 AssertEquals ("#02", "0.0000000000000000E+000", 0.0.ToString ("E16", _nfi));
\r
2279 AssertEquals ("#03", "0.00000000000000000E+000", 0.0.ToString ("E17", _nfi));
\r
2280 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 0.0.ToString ("E99", _nfi));
\r
2281 AssertEquals ("#05", "E100", 0.0.ToString ("E100", _nfi));
\r
2285 public void Test11004 () {
\r
2286 AssertEquals ("#01", "2E+308", Double.MaxValue.ToString ("E0", _nfi));
\r
2287 AssertEquals ("#02", "1.7976931348623157E+308", Double.MaxValue.ToString ("E16", _nfi));
\r
2288 AssertEquals ("#03", "1.79769313486231570E+308", Double.MaxValue.ToString ("E17", _nfi));
\r
2289 AssertEquals ("#04", "1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MaxValue.ToString ("E99", _nfi));
\r
2290 AssertEquals ("#05", "E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("E100", _nfi));
\r
2294 public void Test11005 () {
\r
2295 AssertEquals ("#01", "-2E+308", Double.MinValue.ToString ("E0", _nfi));
\r
2296 AssertEquals ("#02", "-1.7976931348623157E+308", Double.MinValue.ToString ("E16", _nfi));
\r
2297 AssertEquals ("#03", "-1.79769313486231570E+308", Double.MinValue.ToString ("E17", _nfi));
\r
2298 AssertEquals ("#04", "-1.797693134862315700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+308", Double.MinValue.ToString ("E99", _nfi));
\r
2299 AssertEquals ("#05", "-E1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("E100", _nfi));
\r
2303 public void Test11006 () {
\r
2304 AssertEquals ("#01", "EF", 0.0.ToString ("EF", _nfi));
\r
2305 AssertEquals ("#02", "E0F", 0.0.ToString ("E0F", _nfi));
\r
2306 AssertEquals ("#03", "E0xF", 0.0.ToString ("E0xF", _nfi));
\r
2310 public void Test11007 () {
\r
2311 AssertEquals ("#01", "EF", Double.MaxValue.ToString ("EF", _nfi));
\r
2312 AssertEquals ("#02", "E0F", Double.MaxValue.ToString ("E0F", _nfi));
\r
2313 AssertEquals ("#03", "E0xF", Double.MaxValue.ToString ("E0xF", _nfi));
\r
2317 public void Test11008 () {
\r
2318 AssertEquals ("#01", "-EF", Double.MinValue.ToString ("EF", _nfi));
\r
2319 AssertEquals ("#02", "E0F", Double.MinValue.ToString ("E0F", _nfi));
\r
2320 AssertEquals ("#03", "E0xF", Double.MinValue.ToString ("E0xF", _nfi));
\r
2324 public void Test11009 () {
\r
2325 AssertEquals ("#01", "0.00000000000000000E+000", 0.0.ToString ("E0000000000000000000000000000000000000017", _nfi));
\r
2326 AssertEquals ("#02", "1.79769313486231570E+308", Double.MaxValue.ToString ("E0000000000000000000000000000000000000017", _nfi));
\r
2327 AssertEquals ("#03", "-1.79769313486231570E+308", Double.MinValue.ToString ("E0000000000000000000000000000000000000017", _nfi));
\r
2331 public void Test11010 () {
\r
2332 AssertEquals ("#01", "+E", 0.0.ToString ("+E", _nfi));
\r
2333 AssertEquals ("#02", "E+", 0.0.ToString ("E+", _nfi));
\r
2334 AssertEquals ("#03", "+E+", 0.0.ToString ("+E+", _nfi));
\r
2338 public void Test11011 () {
\r
2339 AssertEquals ("#01", "+E", Double.MaxValue.ToString ("+E", _nfi));
\r
2340 AssertEquals ("#02", "E+", Double.MaxValue.ToString ("E+", _nfi));
\r
2341 AssertEquals ("#03", "+E+", Double.MaxValue.ToString ("+E+", _nfi));
\r
2345 public void Test11012 () {
\r
2346 AssertEquals ("#01", "-+E", Double.MinValue.ToString ("+E", _nfi));
\r
2347 AssertEquals ("#02", "-E+", Double.MinValue.ToString ("E+", _nfi));
\r
2348 AssertEquals ("#03", "-+E+", Double.MinValue.ToString ("+E+", _nfi));
\r
2352 public void Test11013 () {
\r
2353 AssertEquals ("#01", "-E", 0.0.ToString ("-E", _nfi));
\r
2354 AssertEquals ("#02", "E-", 0.0.ToString ("E-", _nfi));
\r
2355 AssertEquals ("#03", "-E-", 0.0.ToString ("-E-", _nfi));
\r
2359 public void Test11014 () {
\r
2360 AssertEquals ("#01", "-E", Double.MaxValue.ToString ("-E", _nfi));
\r
2361 AssertEquals ("#02", "E-", Double.MaxValue.ToString ("E-", _nfi));
\r
2362 AssertEquals ("#03", "-E-", Double.MaxValue.ToString ("-E-", _nfi));
\r
2366 public void Test11015 () {
\r
2367 AssertEquals ("#01", "--E", Double.MinValue.ToString ("-E", _nfi));
\r
2368 AssertEquals ("#02", "-E-", Double.MinValue.ToString ("E-", _nfi));
\r
2369 AssertEquals ("#03", "--E-", Double.MinValue.ToString ("-E-", _nfi));
\r
2373 public void Test11016 () {
\r
2374 AssertEquals ("#01", "E+0", 0.0.ToString ("E+0", _nfi));
\r
2375 AssertEquals ("#02", "E+0", Double.MaxValue.ToString ("E+0", _nfi));
\r
2376 AssertEquals ("#03", "E+0", Double.MinValue.ToString ("E+0", _nfi));
\r
2380 public void Test11017 () {
\r
2381 AssertEquals ("#01", "E+9", 0.0.ToString ("E+9", _nfi));
\r
2382 AssertEquals ("#02", "E+9", Double.MaxValue.ToString ("E+9", _nfi));
\r
2383 AssertEquals ("#03", "-E+9", Double.MinValue.ToString ("E+9", _nfi));
\r
2387 public void Test11018 () {
\r
2388 AssertEquals ("#01", "E-9", 0.0.ToString ("E-9", _nfi));
\r
2389 AssertEquals ("#02", "E-9", Double.MaxValue.ToString ("E-9", _nfi));
\r
2390 AssertEquals ("#03", "-E-9", Double.MinValue.ToString ("E-9", _nfi));
\r
2394 public void Test11019 () {
\r
2395 AssertEquals ("#01", "E0", 0.0.ToString ("E0,", _nfi));
\r
2396 AssertEquals ("#02", "E0", Double.MaxValue.ToString ("E0,", _nfi));
\r
2397 AssertEquals ("#03", "E0", Double.MinValue.ToString ("E0,", _nfi));
\r
2401 public void Test11020 () {
\r
2402 AssertEquals ("#01", "E0", 0.0.ToString ("E0.", _nfi));
\r
2403 AssertEquals ("#02", "E0", Double.MaxValue.ToString ("E0.", _nfi));
\r
2404 AssertEquals ("#03", "E0", Double.MinValue.ToString ("E0.", _nfi));
\r
2408 public void Test11021 () {
\r
2409 AssertEquals ("#01", "E0.0", 0.0.ToString ("E0.0", _nfi));
\r
2410 AssertEquals ("#02", "E309.2", Double.MaxValue.ToString ("E0.0", _nfi));
\r
2411 AssertEquals ("#03", "-E309.2", Double.MinValue.ToString ("E0.0", _nfi));
\r
2415 public void Test11022 () {
\r
2416 AssertEquals ("#01", "E09", 0.0.ToString ("E0.9", _nfi));
\r
2417 AssertEquals ("#02", "E09", Double.MaxValue.ToString ("E0.9", _nfi));
\r
2418 AssertEquals ("#03", "E09", Double.MinValue.ToString ("E0.9", _nfi));
\r
2422 public void Test11023 () {
\r
2423 AssertEquals ("#01", "1.1E+000", 1.05.ToString ("E1", _nfi));
\r
2424 AssertEquals ("#02", "1.2E+000", 1.15.ToString ("E1", _nfi));
\r
2425 AssertEquals ("#03", "1.3E+000", 1.25.ToString ("E1", _nfi));
\r
2426 AssertEquals ("#04", "1.4E+000", 1.35.ToString ("E1", _nfi));
\r
2427 AssertEquals ("#05", "1.5E+000", 1.45.ToString ("E1", _nfi));
\r
2428 AssertEquals ("#06", "1.6E+000", 1.55.ToString ("E1", _nfi));
\r
2429 AssertEquals ("#07", "1.7E+000", 1.65.ToString ("E1", _nfi));
\r
2430 AssertEquals ("#08", "1.8E+000", 1.75.ToString ("E1", _nfi));
\r
2431 AssertEquals ("#09", "1.9E+000", 1.85.ToString ("E1", _nfi));
\r
2432 AssertEquals ("#10", "2.0E+000", 1.95.ToString ("E1", _nfi));
\r
2436 public void Test11024 () {
\r
2437 AssertEquals ("#01", "1.01E+000", 1.005.ToString ("E2", _nfi));
\r
2438 AssertEquals ("#02", "1.02E+000", 1.015.ToString ("E2", _nfi));
\r
2439 AssertEquals ("#03", "1.03E+000", 1.025.ToString ("E2", _nfi));
\r
2440 AssertEquals ("#04", "1.04E+000", 1.035.ToString ("E2", _nfi));
\r
2441 AssertEquals ("#05", "1.05E+000", 1.045.ToString ("E2", _nfi));
\r
2442 AssertEquals ("#06", "1.06E+000", 1.055.ToString ("E2", _nfi));
\r
2443 AssertEquals ("#07", "1.07E+000", 1.065.ToString ("E2", _nfi));
\r
2444 AssertEquals ("#08", "1.08E+000", 1.075.ToString ("E2", _nfi));
\r
2445 AssertEquals ("#09", "1.09E+000", 1.085.ToString ("E2", _nfi));
\r
2446 AssertEquals ("#10", "1.10E+000", 1.095.ToString ("E2", _nfi));
\r
2450 public void Test11025 () {
\r
2451 AssertEquals ("#01", "1.00000000000001E+000", 1.000000000000005.ToString ("E14", _nfi));
\r
2452 AssertEquals ("#02", "1.00000000000002E+000", 1.000000000000015.ToString ("E14", _nfi));
\r
2453 AssertEquals ("#03", "1.00000000000003E+000", 1.000000000000025.ToString ("E14", _nfi));
\r
2454 AssertEquals ("#04", "1.00000000000004E+000", 1.000000000000035.ToString ("E14", _nfi));
\r
2455 AssertEquals ("#05", "1.00000000000005E+000", 1.000000000000045.ToString ("E14", _nfi));
\r
2456 AssertEquals ("#06", "1.00000000000006E+000", 1.000000000000055.ToString ("E14", _nfi));
\r
2457 AssertEquals ("#07", "1.00000000000007E+000", 1.000000000000065.ToString ("E14", _nfi));
\r
2458 AssertEquals ("#08", "1.00000000000008E+000", 1.000000000000075.ToString ("E14", _nfi));
\r
2459 AssertEquals ("#09", "1.00000000000009E+000", 1.000000000000085.ToString ("E14", _nfi));
\r
2460 AssertEquals ("#10", "1.00000000000010E+000", 1.000000000000095.ToString ("E14", _nfi));
\r
2464 public void Test11026 () {
\r
2465 AssertEquals ("#01", "1.000000000000000E+000", 1.0000000000000005.ToString ("E15", _nfi));
\r
2466 AssertEquals ("#02", "1.000000000000002E+000", 1.0000000000000015.ToString ("E15", _nfi));
\r
2467 AssertEquals ("#03", "1.000000000000002E+000", 1.0000000000000025.ToString ("E15", _nfi));
\r
2468 AssertEquals ("#04", "1.000000000000004E+000", 1.0000000000000035.ToString ("E15", _nfi));
\r
2469 AssertEquals ("#05", "1.000000000000004E+000", 1.0000000000000045.ToString ("E15", _nfi));
\r
2470 AssertEquals ("#06", "1.000000000000006E+000", 1.0000000000000055.ToString ("E15", _nfi));
\r
2471 AssertEquals ("#07", "1.000000000000006E+000", 1.0000000000000065.ToString ("E15", _nfi));
\r
2472 AssertEquals ("#08", "1.000000000000008E+000", 1.0000000000000075.ToString ("E15", _nfi));
\r
2473 AssertEquals ("#09", "1.000000000000008E+000", 1.0000000000000085.ToString ("E15", _nfi));
\r
2474 AssertEquals ("#10", "1.000000000000010E+000", 1.0000000000000095.ToString ("E15", _nfi));
\r
2478 public void Test11027 () {
\r
2479 AssertEquals ("#01", "1.0000000000000000E+000", 1.00000000000000005.ToString ("E16", _nfi));
\r
2480 AssertEquals ("#02", "1.0000000000000002E+000", 1.00000000000000015.ToString ("E16", _nfi));
\r
2481 AssertEquals ("#03", "1.0000000000000002E+000", 1.00000000000000025.ToString ("E16", _nfi));
\r
2482 AssertEquals ("#04", "1.0000000000000004E+000", 1.00000000000000035.ToString ("E16", _nfi));
\r
2483 AssertEquals ("#05", "1.0000000000000004E+000", 1.00000000000000045.ToString ("E16", _nfi));
\r
2484 AssertEquals ("#06", "1.0000000000000004E+000", 1.00000000000000055.ToString ("E16", _nfi));
\r
2485 AssertEquals ("#07", "1.0000000000000007E+000", 1.00000000000000065.ToString ("E16", _nfi));
\r
2486 AssertEquals ("#08", "1.0000000000000007E+000", 1.00000000000000075.ToString ("E16", _nfi));
\r
2487 AssertEquals ("#09", "1.0000000000000009E+000", 1.00000000000000085.ToString ("E16", _nfi));
\r
2488 AssertEquals ("#10", "1.0000000000000009E+000", 1.00000000000000095.ToString ("E16", _nfi));
\r
2492 public void Test11028 () {
\r
2493 AssertEquals ("#01", "1.00000000000000000E+000", 1.000000000000000005.ToString ("E17", _nfi));
\r
2494 AssertEquals ("#02", "1.00000000000000000E+000", 1.000000000000000015.ToString ("E17", _nfi));
\r
2495 AssertEquals ("#03", "1.00000000000000000E+000", 1.000000000000000025.ToString ("E17", _nfi));
\r
2496 AssertEquals ("#04", "1.00000000000000000E+000", 1.000000000000000035.ToString ("E17", _nfi));
\r
2497 AssertEquals ("#05", "1.00000000000000000E+000", 1.000000000000000045.ToString ("E17", _nfi));
\r
2498 AssertEquals ("#06", "1.00000000000000000E+000", 1.000000000000000055.ToString ("E17", _nfi));
\r
2499 AssertEquals ("#07", "1.00000000000000000E+000", 1.000000000000000065.ToString ("E17", _nfi));
\r
2500 AssertEquals ("#08", "1.00000000000000000E+000", 1.000000000000000075.ToString ("E17", _nfi));
\r
2501 AssertEquals ("#09", "1.00000000000000000E+000", 1.000000000000000085.ToString ("E17", _nfi));
\r
2502 AssertEquals ("#10", "1.00000000000000000E+000", 1.000000000000000095.ToString ("E17", _nfi));
\r
2506 public void Test11029 () {
\r
2507 AssertEquals ("#01", "1E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E0"));
\r
2508 AssertEquals ("#02", "1.2345678901234567E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E16"));
\r
2509 AssertEquals ("#03", "1.23456789012345670E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E17"));
\r
2510 AssertEquals ("#04", "1.234567890123456700000000000000000000000000000000000000000000000000000000000000000000000000000000000E+000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E99"));
\r
2511 AssertEquals ("#04", "E101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("E100"));
\r
2515 public void Test11030 () {
\r
2516 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
2517 nfi.NumberDecimalSeparator = "#";
\r
2518 AssertEquals ("#01", "-1#000000E+008", (-99999999.9).ToString ("E", nfi));
\r
2522 public void Test11031 () {
\r
2523 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
2524 nfi.NegativeSign = "+";
\r
2525 nfi.PositiveSign = "-";
\r
2527 AssertEquals ("#01", "1.000000E-000", 1.0.ToString ("E", nfi));
\r
2528 AssertEquals ("#02", "0.000000E-000", 0.0.ToString ("E", nfi));
\r
2529 AssertEquals ("#03", "+1.000000E-000", (-1.0).ToString ("E", nfi));
\r
2533 public void Test11032 () {
\r
2534 AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("E99", _nfi));
\r
2535 AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("E99", _nfi));
\r
2536 AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("E99", _nfi));
\r
2539 // Test12000- Double and F
\r
2541 public void Test12000 () {
\r
2542 AssertEquals ("#01", "0.00", 0.0.ToString ("F", _nfi));
\r
2543 AssertEquals ("#02", "0.00", 0.0.ToString ("f", _nfi));
\r
2544 AssertEquals ("#03", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("F", _nfi));
\r
2545 AssertEquals ("#04", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MinValue.ToString ("f", _nfi));
\r
2546 AssertEquals ("#05", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("F", _nfi));
\r
2547 AssertEquals ("#06", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00", Double.MaxValue.ToString ("f", _nfi));
\r
2551 public void Test12001 () {
\r
2552 AssertEquals ("#01", "F ", 0.0.ToString ("F ", _nfi));
\r
2553 AssertEquals ("#02", " F", 0.0.ToString (" F", _nfi));
\r
2554 AssertEquals ("#03", " F ", 0.0.ToString (" F ", _nfi));
\r
2558 public void Test12002 () {
\r
2559 AssertEquals ("#01", "-F ", (-1.0).ToString ("F ", _nfi));
\r
2560 AssertEquals ("#02", "- F", (-1.0).ToString (" F", _nfi));
\r
2561 AssertEquals ("#03", "- F ", (-1.0).ToString (" F ", _nfi));
\r
2565 public void Test12003 () {
\r
2566 AssertEquals ("#01", "0", 0.0.ToString ("F0", _nfi));
\r
2567 AssertEquals ("#02", "0.0000000000000000", 0.0.ToString ("F16", _nfi));
\r
2568 AssertEquals ("#03", "0.00000000000000000", 0.0.ToString ("F17", _nfi));
\r
2569 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("F99", _nfi));
\r
2570 AssertEquals ("#05", "F100", 0.0.ToString ("F100", _nfi));
\r
2574 public void Test12004 () {
\r
2575 AssertEquals ("#01", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0", _nfi));
\r
2576 AssertEquals ("#02", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MaxValue.ToString ("F16", _nfi));
\r
2577 AssertEquals ("#03", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F17", _nfi));
\r
2578 AssertEquals ("#04", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F99", _nfi));
\r
2579 AssertEquals ("#05", "F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F100", _nfi));
\r
2583 public void Test12005 () {
\r
2584 AssertEquals ("#01", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0", _nfi));
\r
2585 AssertEquals ("#02", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000000", Double.MinValue.ToString ("F16", _nfi));
\r
2586 AssertEquals ("#03", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F17", _nfi));
\r
2587 AssertEquals ("#04", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F99", _nfi));
\r
2588 AssertEquals ("#05", "-F1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F100", _nfi));
\r
2592 public void Test12006 () {
\r
2593 AssertEquals ("#01", "FF", 0.0.ToString ("FF", _nfi));
\r
2594 AssertEquals ("#02", "F0F", 0.0.ToString ("F0F", _nfi));
\r
2595 AssertEquals ("#03", "F0xF", 0.0.ToString ("F0xF", _nfi));
\r
2599 public void Test12007 () {
\r
2600 AssertEquals ("#01", "FF", Double.MaxValue.ToString ("FF", _nfi));
\r
2601 AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("F0F", _nfi));
\r
2602 AssertEquals ("#03", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("F0xF", _nfi));
\r
2606 public void Test12008 () {
\r
2607 AssertEquals ("#01", "-FF", Double.MinValue.ToString ("FF", _nfi));
\r
2608 AssertEquals ("#02", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("F0F", _nfi));
\r
2609 AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("F0xF", _nfi));
\r
2613 public void Test12009 () {
\r
2614 AssertEquals ("#01", "0.00000000000000000", 0.0.ToString ("F0000000000000000000000000000000000000017", _nfi));
\r
2615 AssertEquals ("#02", "179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MaxValue.ToString ("F0000000000000000000000000000000000000017", _nfi));
\r
2616 AssertEquals ("#03", "-179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000", Double.MinValue.ToString ("F0000000000000000000000000000000000000017", _nfi));
\r
2620 public void Test12010 () {
\r
2621 AssertEquals ("#01", "+F", 0.0.ToString ("+F", _nfi));
\r
2622 AssertEquals ("#02", "F+", 0.0.ToString ("F+", _nfi));
\r
2623 AssertEquals ("#03", "+F+", 0.0.ToString ("+F+", _nfi));
\r
2627 public void Test12011 () {
\r
2628 AssertEquals ("#01", "+F", Double.MaxValue.ToString ("+F", _nfi));
\r
2629 AssertEquals ("#02", "F+", Double.MaxValue.ToString ("F+", _nfi));
\r
2630 AssertEquals ("#03", "+F+", Double.MaxValue.ToString ("+F+", _nfi));
\r
2634 public void Test12012 () {
\r
2635 AssertEquals ("#01", "-+F", Double.MinValue.ToString ("+F", _nfi));
\r
2636 AssertEquals ("#02", "-F+", Double.MinValue.ToString ("F+", _nfi));
\r
2637 AssertEquals ("#03", "-+F+", Double.MinValue.ToString ("+F+", _nfi));
\r
2641 public void Test12013 () {
\r
2642 AssertEquals ("#01", "-F", 0.0.ToString ("-F", _nfi));
\r
2643 AssertEquals ("#02", "F-", 0.0.ToString ("F-", _nfi));
\r
2644 AssertEquals ("#03", "-F-", 0.0.ToString ("-F-", _nfi));
\r
2648 public void Test12014 () {
\r
2649 AssertEquals ("#01", "-F", Double.MaxValue.ToString ("-F", _nfi));
\r
2650 AssertEquals ("#02", "F-", Double.MaxValue.ToString ("F-", _nfi));
\r
2651 AssertEquals ("#03", "-F-", Double.MaxValue.ToString ("-F-", _nfi));
\r
2655 public void Test12015 () {
\r
2656 AssertEquals ("#01", "--F", Double.MinValue.ToString ("-F", _nfi));
\r
2657 AssertEquals ("#02", "-F-", Double.MinValue.ToString ("F-", _nfi));
\r
2658 AssertEquals ("#03", "--F-", Double.MinValue.ToString ("-F-", _nfi));
\r
2662 public void Test12016 () {
\r
2663 AssertEquals ("#01", "F+0", 0.0.ToString ("F+0", _nfi));
\r
2664 AssertEquals ("#02", "F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F+0", _nfi));
\r
2665 AssertEquals ("#03", "-F+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F+0", _nfi));
\r
2669 public void Test12017 () {
\r
2670 AssertEquals ("#01", "F+9", 0.0.ToString ("F+9", _nfi));
\r
2671 AssertEquals ("#02", "F+9", Double.MaxValue.ToString ("F+9", _nfi));
\r
2672 AssertEquals ("#03", "-F+9", Double.MinValue.ToString ("F+9", _nfi));
\r
2676 public void Test12018 () {
\r
2677 AssertEquals ("#01", "F-9", 0.0.ToString ("F-9", _nfi));
\r
2678 AssertEquals ("#02", "F-9", Double.MaxValue.ToString ("F-9", _nfi));
\r
2679 AssertEquals ("#03", "-F-9", Double.MinValue.ToString ("F-9", _nfi));
\r
2683 public void Test12019 () {
\r
2684 AssertEquals ("#01", "F0", 0.0.ToString ("F0,", _nfi));
\r
2685 AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0,", _nfi));
\r
2686 AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0,", _nfi));
\r
2690 public void Test12020 () {
\r
2691 AssertEquals ("#01", "F0", 0.0.ToString ("F0.", _nfi));
\r
2692 AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("F0.", _nfi));
\r
2693 AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("F0.", _nfi));
\r
2697 public void Test12021 () {
\r
2698 AssertEquals ("#01", "F0.0", 0.0.ToString ("F0.0", _nfi));
\r
2699 AssertEquals ("#02", "F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("F0.0", _nfi));
\r
2700 AssertEquals ("#03", "-F179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("F0.0", _nfi));
\r
2704 public void Test12022 () {
\r
2705 AssertEquals ("#01", "F09", 0.0.ToString ("F0.9", _nfi));
\r
2706 AssertEquals ("#02", "F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("F0.9", _nfi));
\r
2707 AssertEquals ("#03", "-F1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("F0.9", _nfi));
\r
2711 public void Test12023 () {
\r
2712 AssertEquals ("#01", "1.1", 1.05.ToString ("F1", _nfi));
\r
2713 AssertEquals ("#02", "1.2", 1.15.ToString ("F1", _nfi));
\r
2714 AssertEquals ("#03", "1.3", 1.25.ToString ("F1", _nfi));
\r
2715 AssertEquals ("#04", "1.4", 1.35.ToString ("F1", _nfi));
\r
2716 AssertEquals ("#05", "1.5", 1.45.ToString ("F1", _nfi));
\r
2717 AssertEquals ("#06", "1.6", 1.55.ToString ("F1", _nfi));
\r
2718 AssertEquals ("#07", "1.7", 1.65.ToString ("F1", _nfi));
\r
2719 AssertEquals ("#08", "1.8", 1.75.ToString ("F1", _nfi));
\r
2720 AssertEquals ("#09", "1.9", 1.85.ToString ("F1", _nfi));
\r
2721 AssertEquals ("#10", "2.0", 1.95.ToString ("F1", _nfi));
\r
2725 public void Test12024 () {
\r
2726 AssertEquals ("#01", "1.01", 1.005.ToString ("F2", _nfi));
\r
2727 AssertEquals ("#02", "1.02", 1.015.ToString ("F2", _nfi));
\r
2728 AssertEquals ("#03", "1.03", 1.025.ToString ("F2", _nfi));
\r
2729 AssertEquals ("#04", "1.04", 1.035.ToString ("F2", _nfi));
\r
2730 AssertEquals ("#05", "1.05", 1.045.ToString ("F2", _nfi));
\r
2731 AssertEquals ("#06", "1.06", 1.055.ToString ("F2", _nfi));
\r
2732 AssertEquals ("#07", "1.07", 1.065.ToString ("F2", _nfi));
\r
2733 AssertEquals ("#08", "1.08", 1.075.ToString ("F2", _nfi));
\r
2734 AssertEquals ("#09", "1.09", 1.085.ToString ("F2", _nfi));
\r
2735 AssertEquals ("#10", "1.10", 1.095.ToString ("F2", _nfi));
\r
2739 public void Test12025 () {
\r
2740 AssertEquals ("#01", "1.00000000000001", 1.000000000000005.ToString ("F14", _nfi));
\r
2741 AssertEquals ("#02", "1.00000000000002", 1.000000000000015.ToString ("F14", _nfi));
\r
2742 AssertEquals ("#03", "1.00000000000003", 1.000000000000025.ToString ("F14", _nfi));
\r
2743 AssertEquals ("#04", "1.00000000000004", 1.000000000000035.ToString ("F14", _nfi));
\r
2744 AssertEquals ("#05", "1.00000000000005", 1.000000000000045.ToString ("F14", _nfi));
\r
2745 AssertEquals ("#06", "1.00000000000006", 1.000000000000055.ToString ("F14", _nfi));
\r
2746 AssertEquals ("#07", "1.00000000000007", 1.000000000000065.ToString ("F14", _nfi));
\r
2747 AssertEquals ("#08", "1.00000000000008", 1.000000000000075.ToString ("F14", _nfi));
\r
2748 AssertEquals ("#09", "1.00000000000009", 1.000000000000085.ToString ("F14", _nfi));
\r
2749 AssertEquals ("#10", "1.00000000000010", 1.000000000000095.ToString ("F14", _nfi));
\r
2753 public void Test12026 () {
\r
2754 AssertEquals ("#01", "1.000000000000000", 1.0000000000000005.ToString ("F15", _nfi));
\r
2755 AssertEquals ("#02", "1.000000000000000", 1.0000000000000015.ToString ("F15", _nfi));
\r
2756 AssertEquals ("#03", "1.000000000000000", 1.0000000000000025.ToString ("F15", _nfi));
\r
2757 AssertEquals ("#04", "1.000000000000000", 1.0000000000000035.ToString ("F15", _nfi));
\r
2758 AssertEquals ("#05", "1.000000000000000", 1.0000000000000045.ToString ("F15", _nfi));
\r
2759 AssertEquals ("#06", "1.000000000000010", 1.0000000000000055.ToString ("F15", _nfi));
\r
2760 AssertEquals ("#07", "1.000000000000010", 1.0000000000000065.ToString ("F15", _nfi));
\r
2761 AssertEquals ("#08", "1.000000000000010", 1.0000000000000075.ToString ("F15", _nfi));
\r
2762 AssertEquals ("#09", "1.000000000000010", 1.0000000000000085.ToString ("F15", _nfi));
\r
2763 AssertEquals ("#10", "1.000000000000010", 1.0000000000000095.ToString ("F15", _nfi));
\r
2767 public void Test12027 () {
\r
2768 AssertEquals ("#01", "1.0000000000000000", 1.00000000000000005.ToString ("F16", _nfi));
\r
2769 AssertEquals ("#02", "1.0000000000000000", 1.00000000000000015.ToString ("F16", _nfi));
\r
2770 AssertEquals ("#03", "1.0000000000000000", 1.00000000000000025.ToString ("F16", _nfi));
\r
2771 AssertEquals ("#04", "1.0000000000000000", 1.00000000000000035.ToString ("F16", _nfi));
\r
2772 AssertEquals ("#05", "1.0000000000000000", 1.00000000000000045.ToString ("F16", _nfi));
\r
2773 AssertEquals ("#06", "1.0000000000000000", 1.00000000000000055.ToString ("F16", _nfi));
\r
2774 AssertEquals ("#07", "1.0000000000000000", 1.00000000000000065.ToString ("F16", _nfi));
\r
2775 AssertEquals ("#08", "1.0000000000000000", 1.00000000000000075.ToString ("F16", _nfi));
\r
2776 AssertEquals ("#09", "1.0000000000000000", 1.00000000000000085.ToString ("F16", _nfi));
\r
2777 AssertEquals ("#10", "1.0000000000000000", 1.00000000000000095.ToString ("F16", _nfi));
\r
2781 public void Test12028 () {
\r
2782 AssertEquals ("#01", "1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F0", _nfi));
\r
2783 AssertEquals ("#02", "1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F12", _nfi));
\r
2784 AssertEquals ("#03", "1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F13", _nfi));
\r
2785 AssertEquals ("#04", "1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F14", _nfi));
\r
2786 AssertEquals ("#05", "1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F15", _nfi));
\r
2787 AssertEquals ("#06", "1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F99", _nfi));
\r
2788 AssertEquals ("#07", "F101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("F100", _nfi));
\r
2792 public void Test12029 () {
\r
2793 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
2794 nfi.NumberDecimalSeparator = "#";
\r
2795 AssertEquals ("#01", "-99999999#90", (-99999999.9).ToString ("F", nfi));
\r
2799 public void Test12030 () {
\r
2800 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
2801 nfi.NegativeSign = "+";
\r
2802 nfi.PositiveSign = "-";
\r
2804 AssertEquals ("#01", "1.00", 1.0.ToString ("F", nfi));
\r
2805 AssertEquals ("#02", "0.00", 0.0.ToString ("F", nfi));
\r
2806 AssertEquals ("#03", "+1.00", (-1.0).ToString ("F", nfi));
\r
2810 public void Test12031 () {
\r
2811 AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("F99", _nfi));
\r
2812 AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("F99", _nfi));
\r
2813 AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("F99", _nfi));
\r
2816 // Test13000- Double and G
\r
2818 public void Test13000 () {
\r
2819 AssertEquals ("#01", "0", 0.0.ToString ("G", _nfi));
\r
2820 AssertEquals ("#02", "0", 0.0.ToString ("g", _nfi));
\r
2821 AssertEquals ("#03", "-1.79769313486232E+308", Double.MinValue.ToString ("G", _nfi));
\r
2822 AssertEquals ("#04", "-1.79769313486232e+308", Double.MinValue.ToString ("g", _nfi));
\r
2823 AssertEquals ("#05", "1.79769313486232E+308", Double.MaxValue.ToString ("G", _nfi));
\r
2824 AssertEquals ("#06", "1.79769313486232e+308", Double.MaxValue.ToString ("g", _nfi));
\r
2828 public void Test13001 () {
\r
2829 AssertEquals ("#01", "G ", 0.0.ToString ("G ", _nfi));
\r
2830 AssertEquals ("#02", " G", 0.0.ToString (" G", _nfi));
\r
2831 AssertEquals ("#03", " G ", 0.0.ToString (" G ", _nfi));
\r
2835 public void Test13002 () {
\r
2836 AssertEquals ("#01", "-G ", (-1.0).ToString ("G ", _nfi));
\r
2837 AssertEquals ("#02", "- G", (-1.0).ToString (" G", _nfi));
\r
2838 AssertEquals ("#03", "- G ", (-1.0).ToString (" G ", _nfi));
\r
2842 public void Test13003 () {
\r
2843 AssertEquals ("#01", "0", 0.0.ToString ("G0", _nfi));
\r
2844 AssertEquals ("#02", "0", 0.0.ToString ("G16", _nfi));
\r
2845 AssertEquals ("#03", "0", 0.0.ToString ("G17", _nfi));
\r
2846 AssertEquals ("#04", "0", 0.0.ToString ("G99", _nfi));
\r
2847 AssertEquals ("#05", "G100", 0.0.ToString ("G100", _nfi));
\r
2851 public void Test13004 () {
\r
2852 AssertEquals ("#01", "1.79769313486232E+308", Double.MaxValue.ToString ("G0", _nfi));
\r
2853 AssertEquals ("#02", "1.797693134862316E+308", Double.MaxValue.ToString ("G16", _nfi));
\r
2854 AssertEquals ("#03", "1.7976931348623157E+308", Double.MaxValue.ToString ("G17", _nfi));
\r
2855 AssertEquals ("#04", "1.7976931348623157E+308", Double.MaxValue.ToString ("G99", _nfi));
\r
2856 AssertEquals ("#05", "G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G100", _nfi));
\r
2860 public void Test13005 () {
\r
2861 AssertEquals ("#01", "-1.79769313486232E+308", Double.MinValue.ToString ("G0", _nfi));
\r
2862 AssertEquals ("#02", "-1.797693134862316E+308", Double.MinValue.ToString ("G16", _nfi));
\r
2863 AssertEquals ("#03", "-1.7976931348623157E+308", Double.MinValue.ToString ("G17", _nfi));
\r
2864 AssertEquals ("#04", "-1.7976931348623157E+308", Double.MinValue.ToString ("G99", _nfi));
\r
2865 AssertEquals ("#05", "-G1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G100", _nfi));
\r
2869 public void Test13006 () {
\r
2870 AssertEquals ("#01", "GF", 0.0.ToString ("GF", _nfi));
\r
2871 AssertEquals ("#02", "G0F", 0.0.ToString ("G0F", _nfi));
\r
2872 AssertEquals ("#03", "G0xF", 0.0.ToString ("G0xF", _nfi));
\r
2876 public void Test13007 () {
\r
2877 AssertEquals ("#01", "GF", Double.MaxValue.ToString ("GF", _nfi));
\r
2878 AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("G0F", _nfi));
\r
2879 AssertEquals ("#03", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("G0xF", _nfi));
\r
2883 public void Test13008 () {
\r
2884 AssertEquals ("#01", "-GF", Double.MinValue.ToString ("GF", _nfi));
\r
2885 AssertEquals ("#02", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("G0F", _nfi));
\r
2886 AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("G0xF", _nfi));
\r
2890 public void Test13009 () {
\r
2891 AssertEquals ("#01", "0", 0.0.ToString ("G0000000000000000000000000000000000000017", _nfi));
\r
2892 AssertEquals ("#02", "1.7976931348623157E+308", Double.MaxValue.ToString ("G0000000000000000000000000000000000000017", _nfi));
\r
2893 AssertEquals ("#03", "-1.7976931348623157E+308", Double.MinValue.ToString ("G0000000000000000000000000000000000000017", _nfi));
\r
2897 public void Test13010 () {
\r
2898 AssertEquals ("#01", "+G", 0.0.ToString ("+G", _nfi));
\r
2899 AssertEquals ("#02", "G+", 0.0.ToString ("G+", _nfi));
\r
2900 AssertEquals ("#03", "+G+", 0.0.ToString ("+G+", _nfi));
\r
2904 public void Test13011 () {
\r
2905 AssertEquals ("#01", "+G", Double.MaxValue.ToString ("+G", _nfi));
\r
2906 AssertEquals ("#02", "G+", Double.MaxValue.ToString ("G+", _nfi));
\r
2907 AssertEquals ("#03", "+G+", Double.MaxValue.ToString ("+G+", _nfi));
\r
2911 public void Test13012 () {
\r
2912 AssertEquals ("#01", "-+G", Double.MinValue.ToString ("+G", _nfi));
\r
2913 AssertEquals ("#02", "-G+", Double.MinValue.ToString ("G+", _nfi));
\r
2914 AssertEquals ("#03", "-+G+", Double.MinValue.ToString ("+G+", _nfi));
\r
2918 public void Test13013 () {
\r
2919 AssertEquals ("#01", "-G", 0.0.ToString ("-G", _nfi));
\r
2920 AssertEquals ("#02", "G-", 0.0.ToString ("G-", _nfi));
\r
2921 AssertEquals ("#03", "-G-", 0.0.ToString ("-G-", _nfi));
\r
2925 public void Test13014 () {
\r
2926 AssertEquals ("#01", "-G", Double.MaxValue.ToString ("-G", _nfi));
\r
2927 AssertEquals ("#02", "G-", Double.MaxValue.ToString ("G-", _nfi));
\r
2928 AssertEquals ("#03", "-G-", Double.MaxValue.ToString ("-G-", _nfi));
\r
2932 public void Test13015 () {
\r
2933 AssertEquals ("#01", "--G", Double.MinValue.ToString ("-G", _nfi));
\r
2934 AssertEquals ("#02", "-G-", Double.MinValue.ToString ("G-", _nfi));
\r
2935 AssertEquals ("#03", "--G-", Double.MinValue.ToString ("-G-", _nfi));
\r
2939 public void Test13016 () {
\r
2940 AssertEquals ("#01", "G+0", 0.0.ToString ("G+0", _nfi));
\r
2941 AssertEquals ("#02", "G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G+0", _nfi));
\r
2942 AssertEquals ("#03", "-G+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G+0", _nfi));
\r
2946 public void Test13017 () {
\r
2947 AssertEquals ("#01", "G+9", 0.0.ToString ("G+9", _nfi));
\r
2948 AssertEquals ("#02", "G+9", Double.MaxValue.ToString ("G+9", _nfi));
\r
2949 AssertEquals ("#03", "-G+9", Double.MinValue.ToString ("G+9", _nfi));
\r
2953 public void Test13018 () {
\r
2954 AssertEquals ("#01", "G-9", 0.0.ToString ("G-9", _nfi));
\r
2955 AssertEquals ("#02", "G-9", Double.MaxValue.ToString ("G-9", _nfi));
\r
2956 AssertEquals ("#03", "-G-9", Double.MinValue.ToString ("G-9", _nfi));
\r
2960 public void Test13019 () {
\r
2961 AssertEquals ("#01", "G0", 0.0.ToString ("G0,", _nfi));
\r
2962 AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0,", _nfi));
\r
2963 AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0,", _nfi));
\r
2967 public void Test13020 () {
\r
2968 AssertEquals ("#01", "G0", 0.0.ToString ("G0.", _nfi));
\r
2969 AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("G0.", _nfi));
\r
2970 AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("G0.", _nfi));
\r
2974 public void Test13021 () {
\r
2975 AssertEquals ("#01", "G0.0", 0.0.ToString ("G0.0", _nfi));
\r
2976 AssertEquals ("#02", "G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("G0.0", _nfi));
\r
2977 AssertEquals ("#03", "-G179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("G0.0", _nfi));
\r
2981 public void Test13022 () {
\r
2982 AssertEquals ("#01", "G09", 0.0.ToString ("G0.9", _nfi));
\r
2983 AssertEquals ("#02", "G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("G0.9", _nfi));
\r
2984 AssertEquals ("#03", "-G1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("G0.9", _nfi));
\r
2988 public void Test13023 () {
\r
2989 AssertEquals ("#01", "0.5", 0.5.ToString ("G1", _nfi));
\r
2990 AssertEquals ("#02", "2", 1.5.ToString ("G1", _nfi));
\r
2991 AssertEquals ("#03", "3", 2.5.ToString ("G1", _nfi));
\r
2992 AssertEquals ("#04", "4", 3.5.ToString ("G1", _nfi));
\r
2993 AssertEquals ("#05", "5", 4.5.ToString ("G1", _nfi));
\r
2994 AssertEquals ("#06", "6", 5.5.ToString ("G1", _nfi));
\r
2995 AssertEquals ("#07", "7", 6.5.ToString ("G1", _nfi));
\r
2996 AssertEquals ("#08", "8", 7.5.ToString ("G1", _nfi));
\r
2997 AssertEquals ("#09", "9", 8.5.ToString ("G1", _nfi));
\r
2998 AssertEquals ("#10", "1E+01", 9.5.ToString ("G1", _nfi));
\r
3002 public void Test13024_CarryPropagation ()
3005 AssertEquals ("#01", "1", d.ToString ("G1", _nfi));
\r
3006 // NumberStore converts 1.15 into 1.14999...91 (1 in index 17)
3007 // so the call to NumberToString doesn't result in 1.2 but in 1.1
\r
3008 // which seems "somewhat" normal considering the #17 results,
3009 AssertEquals ("#02", "1.2", d.ToString ("G2", _nfi));
\r
3010 AssertEquals ("#03", "1.15", d.ToString ("G3", _nfi));
\r
3011 AssertEquals ("#04", "1.15", d.ToString ("G4", _nfi));
\r
3012 AssertEquals ("#05", "1.15", d.ToString ("G5", _nfi));
\r
3013 AssertEquals ("#06", "1.15", d.ToString ("G6", _nfi));
\r
3014 AssertEquals ("#07", "1.15", d.ToString ("G7", _nfi));
\r
3015 AssertEquals ("#08", "1.15", d.ToString ("G8", _nfi));
\r
3016 AssertEquals ("#09", "1.15", d.ToString ("G9", _nfi));
\r
3017 AssertEquals ("#10", "1.15", d.ToString ("G10", _nfi));
\r
3018 AssertEquals ("#11", "1.15", d.ToString ("G11", _nfi));
\r
3019 AssertEquals ("#12", "1.15", d.ToString ("G12", _nfi));
\r
3020 AssertEquals ("#13", "1.15", d.ToString ("G13", _nfi));
\r
3021 AssertEquals ("#14", "1.15", d.ToString ("G14", _nfi));
\r
3022 AssertEquals ("#15", "1.15", d.ToString ("G15", _nfi));
\r
3023 AssertEquals ("#16", "1.15", d.ToString ("G16", _nfi));
\r
3024 AssertEquals ("#17", "1.1499999999999999", d.ToString ("G17", _nfi));
\r
3028 public void Test13024 () {
\r
3029 AssertEquals ("#01", "1.1", 1.05.ToString ("G2", _nfi));
\r
3030 AssertEquals ("#02", "1.2", 1.15.ToString ("G2", _nfi));
\r
3031 AssertEquals ("#03", "1.3", 1.25.ToString ("G2", _nfi));
\r
3032 AssertEquals ("#04", "1.4", 1.35.ToString ("G2", _nfi));
\r
3033 AssertEquals ("#05", "1.5", 1.45.ToString ("G2", _nfi));
\r
3034 AssertEquals ("#06", "1.6", 1.55.ToString ("G2", _nfi));
\r
3035 AssertEquals ("#07", "1.7", 1.65.ToString ("G2", _nfi));
\r
3036 AssertEquals ("#08", "1.8", 1.75.ToString ("G2", _nfi));
\r
3037 AssertEquals ("#09", "1.9", 1.85.ToString ("G2", _nfi));
\r
3038 AssertEquals ("#10", "2", 1.95.ToString ("G2", _nfi));
\r
3042 public void Test13025 () {
\r
3043 AssertEquals ("#01", "10", 10.05.ToString ("G2", _nfi));
\r
3044 AssertEquals ("#02", "10", 10.15.ToString ("G2", _nfi));
\r
3045 AssertEquals ("#03", "10", 10.25.ToString ("G2", _nfi));
\r
3046 AssertEquals ("#04", "10", 10.35.ToString ("G2", _nfi));
\r
3047 AssertEquals ("#05", "10", 10.45.ToString ("G2", _nfi));
\r
3048 AssertEquals ("#06", "11", 10.55.ToString ("G2", _nfi));
\r
3049 AssertEquals ("#07", "11", 10.65.ToString ("G2", _nfi));
\r
3050 AssertEquals ("#08", "11", 10.75.ToString ("G2", _nfi));
\r
3051 AssertEquals ("#09", "11", 10.85.ToString ("G2", _nfi));
\r
3052 AssertEquals ("#10", "11", 10.95.ToString ("G2", _nfi));
\r
3056 public void Test13026 () {
\r
3057 AssertEquals ("#01", "1.00000000000001", 1.000000000000005.ToString ("G15", _nfi));
\r
3058 AssertEquals ("#02", "1.00000000000002", 1.000000000000015.ToString ("G15", _nfi));
\r
3059 AssertEquals ("#03", "1.00000000000003", 1.000000000000025.ToString ("G15", _nfi));
\r
3060 AssertEquals ("#04", "1.00000000000004", 1.000000000000035.ToString ("G15", _nfi));
\r
3061 AssertEquals ("#05", "1.00000000000005", 1.000000000000045.ToString ("G15", _nfi));
\r
3062 AssertEquals ("#06", "1.00000000000006", 1.000000000000055.ToString ("G15", _nfi));
\r
3063 AssertEquals ("#07", "1.00000000000007", 1.000000000000065.ToString ("G15", _nfi));
\r
3064 AssertEquals ("#08", "1.00000000000008", 1.000000000000075.ToString ("G15", _nfi));
\r
3065 AssertEquals ("#09", "1.00000000000009", 1.000000000000085.ToString ("G15", _nfi));
\r
3066 AssertEquals ("#10", "1.0000000000001", 1.000000000000095.ToString ("G15", _nfi));
\r
3070 public void Test13027 () {
\r
3071 AssertEquals ("#01", "1", 1.0000000000000005.ToString ("G16", _nfi));
\r
3072 AssertEquals ("#02", "1.000000000000002", 1.0000000000000015.ToString ("G16", _nfi));
\r
3073 AssertEquals ("#03", "1.000000000000002", 1.0000000000000025.ToString ("G16", _nfi));
\r
3074 AssertEquals ("#04", "1.000000000000004", 1.0000000000000035.ToString ("G16", _nfi));
\r
3075 AssertEquals ("#05", "1.000000000000004", 1.0000000000000045.ToString ("G16", _nfi));
\r
3076 AssertEquals ("#06", "1.000000000000006", 1.0000000000000055.ToString ("G16", _nfi));
\r
3077 AssertEquals ("#07", "1.000000000000006", 1.0000000000000065.ToString ("G16", _nfi));
\r
3078 AssertEquals ("#08", "1.000000000000008", 1.0000000000000075.ToString ("G16", _nfi));
\r
3079 AssertEquals ("#09", "1.000000000000008", 1.0000000000000085.ToString ("G16", _nfi));
\r
3080 AssertEquals ("#10", "1.00000000000001", 1.0000000000000095.ToString ("G16", _nfi));
\r
3084 public void Test13028 () {
\r
3085 AssertEquals ("#01", "1", 1.00000000000000005.ToString ("G17", _nfi));
\r
3086 AssertEquals ("#02", "1.0000000000000002", 1.00000000000000015.ToString ("G17", _nfi));
\r
3087 AssertEquals ("#03", "1.0000000000000002", 1.00000000000000025.ToString ("G17", _nfi));
\r
3088 AssertEquals ("#04", "1.0000000000000004", 1.00000000000000035.ToString ("G17", _nfi));
\r
3089 AssertEquals ("#05", "1.0000000000000004", 1.00000000000000045.ToString ("G17", _nfi));
\r
3090 AssertEquals ("#06", "1.0000000000000004", 1.00000000000000055.ToString ("G17", _nfi));
\r
3091 AssertEquals ("#07", "1.0000000000000007", 1.00000000000000065.ToString ("G17", _nfi));
\r
3092 AssertEquals ("#08", "1.0000000000000007", 1.00000000000000075.ToString ("G17", _nfi));
\r
3093 AssertEquals ("#09", "1.0000000000000009", 1.00000000000000085.ToString ("G17", _nfi));
\r
3094 AssertEquals ("#10", "1.0000000000000009", 1.00000000000000095.ToString ("G17", _nfi));
\r
3098 public void Test13029 () {
\r
3099 AssertEquals ("#01", "1", 1.000000000000000005.ToString ("G18", _nfi));
\r
3100 AssertEquals ("#02", "1", 1.000000000000000015.ToString ("G18", _nfi));
\r
3101 AssertEquals ("#03", "1", 1.000000000000000025.ToString ("G18", _nfi));
\r
3102 AssertEquals ("#04", "1", 1.000000000000000035.ToString ("G18", _nfi));
\r
3103 AssertEquals ("#05", "1", 1.000000000000000045.ToString ("G18", _nfi));
\r
3104 AssertEquals ("#06", "1", 1.000000000000000055.ToString ("G18", _nfi));
\r
3105 AssertEquals ("#07", "1", 1.000000000000000065.ToString ("G18", _nfi));
\r
3106 AssertEquals ("#08", "1", 1.000000000000000075.ToString ("G18", _nfi));
\r
3107 AssertEquals ("#09", "1", 1.000000000000000085.ToString ("G18", _nfi));
\r
3108 AssertEquals ("#10", "1", 1.000000000000000095.ToString ("G18", _nfi));
\r
3112 public void Test13030 () {
\r
3113 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
3114 nfi.NumberDecimalSeparator = "#";
\r
3115 AssertEquals ("#01", "-99999999#9", (-99999999.9).ToString ("G", nfi));
\r
3119 public void Test13031 () {
\r
3120 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
3121 nfi.NegativeSign = "+";
\r
3122 nfi.PositiveSign = "-";
\r
3124 AssertEquals ("#01", "1", 1.0.ToString ("G", nfi));
\r
3125 AssertEquals ("#02", "0", 0.0.ToString ("G", nfi));
\r
3126 AssertEquals ("#03", "+1", (-1.0).ToString ("G", nfi));
\r
3130 public void Test13032 () {
\r
3131 AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("G99", _nfi));
\r
3132 AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("G99", _nfi));
\r
3133 AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("G99", _nfi));
\r
3137 public void Test13033 () {
\r
3138 AssertEquals ("#01", "0.0001", 0.0001.ToString ("G", _nfi));
\r
3139 AssertEquals ("#02", "1E-05", 0.00001.ToString ("G", _nfi));
\r
3140 AssertEquals ("#03", "0.0001", 0.0001.ToString ("G0", _nfi));
\r
3141 AssertEquals ("#04", "1E-05", 0.00001.ToString ("G0", _nfi));
\r
3142 AssertEquals ("#05", "100000000000000", 100000000000000.0.ToString ("G", _nfi));
\r
3143 AssertEquals ("#06", "1E+15", 1000000000000000.0.ToString ("G", _nfi));
\r
3144 AssertEquals ("#07", "1000000000000000", 1000000000000000.0.ToString ("G16", _nfi));
\r
3147 // Test14000- Double and N
\r
3149 public void Test14000 () {
\r
3150 AssertEquals ("#01", "0.00", 0.0.ToString ("N", _nfi));
\r
3151 AssertEquals ("#02", "0.00", 0.0.ToString ("n", _nfi));
\r
3152 AssertEquals ("#03", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MinValue.ToString ("N", _nfi));
\r
3153 AssertEquals ("#04", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MinValue.ToString ("n", _nfi));
\r
3154 AssertEquals ("#05", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MaxValue.ToString ("N", _nfi));
\r
3155 AssertEquals ("#06", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00", Double.MaxValue.ToString ("n", _nfi));
\r
3159 public void Test14001 () {
\r
3160 AssertEquals ("#01", "N ", 0.0.ToString ("N ", _nfi));
\r
3161 AssertEquals ("#02", " N", 0.0.ToString (" N", _nfi));
\r
3162 AssertEquals ("#03", " N ", 0.0.ToString (" N ", _nfi));
\r
3166 public void Test14002 () {
\r
3167 AssertEquals ("#01", "-N ", (-1.0).ToString ("N ", _nfi));
\r
3168 AssertEquals ("#02", "- N", (-1.0).ToString (" N", _nfi));
\r
3169 AssertEquals ("#03", "- N ", (-1.0).ToString (" N ", _nfi));
\r
3173 public void Test14003 () {
\r
3174 AssertEquals ("#01", "0", 0.0.ToString ("N0", _nfi));
\r
3175 AssertEquals ("#02", "0.0000000000000000", 0.0.ToString ("N16", _nfi));
\r
3176 AssertEquals ("#03", "0.00000000000000000", 0.0.ToString ("N17", _nfi));
\r
3177 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 0.0.ToString ("N99", _nfi));
\r
3178 AssertEquals ("#05", "N100", 0.0.ToString ("N100", _nfi));
\r
3182 public void Test14004 () {
\r
3183 AssertEquals ("#01", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000", Double.MaxValue.ToString ("N0", _nfi));
\r
3184 AssertEquals ("#02", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000", Double.MaxValue.ToString ("N16", _nfi));
\r
3185 AssertEquals ("#03", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MaxValue.ToString ("N17", _nfi));
\r
3186 AssertEquals ("#04", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N99", _nfi));
\r
3187 AssertEquals ("#05", "N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N100", _nfi));
\r
3191 public void Test14005 () {
\r
3192 AssertEquals ("#01", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000", Double.MinValue.ToString ("N0", _nfi));
\r
3193 AssertEquals ("#02", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000", Double.MinValue.ToString ("N16", _nfi));
\r
3194 AssertEquals ("#03", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MinValue.ToString ("N17", _nfi));
\r
3195 AssertEquals ("#04", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N99", _nfi));
\r
3196 AssertEquals ("#05", "-N1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N100", _nfi));
\r
3200 public void Test14006 () {
\r
3201 AssertEquals ("#01", "NF", 0.0.ToString ("NF", _nfi));
\r
3202 AssertEquals ("#02", "N0F", 0.0.ToString ("N0F", _nfi));
\r
3203 AssertEquals ("#03", "N0xF", 0.0.ToString ("N0xF", _nfi));
\r
3207 public void Test14007 () {
\r
3208 AssertEquals ("#01", "NF", Double.MaxValue.ToString ("NF", _nfi));
\r
3209 AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("N0F", _nfi));
\r
3210 AssertEquals ("#03", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("N0xF", _nfi));
\r
3214 public void Test14008 () {
\r
3215 AssertEquals ("#01", "-NF", Double.MinValue.ToString ("NF", _nfi));
\r
3216 AssertEquals ("#02", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("N0F", _nfi));
\r
3217 AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("N0xF", _nfi));
\r
3221 public void Test14009 () {
\r
3222 AssertEquals ("#01", "0.00000000000000000", 0.0.ToString ("N0000000000000000000000000000000000000017", _nfi));
\r
3223 AssertEquals ("#02", "179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MaxValue.ToString ("N0000000000000000000000000000000000000017", _nfi));
\r
3224 AssertEquals ("#03", "-179,769,313,486,232,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000", Double.MinValue.ToString ("N0000000000000000000000000000000000000017", _nfi));
\r
3228 public void Test14010 () {
\r
3229 AssertEquals ("#01", "+N", 0.0.ToString ("+N", _nfi));
\r
3230 AssertEquals ("#02", "N+", 0.0.ToString ("N+", _nfi));
\r
3231 AssertEquals ("#03", "+N+", 0.0.ToString ("+N+", _nfi));
\r
3235 public void Test14011 () {
\r
3236 AssertEquals ("#01", "+N", Double.MaxValue.ToString ("+N", _nfi));
\r
3237 AssertEquals ("#02", "N+", Double.MaxValue.ToString ("N+", _nfi));
\r
3238 AssertEquals ("#03", "+N+", Double.MaxValue.ToString ("+N+", _nfi));
\r
3242 public void Test14012 () {
\r
3243 AssertEquals ("#01", "-+N", Double.MinValue.ToString ("+N", _nfi));
\r
3244 AssertEquals ("#02", "-N+", Double.MinValue.ToString ("N+", _nfi));
\r
3245 AssertEquals ("#03", "-+N+", Double.MinValue.ToString ("+N+", _nfi));
\r
3249 public void Test14013 () {
\r
3250 AssertEquals ("#01", "-N", 0.0.ToString ("-N", _nfi));
\r
3251 AssertEquals ("#02", "N-", 0.0.ToString ("N-", _nfi));
\r
3252 AssertEquals ("#03", "-N-", 0.0.ToString ("-N-", _nfi));
\r
3256 public void Test14014 () {
\r
3257 AssertEquals ("#01", "-N", Double.MaxValue.ToString ("-N", _nfi));
\r
3258 AssertEquals ("#02", "N-", Double.MaxValue.ToString ("N-", _nfi));
\r
3259 AssertEquals ("#03", "-N-", Double.MaxValue.ToString ("-N-", _nfi));
\r
3263 public void Test14015 () {
\r
3264 AssertEquals ("#01", "--N", Double.MinValue.ToString ("-N", _nfi));
\r
3265 AssertEquals ("#02", "-N-", Double.MinValue.ToString ("N-", _nfi));
\r
3266 AssertEquals ("#03", "--N-", Double.MinValue.ToString ("-N-", _nfi));
\r
3270 public void Test14016 () {
\r
3271 AssertEquals ("#01", "N+0", 0.0.ToString ("N+0", _nfi));
\r
3272 AssertEquals ("#02", "N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N+0", _nfi));
\r
3273 AssertEquals ("#03", "-N+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N+0", _nfi));
\r
3277 public void Test14017 () {
\r
3278 AssertEquals ("#01", "N+9", 0.0.ToString ("N+9", _nfi));
\r
3279 AssertEquals ("#02", "N+9", Double.MaxValue.ToString ("N+9", _nfi));
\r
3280 AssertEquals ("#03", "-N+9", Double.MinValue.ToString ("N+9", _nfi));
\r
3284 public void Test14018 () {
\r
3285 AssertEquals ("#01", "N-9", 0.0.ToString ("N-9", _nfi));
\r
3286 AssertEquals ("#02", "N-9", Double.MaxValue.ToString ("N-9", _nfi));
\r
3287 AssertEquals ("#03", "-N-9", Double.MinValue.ToString ("N-9", _nfi));
\r
3291 public void Test14019 () {
\r
3292 AssertEquals ("#01", "N0", 0.0.ToString ("N0,", _nfi));
\r
3293 AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0,", _nfi));
\r
3294 AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0,", _nfi));
\r
3298 public void Test14020 () {
\r
3299 AssertEquals ("#01", "N0", 0.0.ToString ("N0.", _nfi));
\r
3300 AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("N0.", _nfi));
\r
3301 AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("N0.", _nfi));
\r
3305 public void Test14021 () {
\r
3306 AssertEquals ("#01", "N0.0", 0.0.ToString ("N0.0", _nfi));
\r
3307 AssertEquals ("#02", "N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("N0.0", _nfi));
\r
3308 AssertEquals ("#03", "-N179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("N0.0", _nfi));
\r
3312 public void Test14022 () {
\r
3313 AssertEquals ("#01", "N09", 0.0.ToString ("N0.9", _nfi));
\r
3314 AssertEquals ("#02", "N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("N0.9", _nfi));
\r
3315 AssertEquals ("#03", "-N1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("N0.9", _nfi));
\r
3319 public void Test14023 () {
\r
3320 AssertEquals ("#01", "999.1", 999.05.ToString ("N1", _nfi));
\r
3321 AssertEquals ("#02", "999.2", 999.15.ToString ("N1", _nfi));
\r
3322 AssertEquals ("#03", "999.3", 999.25.ToString ("N1", _nfi));
\r
3323 AssertEquals ("#04", "999.4", 999.35.ToString ("N1", _nfi));
\r
3324 AssertEquals ("#05", "999.5", 999.45.ToString ("N1", _nfi));
\r
3325 AssertEquals ("#06", "999.6", 999.55.ToString ("N1", _nfi));
\r
3326 AssertEquals ("#07", "999.7", 999.65.ToString ("N1", _nfi));
\r
3327 AssertEquals ("#08", "999.8", 999.75.ToString ("N1", _nfi));
\r
3328 AssertEquals ("#09", "999.9", 999.85.ToString ("N1", _nfi));
\r
3329 AssertEquals ("#10", "1,000.0", 999.95.ToString ("N1", _nfi));
\r
3333 public void Test14024 () {
\r
3334 AssertEquals ("#01", "999.91", 999.905.ToString ("N2", _nfi));
\r
3335 AssertEquals ("#02", "999.92", 999.915.ToString ("N2", _nfi));
\r
3336 AssertEquals ("#03", "999.93", 999.925.ToString ("N2", _nfi));
\r
3337 AssertEquals ("#04", "999.94", 999.935.ToString ("N2", _nfi));
\r
3338 AssertEquals ("#05", "999.95", 999.945.ToString ("N2", _nfi));
\r
3339 AssertEquals ("#06", "999.96", 999.955.ToString ("N2", _nfi));
\r
3340 AssertEquals ("#07", "999.97", 999.965.ToString ("N2", _nfi));
\r
3341 AssertEquals ("#08", "999.98", 999.975.ToString ("N2", _nfi));
\r
3342 AssertEquals ("#09", "999.99", 999.985.ToString ("N2", _nfi));
\r
3343 AssertEquals ("#10", "1,000.00", 999.995.ToString ("N2", _nfi));
\r
3347 public void Test14025 () {
\r
3348 AssertEquals ("#01", "999.99999999991", 999.999999999905.ToString ("N11", _nfi));
\r
3349 AssertEquals ("#02", "999.99999999992", 999.999999999915.ToString ("N11", _nfi));
\r
3350 AssertEquals ("#03", "999.99999999993", 999.999999999925.ToString ("N11", _nfi));
\r
3351 AssertEquals ("#04", "999.99999999994", 999.999999999935.ToString ("N11", _nfi));
\r
3352 AssertEquals ("#05", "999.99999999995", 999.999999999945.ToString ("N11", _nfi));
\r
3353 AssertEquals ("#06", "999.99999999996", 999.999999999955.ToString ("N11", _nfi));
\r
3354 AssertEquals ("#07", "999.99999999997", 999.999999999965.ToString ("N11", _nfi));
\r
3355 AssertEquals ("#08", "999.99999999998", 999.999999999975.ToString ("N11", _nfi));
\r
3356 AssertEquals ("#09", "999.99999999999", 999.999999999985.ToString ("N11", _nfi));
\r
3357 AssertEquals ("#10", "1,000.00000000000", 999.999999999995.ToString ("N11", _nfi));
\r
3361 public void Test14026 () {
\r
3362 AssertEquals ("#01", "999.999999999990", 999.9999999999905.ToString ("N12", _nfi));
\r
3363 AssertEquals ("#02", "999.999999999991", 999.9999999999915.ToString ("N12", _nfi));
\r
3364 AssertEquals ("#03", "999.999999999993", 999.9999999999925.ToString ("N12", _nfi));
\r
3365 AssertEquals ("#04", "999.999999999994", 999.9999999999935.ToString ("N12", _nfi));
\r
3366 AssertEquals ("#05", "999.999999999995", 999.9999999999945.ToString ("N12", _nfi));
\r
3367 AssertEquals ("#06", "999.999999999995", 999.9999999999955.ToString ("N12", _nfi));
\r
3368 AssertEquals ("#07", "999.999999999996", 999.9999999999965.ToString ("N12", _nfi));
\r
3369 AssertEquals ("#08", "999.999999999998", 999.9999999999975.ToString ("N12", _nfi));
\r
3370 AssertEquals ("#09", "999.999999999999", 999.9999999999985.ToString ("N12", _nfi));
\r
3371 AssertEquals ("#10", "1,000.000000000000", 999.9999999999995.ToString ("N12", _nfi));
\r
3375 public void Test14027 () {
\r
3376 AssertEquals ("#01", "999.9999999999990", 999.99999999999905.ToString ("N13", _nfi));
\r
3377 AssertEquals ("#02", "999.9999999999990", 999.99999999999915.ToString ("N13", _nfi));
\r
3378 AssertEquals ("#03", "999.9999999999990", 999.99999999999925.ToString ("N13", _nfi));
\r
3379 AssertEquals ("#04", "999.9999999999990", 999.99999999999935.ToString ("N13", _nfi));
\r
3380 AssertEquals ("#05", "999.9999999999990", 999.99999999999945.ToString ("N13", _nfi));
\r
3381 AssertEquals ("#06", "1,000.0000000000000", 999.99999999999955.ToString ("N13", _nfi));
\r
3382 AssertEquals ("#07", "1,000.0000000000000", 999.99999999999965.ToString ("N13", _nfi));
\r
3383 AssertEquals ("#08", "1,000.0000000000000", 999.99999999999975.ToString ("N13", _nfi));
\r
3384 AssertEquals ("#09", "1,000.0000000000000", 999.99999999999985.ToString ("N13", _nfi));
\r
3385 AssertEquals ("#10", "1,000.0000000000000", 999.99999999999995.ToString ("N13", _nfi));
\r
3389 public void Test14028 () {
\r
3390 AssertEquals ("#01", "1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi));
\r
3391 AssertEquals ("#02", "1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi));
\r
3392 AssertEquals ("#03", "1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi));
\r
3393 AssertEquals ("#04", "1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi));
\r
3394 AssertEquals ("#05", "1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi));
\r
3395 AssertEquals ("#06", "1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi));
\r
3396 AssertEquals ("#07", "N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100", _nfi));
\r
3400 public void Test14029 () {
\r
3401 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
3402 nfi.NumberDecimalSeparator = "#";
\r
3403 AssertEquals ("#01", "-99,999,999#90", (-99999999.9).ToString ("N", nfi));
\r
3407 public void Test14030 () {
\r
3408 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
3409 nfi.NegativeSign = "+";
\r
3410 nfi.PositiveSign = "-";
\r
3412 AssertEquals ("#01", "1,000.00", 1000.0.ToString ("N", nfi));
\r
3413 AssertEquals ("#02", "0.00", 0.0.ToString ("N", nfi));
\r
3414 AssertEquals ("#03", "+1,000.00", (-1000.0).ToString ("N", nfi));
\r
3418 public void Test14031 () {
\r
3419 AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi));
\r
3420 AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi));
\r
3421 AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("N99", _nfi));
\r
3424 // Test15000- Double and P
\r
3426 public void Test15000 () {
\r
3427 AssertEquals ("#01", "0.00 %", 0.0.ToString ("P", _nfi));
\r
3428 AssertEquals ("#02", "0.00 %", 0.0.ToString ("p", _nfi));
\r
3429 AssertEquals ("#03", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MinValue.ToString ("P", _nfi));
\r
3430 AssertEquals ("#04", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MinValue.ToString ("p", _nfi));
\r
3431 AssertEquals ("#05", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MaxValue.ToString ("P", _nfi));
\r
3432 AssertEquals ("#06", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00 %", Double.MaxValue.ToString ("p", _nfi));
\r
3436 public void Test15001 () {
\r
3437 AssertEquals ("#01", "P ", 0.0.ToString ("P ", _nfi));
\r
3438 AssertEquals ("#02", " P", 0.0.ToString (" P", _nfi));
\r
3439 AssertEquals ("#03", " P ", 0.0.ToString (" P ", _nfi));
\r
3443 public void Test15002 () {
\r
3444 AssertEquals ("#01", "-P ", (-1.0).ToString ("P ", _nfi));
\r
3445 AssertEquals ("#02", "- P", (-1.0).ToString (" P", _nfi));
\r
3446 AssertEquals ("#03", "- P ", (-1.0).ToString (" P ", _nfi));
\r
3450 public void Test15003 () {
\r
3451 AssertEquals ("#01", "0 %", 0.0.ToString ("P0", _nfi));
\r
3452 AssertEquals ("#02", "0.0000000000000000 %", 0.0.ToString ("P16", _nfi));
\r
3453 AssertEquals ("#03", "0.00000000000000000 %", 0.0.ToString ("P17", _nfi));
\r
3454 AssertEquals ("#04", "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", 0.0.ToString ("P99", _nfi));
\r
3455 AssertEquals ("#05", "P100", 0.0.ToString ("P100", _nfi));
\r
3459 public void Test15004 () {
\r
3460 AssertEquals ("#01", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 %", Double.MaxValue.ToString ("P0", _nfi));
\r
3461 AssertEquals ("#02", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000 %", Double.MaxValue.ToString ("P16", _nfi));
\r
3462 AssertEquals ("#03", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MaxValue.ToString ("P17", _nfi));
\r
3463 AssertEquals ("#04", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Double.MaxValue.ToString ("P99", _nfi));
\r
3464 AssertEquals ("#05", "P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi));
\r
3468 public void Test15005 () {
\r
3469 AssertEquals ("#01", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 %", Double.MinValue.ToString ("P0", _nfi));
\r
3470 AssertEquals ("#02", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.0000000000000000 %", Double.MinValue.ToString ("P16", _nfi));
\r
3471 AssertEquals ("#03", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MinValue.ToString ("P17", _nfi));
\r
3472 AssertEquals ("#04", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 %", Double.MinValue.ToString ("P99", _nfi));
\r
3473 AssertEquals ("#05", "P1179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P100", _nfi));
\r
3477 public void Test15006 () {
\r
3478 AssertEquals ("#01", "PF", 0.0.ToString ("PF", _nfi));
\r
3479 AssertEquals ("#02", "P0F", 0.0.ToString ("P0F", _nfi));
\r
3480 AssertEquals ("#03", "P0xF", 0.0.ToString ("P0xF", _nfi));
\r
3484 public void Test15007 () {
\r
3485 AssertEquals ("#01", "PF", Double.MaxValue.ToString ("PF", _nfi));
\r
3486 AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MaxValue.ToString ("P0F", _nfi));
\r
3487 AssertEquals ("#03", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MaxValue.ToString ("P0xF", _nfi));
\r
3491 public void Test15008 () {
\r
3492 AssertEquals ("#01", "-PF", Double.MinValue.ToString ("PF", _nfi));
\r
3493 AssertEquals ("#02", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000F", Double.MinValue.ToString ("P0F", _nfi));
\r
3494 AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000xF", Double.MinValue.ToString ("P0xF", _nfi));
\r
3498 public void Test15009 () {
\r
3499 AssertEquals ("#01", "0.00000000000000000 %", 0.0.ToString ("P0000000000000000000000000000000000000017", _nfi));
\r
3500 AssertEquals ("#02", "17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MaxValue.ToString ("P0000000000000000000000000000000000000017", _nfi));
\r
3501 AssertEquals ("#03", "-17,976,931,348,623,200,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000000000000000 %", Double.MinValue.ToString ("P0000000000000000000000000000000000000017", _nfi));
\r
3505 public void Test15010 () {
\r
3506 AssertEquals ("#01", "+P", 0.0.ToString ("+P", _nfi));
\r
3507 AssertEquals ("#02", "P+", 0.0.ToString ("P+", _nfi));
\r
3508 AssertEquals ("#03", "+P+", 0.0.ToString ("+P+", _nfi));
\r
3512 public void Test15011 () {
\r
3513 AssertEquals ("#01", "+P", Double.MaxValue.ToString ("+P", _nfi));
\r
3514 AssertEquals ("#02", "P+", Double.MaxValue.ToString ("P+", _nfi));
\r
3515 AssertEquals ("#03", "+P+", Double.MaxValue.ToString ("+P+", _nfi));
\r
3519 public void Test15012 () {
\r
3520 AssertEquals ("#01", "-+P", Double.MinValue.ToString ("+P", _nfi));
\r
3521 AssertEquals ("#02", "-P+", Double.MinValue.ToString ("P+", _nfi));
\r
3522 AssertEquals ("#03", "-+P+", Double.MinValue.ToString ("+P+", _nfi));
\r
3526 public void Test15013 () {
\r
3527 AssertEquals ("#01", "-P", 0.0.ToString ("-P", _nfi));
\r
3528 AssertEquals ("#02", "P-", 0.0.ToString ("P-", _nfi));
\r
3529 AssertEquals ("#03", "-P-", 0.0.ToString ("-P-", _nfi));
\r
3533 public void Test15014 () {
\r
3534 AssertEquals ("#01", "-P", Double.MaxValue.ToString ("-P", _nfi));
\r
3535 AssertEquals ("#02", "P-", Double.MaxValue.ToString ("P-", _nfi));
\r
3536 AssertEquals ("#03", "-P-", Double.MaxValue.ToString ("-P-", _nfi));
\r
3540 public void Test15015 () {
\r
3541 AssertEquals ("#01", "--P", Double.MinValue.ToString ("-P", _nfi));
\r
3542 AssertEquals ("#02", "-P-", Double.MinValue.ToString ("P-", _nfi));
\r
3543 AssertEquals ("#03", "--P-", Double.MinValue.ToString ("-P-", _nfi));
\r
3547 public void Test15016 () {
\r
3548 AssertEquals ("#01", "P+0", 0.0.ToString ("P+0", _nfi));
\r
3549 AssertEquals ("#02", "P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P+0", _nfi));
\r
3550 AssertEquals ("#03", "-P+179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P+0", _nfi));
\r
3554 public void Test15017 () {
\r
3555 AssertEquals ("#01", "P+9", 0.0.ToString ("P+9", _nfi));
\r
3556 AssertEquals ("#02", "P+9", Double.MaxValue.ToString ("P+9", _nfi));
\r
3557 AssertEquals ("#03", "-P+9", Double.MinValue.ToString ("P+9", _nfi));
\r
3561 public void Test15018 () {
\r
3562 AssertEquals ("#01", "P-9", 0.0.ToString ("P-9", _nfi));
\r
3563 AssertEquals ("#02", "P-9", Double.MaxValue.ToString ("P-9", _nfi));
\r
3564 AssertEquals ("#03", "-P-9", Double.MinValue.ToString ("P-9", _nfi));
\r
3568 public void Test15019 () {
\r
3569 AssertEquals ("#01", "P0", 0.0.ToString ("P0,", _nfi));
\r
3570 AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0,", _nfi));
\r
3571 AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0,", _nfi));
\r
3575 public void Test15020 () {
\r
3576 AssertEquals ("#01", "P0", 0.0.ToString ("P0.", _nfi));
\r
3577 AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MaxValue.ToString ("P0.", _nfi));
\r
3578 AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", Double.MinValue.ToString ("P0.", _nfi));
\r
3582 public void Test15021 () {
\r
3583 AssertEquals ("#01", "P0.0", 0.0.ToString ("P0.0", _nfi));
\r
3584 AssertEquals ("#02", "P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MaxValue.ToString ("P0.0", _nfi));
\r
3585 AssertEquals ("#03", "-P179769313486232000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0", Double.MinValue.ToString ("P0.0", _nfi));
\r
3589 public void Test15022 () {
\r
3590 AssertEquals ("#01", "P09", 0.0.ToString ("P0.9", _nfi));
\r
3591 AssertEquals ("#02", "P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MaxValue.ToString ("P0.9", _nfi));
\r
3592 AssertEquals ("#03", "-P1797693134862320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009", Double.MinValue.ToString ("P0.9", _nfi));
\r
3596 public void Test15023 () {
\r
3597 AssertEquals ("#01", "999.1 %", 9.9905.ToString ("P1", _nfi));
\r
3598 AssertEquals ("#02", "999.2 %", 9.9915.ToString ("P1", _nfi));
\r
3599 AssertEquals ("#03", "999.3 %", 9.9925.ToString ("P1", _nfi));
\r
3600 AssertEquals ("#04", "999.4 %", 9.9935.ToString ("P1", _nfi));
\r
3601 AssertEquals ("#05", "999.5 %", 9.9945.ToString ("P1", _nfi));
\r
3602 AssertEquals ("#06", "999.6 %", 9.9955.ToString ("P1", _nfi));
\r
3603 AssertEquals ("#07", "999.7 %", 9.9965.ToString ("P1", _nfi));
\r
3604 AssertEquals ("#08", "999.8 %", 9.9975.ToString ("P1", _nfi));
\r
3605 AssertEquals ("#09", "999.9 %", 9.9985.ToString ("P1", _nfi));
\r
3606 AssertEquals ("#10", "1,000.0 %", 9.9995.ToString ("P1", _nfi));
\r
3610 public void Test15024 () {
\r
3611 AssertEquals ("#01", "999.91 %", 9.99905.ToString ("P2", _nfi));
\r
3612 AssertEquals ("#02", "999.92 %", 9.99915.ToString ("P2", _nfi));
\r
3613 AssertEquals ("#03", "999.93 %", 9.99925.ToString ("P2", _nfi));
\r
3614 AssertEquals ("#04", "999.94 %", 9.99935.ToString ("P2", _nfi));
\r
3615 AssertEquals ("#05", "999.95 %", 9.99945.ToString ("P2", _nfi));
\r
3616 AssertEquals ("#06", "999.96 %", 9.99955.ToString ("P2", _nfi));
\r
3617 AssertEquals ("#07", "999.97 %", 9.99965.ToString ("P2", _nfi));
\r
3618 AssertEquals ("#08", "999.98 %", 9.99975.ToString ("P2", _nfi));
\r
3619 AssertEquals ("#09", "999.99 %", 9.99985.ToString ("P2", _nfi));
\r
3620 AssertEquals ("#10", "1,000.00 %", 9.99995.ToString ("P2", _nfi));
\r
3624 public void Test15025 () {
\r
3625 AssertEquals ("#01", "999.99999999991 %", 9.99999999999905.ToString ("P11", _nfi));
\r
3626 AssertEquals ("#02", "999.99999999992 %", 9.99999999999915.ToString ("P11", _nfi));
\r
3627 AssertEquals ("#03", "999.99999999993 %", 9.99999999999925.ToString ("P11", _nfi));
\r
3628 AssertEquals ("#04", "999.99999999994 %", 9.99999999999935.ToString ("P11", _nfi));
\r
3629 AssertEquals ("#05", "999.99999999995 %", 9.99999999999945.ToString ("P11", _nfi));
\r
3630 AssertEquals ("#06", "999.99999999996 %", 9.99999999999955.ToString ("P11", _nfi));
\r
3631 AssertEquals ("#07", "999.99999999997 %", 9.99999999999965.ToString ("P11", _nfi));
\r
3632 AssertEquals ("#08", "999.99999999998 %", 9.99999999999975.ToString ("P11", _nfi));
\r
3633 AssertEquals ("#09", "999.99999999999 %", 9.99999999999985.ToString ("P11", _nfi));
\r
3634 AssertEquals ("#10", "1,000.00000000000 %", 9.99999999999995.ToString ("P11", _nfi));
\r
3638 public void Test15026 () {
\r
3639 AssertEquals ("#01", "999.999999999991 %", 9.999999999999905.ToString ("P12", _nfi));
\r
3640 AssertEquals ("#02", "999.999999999991 %", 9.999999999999915.ToString ("P12", _nfi));
\r
3641 AssertEquals ("#03", "999.999999999993 %", 9.999999999999925.ToString ("P12", _nfi));
\r
3642 AssertEquals ("#04", "999.999999999993 %", 9.999999999999935.ToString ("P12", _nfi));
\r
3643 AssertEquals ("#05", "999.999999999994 %", 9.999999999999945.ToString ("P12", _nfi));
\r
3644 AssertEquals ("#06", "999.999999999996 %", 9.999999999999955.ToString ("P12", _nfi));
\r
3645 AssertEquals ("#07", "999.999999999996 %", 9.999999999999965.ToString ("P12", _nfi));
\r
3646 AssertEquals ("#08", "999.999999999998 %", 9.999999999999975.ToString ("P12", _nfi));
\r
3647 AssertEquals ("#09", "999.999999999999 %", 9.999999999999985.ToString ("P12", _nfi));
\r
3648 AssertEquals ("#10", "999.999999999999 %", 9.999999999999995.ToString ("P12", _nfi));
\r
3652 public void Test15027 () {
\r
3653 AssertEquals ("#01", "999.9999999999990 %", 9.9999999999999905.ToString ("P13", _nfi));
\r
3654 AssertEquals ("#02", "999.9999999999990 %", 9.9999999999999915.ToString ("P13", _nfi));
\r
3655 AssertEquals ("#03", "999.9999999999990 %", 9.9999999999999925.ToString ("P13", _nfi));
\r
3656 AssertEquals ("#04", "999.9999999999990 %", 9.9999999999999935.ToString ("P13", _nfi));
\r
3657 AssertEquals ("#05", "999.9999999999990 %", 9.9999999999999945.ToString ("P13", _nfi));
\r
3658 AssertEquals ("#06", "999.9999999999990 %", 9.9999999999999955.ToString ("P13", _nfi));
\r
3659 AssertEquals ("#07", "1,000.0000000000000 %", 9.9999999999999965.ToString ("P13", _nfi));
\r
3660 AssertEquals ("#08", "1,000.0000000000000 %", 9.9999999999999975.ToString ("P13", _nfi));
\r
3661 AssertEquals ("#09", "1,000.0000000000000 %", 9.9999999999999985.ToString ("P13", _nfi));
\r
3662 AssertEquals ("#10", "1,000.0000000000000 %", 9.9999999999999995.ToString ("P13", _nfi));
\r
3666 public void Test15028 () {
\r
3667 AssertEquals ("#01", "1", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N0", _nfi));
\r
3668 AssertEquals ("#02", "1.234567890123", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N12", _nfi));
\r
3669 AssertEquals ("#03", "1.2345678901235", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N13", _nfi));
\r
3670 AssertEquals ("#04", "1.23456789012346", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N14", _nfi));
\r
3671 AssertEquals ("#05", "1.234567890123460", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N15", _nfi));
\r
3672 AssertEquals ("#06", "1.234567890123460000000000000000000000000000000000000000000000000000000000000000000000000000000000000", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N99", _nfi));
\r
3673 AssertEquals ("#07", "N101", 1.234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789.ToString ("N100"));
\r
3677 public void Test15029 () {
\r
3678 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
3679 nfi.PercentDecimalSeparator = "#";
\r
3680 AssertEquals ("#01", "-9,999,999,990#00 %", (-99999999.9).ToString ("P", nfi));
\r
3684 public void Test15030 () {
\r
3685 NumberFormatInfo nfi = _nfi.Clone() as NumberFormatInfo;
\r
3686 nfi.NegativeSign = "+";
\r
3687 nfi.PositiveSign = "-";
\r
3689 AssertEquals ("#01", "1,000.00 %", 10.0.ToString ("P", nfi));
\r
3690 AssertEquals ("#02", "0.00 %", 0.0.ToString ("P", nfi));
\r
3691 AssertEquals ("#03", "+1,000.00 %", (-10.0).ToString ("P", nfi));
\r
3695 public void Test15031 () {
\r
3696 AssertEquals ("#01", "Infinity", (Double.MaxValue / 0.0).ToString ("N99", _nfi));
\r
3697 AssertEquals ("#02", "-Infinity", (Double.MinValue / 0.0).ToString ("N99", _nfi));
\r
3698 AssertEquals ("#03", "NaN", (0.0 / 0.0).ToString ("N99", _nfi));
\r
3701 // Test16000 - Double and R
\r
3703 public void Test16000 () {
\r
3704 AssertEquals ("#01", "1.2345678901234567", 1.2345678901234567890.ToString ("R", _nfi));
\r
3705 AssertEquals ("#02", "1.2345678901234567", 1.2345678901234567890.ToString ("r", _nfi));
\r
3706 AssertEquals ("#03", "1.2345678901234567", 1.2345678901234567890.ToString ("R0", _nfi));
\r
3707 AssertEquals ("#04", "1.2345678901234567", 1.2345678901234567890.ToString ("r0", _nfi));
\r
3708 AssertEquals ("#05", "1.2345678901234567", 1.2345678901234567890.ToString ("R99", _nfi));
\r
3709 AssertEquals ("#06", "1.2345678901234567", 1.2345678901234567890.ToString ("r99", _nfi));
\r
3712 // Test17000 - Double and X
\r
3714 [ExpectedException (typeof (FormatException))]
\r
3715 public void Test17000 () {
\r
3716 AssertEquals ("#01", "", 0.0.ToString ("X99", _nfi));
\r
projects / mono.git / blob