1 /*
2 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /* Type-specific source code for unit test
25 *
26 * Regenerate the BasicX classes via genBasic.sh whenever this file changes.
27 * We check in the generated source files so that the test tree can be used
28 * independently of the rest of the source tree.
29 */
30
31 // -- This file was mechanically generated: Do not edit! -- //
32
33 import java.io.*;
34 import java.math.BigDecimal;
35 import java.math.BigInteger;
36 import java.text.DateFormatSymbols;
37 import java.util.*;
38
39 import sun.misc.DoubleConsts;
40
41 import static java.util.Calendar.*;
42
43 public class BasicDouble extends Basic {
44
45 private static void test(String fs, String exp, Object ... args) {
46 Formatter f = new Formatter(new StringBuilder(), Locale.US);
47 f.format(fs, args);
48 ck(fs, exp, f.toString());
49
50 f = new Formatter(new StringBuilder(), Locale.US);
51 f.format("foo " + fs + " bar", args);
52 ck(fs, "foo " + exp + " bar", f.toString());
53 }
54
55 private static void test(Locale l, String fs, String exp, Object ... args)
56 {
57 Formatter f = new Formatter(new StringBuilder(), l);
58 f.format(fs, args);
59 ck(fs, exp, f.toString());
60
61 f = new Formatter(new StringBuilder(), l);
62 f.format("foo " + fs + " bar", args);
63 ck(fs, "foo " + exp + " bar", f.toString());
64 }
65
66 private static void test(String fs, Object ... args) {
67 Formatter f = new Formatter(new StringBuilder(), Locale.US);
68 f.format(fs, args);
69 ck(fs, "fail", f.toString());
70 }
71
72 private static void test(String fs) {
73 Formatter f = new Formatter(new StringBuilder(), Locale.US);
74 f.format(fs, "fail");
75 ck(fs, "fail", f.toString());
76 }
77
78 private static void testSysOut(String fs, String exp, Object ... args) {
79 FileOutputStream fos = null;
80 FileInputStream fis = null;
81 try {
82 PrintStream saveOut = System.out;
83 fos = new FileOutputStream("testSysOut");
84 System.setOut(new PrintStream(fos));
85 System.out.format(Locale.US, fs, args);
86 fos.close();
87
88 fis = new FileInputStream("testSysOut");
89 byte [] ba = new byte[exp.length()];
90 int len = fis.read(ba);
91 String got = new String(ba);
92 if (len != ba.length)
93 fail(fs, exp, got);
94 ck(fs, exp, got);
95
96 System.setOut(saveOut);
97 } catch (FileNotFoundException ex) {
98 fail(fs, ex.getClass());
99 } catch (IOException ex) {
100 fail(fs, ex.getClass());
101 } finally {
102 try {
103 if (fos != null)
104 fos.close();
105 if (fis != null)
106 fis.close();
107 } catch (IOException ex) {
108 fail(fs, ex.getClass());
109 }
110 }
111 }
112
113 private static void tryCatch(String fs, Class<?> ex) {
114 boolean caught = false;
115 try {
116 test(fs);
117 } catch (Throwable x) {
118 if (ex.isAssignableFrom(x.getClass()))
119 caught = true;
120 }
121 if (!caught)
122 fail(fs, ex);
123 else
124 pass();
125 }
126
127 private static void tryCatch(String fs, Class<?> ex, Object ... args) {
128 boolean caught = false;
129 try {
130 test(fs, args);
131 } catch (Throwable x) {
132 if (ex.isAssignableFrom(x.getClass()))
133 caught = true;
134 }
135 if (!caught)
136 fail(fs, ex);
137 else
138 pass();
139 }
140
141 private static double create(double v) {
142 return (double) v;
143 }
144
145 private static double negate(double v) {
146 return -v;
147 }
148
149 private static double mult(double v, double mul) {
150 return v * mul;
151 }
152
153 private static double recip(double v) {
154 return 1.0 / v;
155 }
156
157 public static void test() {
158 TimeZone.setDefault(TimeZone.getTimeZone("GMT-0800"));
159
160 // Any characters not explicitly defined as conversions, date/time
161 // conversion suffixes, or flags are illegal and are reserved for
162 // future extensions. Use of such a character in a format string will
163 // cause an UnknownFormatConversionException or
164 // UnknownFormatFlagsException to be thrown.
165 tryCatch("%q", UnknownFormatConversionException.class);
166 tryCatch("%t&", UnknownFormatConversionException.class);
167 tryCatch("%&d", UnknownFormatConversionException.class);
168 tryCatch("%^b", UnknownFormatConversionException.class);
169
170 //---------------------------------------------------------------------
171 // Formatter.java class javadoc examples
172 //---------------------------------------------------------------------
173 test(Locale.FRANCE, "e = %+10.4f", "e = +2,7183", Math.E);
174 test("%4$2s %3$2s %2$2s %1$2s", " d c b a", "a", "b", "c", "d");
175 test("Amount gained or lost since last statement: $ %,(.2f",
176 "Amount gained or lost since last statement: $ (6,217.58)",
177 (new BigDecimal("-6217.58")));
178 Calendar c = new GregorianCalendar(1969, JULY, 20, 16, 17, 0);
179 testSysOut("Local time: %tT", "Local time: 16:17:00", c);
180
181 test("Unable to open file '%1$s': %2$s",
182 "Unable to open file 'food': No such file or directory",
183 "food", "No such file or directory");
184 Calendar duke = new GregorianCalendar(1995, MAY, 23, 19, 48, 34);
185 duke.set(Calendar.MILLISECOND, 584);
186 test("Duke's Birthday: %1$tB %1$te, %1$tY",
187 "Duke's Birthday: May 23, 1995",
188 duke);
189 test("Duke's Birthday: %1$tB %1$te, %1$tY",
190 "Duke's Birthday: May 23, 1995",
191 duke.getTime());
192 test("Duke's Birthday: %1$tB %1$te, %1$tY",
193 "Duke's Birthday: May 23, 1995",
194 duke.getTimeInMillis());
195
196 test("%4$s %3$s %2$s %1$s %4$s %3$s %2$s %1$s",
197 "d c b a d c b a", "a", "b", "c", "d");
198 test("%s %s %<s %<s", "a b b b", "a", "b", "c", "d");
199 test("%s %s %s %s", "a b c d", "a", "b", "c", "d");
200 test("%2$s %s %<s %s", "b a a b", "a", "b", "c", "d");
201
202 //---------------------------------------------------------------------
203 // %b
204 //
205 // General conversion applicable to any argument.
206 //---------------------------------------------------------------------
207 test("%b", "true", true);
208 test("%b", "false", false);
209 test("%B", "TRUE", true);
210 test("%B", "FALSE", false);
211 test("%b", "true", Boolean.TRUE);
212 test("%b", "false", Boolean.FALSE);
213 test("%B", "TRUE", Boolean.TRUE);
214 test("%B", "FALSE", Boolean.FALSE);
215 test("%14b", " true", true);
216 test("%-14b", "true ", true);
217 test("%5.1b", " f", false);
218 test("%-5.1b", "f ", false);
219
220 test("%b", "true", "foo");
221 test("%b", "false", (Object)null);
222
223 // Boolean.java hardcodes the Strings for "true" and "false", so no
224 // localization is possible.
225 test(Locale.FRANCE, "%b", "true", true);
226 test(Locale.FRANCE, "%b", "false", false);
227
228 // If you pass in a single array to a varargs method, the compiler
229 // uses it as the array of arguments rather than treating it as a
230 // single array-type argument.
231 test("%b", "false", (Object[])new String[2]);
232 test("%b", "true", new String[2], new String[2]);
233
234 int [] ia = { 1, 2, 3 };
235 test("%b", "true", ia);
236
237 //---------------------------------------------------------------------
238 // %b - errors
239 //---------------------------------------------------------------------
240 tryCatch("%#b", FormatFlagsConversionMismatchException.class);
241 tryCatch("%-b", MissingFormatWidthException.class);
242 // correct or side-effect of implementation?
243 tryCatch("%.b", UnknownFormatConversionException.class);
244 tryCatch("%,b", FormatFlagsConversionMismatchException.class);
245
246 //---------------------------------------------------------------------
247 // %c
248 //
249 // General conversion applicable to any argument.
250 //---------------------------------------------------------------------
251 test("%c", "i", 'i');
252 test("%C", "I", 'i');
253 test("%4c", " i", 'i');
254 test("%-4c", "i ", 'i');
255 test("%4C", " I", 'i');
256 test("%-4C", "I ", 'i');
257 test("%c", "i", new Character('i'));
258 test("%c", "H", (byte) 72);
259 test("%c", "i", (short) 105);
260 test("%c", "!", (int) 33);
261 test("%c", "\u007F", Byte.MAX_VALUE);
262 test("%c", new String(Character.toChars(Short.MAX_VALUE)),
263 Short.MAX_VALUE);
264 test("%c", "null", (Object) null);
265
266 //---------------------------------------------------------------------
267 // %c - errors
268 //---------------------------------------------------------------------
269 tryCatch("%c", IllegalFormatConversionException.class,
270 Boolean.TRUE);
271 tryCatch("%c", IllegalFormatConversionException.class,
272 (float) 0.1);
273 tryCatch("%c", IllegalFormatConversionException.class,
274 new Object());
275 tryCatch("%c", IllegalFormatCodePointException.class,
276 Byte.MIN_VALUE);
277 tryCatch("%c", IllegalFormatCodePointException.class,
278 Short.MIN_VALUE);
279 tryCatch("%c", IllegalFormatCodePointException.class,
280 Integer.MIN_VALUE);
281 tryCatch("%c", IllegalFormatCodePointException.class,
282 Integer.MAX_VALUE);
283
284 tryCatch("%#c", FormatFlagsConversionMismatchException.class);
285 tryCatch("%,c", FormatFlagsConversionMismatchException.class);
286 tryCatch("%(c", FormatFlagsConversionMismatchException.class);
287 tryCatch("%$c", UnknownFormatConversionException.class);
288 tryCatch("%.2c", IllegalFormatPrecisionException.class);
289
290 //---------------------------------------------------------------------
291 // %s
292 //
293 // General conversion applicable to any argument.
294 //---------------------------------------------------------------------
295 test("%s", "Hello, Duke", "Hello, Duke");
296 test("%S", "HELLO, DUKE", "Hello, Duke");
297 test("%20S", " HELLO, DUKE", "Hello, Duke");
298 test("%20s", " Hello, Duke", "Hello, Duke");
299 test("%-20s", "Hello, Duke ", "Hello, Duke");
300 test("%-20.5s", "Hello ", "Hello, Duke");
301 test("%s", "null", (Object)null);
302
303 StringBuffer sb = new StringBuffer("foo bar");
304 test("%s", sb.toString(), sb);
305 test("%S", sb.toString().toUpperCase(), sb);
306
307 //---------------------------------------------------------------------
308 // %s - errors
309 //---------------------------------------------------------------------
310 tryCatch("%-s", MissingFormatWidthException.class);
311 tryCatch("%--s", DuplicateFormatFlagsException.class);
312 tryCatch("%#s", FormatFlagsConversionMismatchException.class, 0);
313 tryCatch("%#s", FormatFlagsConversionMismatchException.class, 0.5f);
314 tryCatch("%#s", FormatFlagsConversionMismatchException.class, "hello");
315 tryCatch("%#s", FormatFlagsConversionMismatchException.class, null);
316
317 //---------------------------------------------------------------------
318 // %h
319 //
320 // General conversion applicable to any argument.
321 //---------------------------------------------------------------------
322 test("%h", Integer.toHexString("Hello, Duke".hashCode()),
323 "Hello, Duke");
324 test("%10h", " ddf63471", "Hello, Duke");
325 test("%-10h", "ddf63471 ", "Hello, Duke");
326 test("%-10H", "DDF63471 ", "Hello, Duke");
327 test("%10h", " 402e0000", 15.0);
328 test("%10H", " 402E0000", 15.0);
329
330 //---------------------------------------------------------------------
331 // %h - errors
332 //---------------------------------------------------------------------
333 tryCatch("%#h", FormatFlagsConversionMismatchException.class);
334
335 //---------------------------------------------------------------------
336 // flag/conversion errors
337 //---------------------------------------------------------------------
338 tryCatch("%F", UnknownFormatConversionException.class);
339
340 tryCatch("%#g", FormatFlagsConversionMismatchException.class);
341
342 //---------------------------------------------------------------------
343 // %s - double
344 //---------------------------------------------------------------------
345 double one = 1.0;
346 double ten = 10.0;
347 double pi = Math.PI;
348
349 test("%s", "3.141592653589793", pi);
350
351 //---------------------------------------------------------------------
352 // flag/conversion errors
353 //---------------------------------------------------------------------
354 tryCatch("%d", IllegalFormatConversionException.class, one);
355 tryCatch("%,.4e", FormatFlagsConversionMismatchException.class, one);
356
357 //---------------------------------------------------------------------
358 // %e
359 //
360 // Floating-point conversions applicable to float, double, and
361 // BigDecimal.
362 //---------------------------------------------------------------------
363 test("%e", "null", (Object)null);
364
365 //---------------------------------------------------------------------
366 // %e - float and double
367 //---------------------------------------------------------------------
368 // double PI = 3.141 592 653 589 793 238 46;
369 test("%e", "3.141593e+00", pi);
370 test("%.0e", "1e+01", ten);
371 test("%#.0e", "1.e+01", ten);
372 test("%E", "3.141593E+00", pi);
373 test("%10.3e", " 3.142e+00", pi);
374 test("%10.3e", "-3.142e+00", negate(pi));
375 test("%010.3e", "03.142e+00", pi);
376 test("%010.3e", "-3.142e+00", negate(pi));
377 test("%-12.3e", "3.142e+00 ", pi);
378 test("%-12.3e", "-3.142e+00 ", negate(pi));
379 test("%.3e", "3.142e+00", pi);
380 test("%.3e", "-3.142e+00", negate(pi));
381 test("%.3e", "3.142e+06", mult(pi, 1000000.0));
382 test("%.3e", "-3.142e+06", mult(pi, -1000000.0));
383
384 test(Locale.FRANCE, "%e", "3,141593e+00", pi);
385
386 // double PI^300
387 // = 13962455701329742638131355433930076081862072808 ... e+149
388
389 test("%10.3e", " 1.000e+00", one);
390 test("%+.3e", "+3.142e+00", pi);
391 test("%+.3e", "-3.142e+00", negate(pi));
392 test("% .3e", " 3.142e+00", pi);
393 test("% .3e", "-3.142e+00", negate(pi));
394 test("%#.0e", "3.e+00", create(3.0));
395 test("%#.0e", "-3.e+00", create(-3.0));
396 test("%.0e", "3e+00", create(3.0));
397 test("%.0e", "-3e+00", create(-3.0));
398
399 test("%(.4e", "3.1416e+06", mult(pi, 1000000.0));
400 test("%(.4e", "(3.1416e+06)", mult(pi, -1000000.0));
401
402 //---------------------------------------------------------------------
403 // %e - boundary problems
404 //---------------------------------------------------------------------
405 test("%3.0e", "1e-06", 0.000001);
406 test("%3.0e", "1e-05", 0.00001);
407 test("%3.0e", "1e-04", 0.0001);
408 test("%3.0e", "1e-03", 0.001);
409 test("%3.0e", "1e-02", 0.01);
410 test("%3.0e", "1e-01", 0.1);
411 test("%3.0e", "9e-01", 0.9);
412 test("%3.1e", "9.0e-01", 0.9);
413 test("%3.0e", "1e+00", 1.00);
414 test("%3.0e", "1e+01", 10.00);
415 test("%3.0e", "1e+02", 99.19);
416 test("%3.1e", "9.9e+01", 99.19);
417 test("%3.0e", "1e+02", 99.99);
418 test("%3.0e", "1e+02", 100.00);
419 test("%#3.0e", "1.e+03", 1000.00);
420 test("%3.0e", "1e+04", 10000.00);
421 test("%3.0e", "1e+05", 100000.00);
422 test("%3.0e", "1e+06", 1000000.00);
423 test("%3.0e", "1e+07", 10000000.00);
424 test("%3.0e", "1e+08", 100000000.00);
425
426 //---------------------------------------------------------------------
427 // %f
428 //
429 // Floating-point conversions applicable to float, double, and
430 // BigDecimal.
431 //---------------------------------------------------------------------
432 test("%f", "null", (Object)null);
433 test("%f", "3.141593", pi);
434 test(Locale.FRANCE, "%f", "3,141593", pi);
435 test("%10.3f", " 3.142", pi);
436 test("%10.3f", " -3.142", negate(pi));
437 test("%010.3f", "000003.142", pi);
438 test("%010.3f", "-00003.142", negate(pi));
439 test("%-10.3f", "3.142 ", pi);
440 test("%-10.3f", "-3.142 ", negate(pi));
441 test("%.3f", "3.142", pi);
442 test("%.3f", "-3.142", negate(pi));
443 test("%+.3f", "+3.142", pi);
444 test("%+.3f", "-3.142", negate(pi));
445 test("% .3f", " 3.142", pi);
446 test("% .3f", "-3.142", negate(pi));
447 test("%#.0f", "3.", create(3.0));
448 test("%#.0f", "-3.", create(-3.0));
449 test("%.0f", "3", create(3.0));
450 test("%.0f", "-3", create(-3.0));
451 test("%.3f", "10.000", ten);
452 test("%.3f", "1.000", one);
453 test("%10.3f", " 1.000", one);
454
455 //---------------------------------------------------------------------
456 // %f - boundary problems
457 //---------------------------------------------------------------------
458 test("%3.0f", " 0", 0.000001);
459 test("%3.0f", " 0", 0.00001);
460 test("%3.0f", " 0", 0.0001);
461 test("%3.0f", " 0", 0.001);
462 test("%3.0f", " 0", 0.01);
463 test("%3.0f", " 0", 0.1);
464 test("%3.0f", " 1", 0.9);
465 test("%3.1f", "0.9", 0.9);
466 test("%3.0f", " 1", 1.00);
467 test("%3.0f", " 10", 10.00);
468 test("%3.0f", " 99", 99.19);
469 test("%3.1f", "99.2", 99.19);
470 test("%3.0f", "100", 99.99);
471 test("%3.0f", "100", 100.00);
472 test("%#3.0f", "1000.", 1000.00);
473 test("%3.0f", "10000", 10000.00);
474 test("%3.0f", "100000", 100000.00);
475 test("%3.0f", "1000000", 1000000.00);
476 test("%3.0f", "10000000", 10000000.00);
477 test("%3.0f", "100000000", 100000000.00);
478 test("%10.0f", " 1000000", 1000000.00);
479 test("%,10.0f", " 1,000,000", 1000000.00);
480 test("%,10.1f", "1,000,000.0", 1000000.00);
481 test("%,3.0f", "1,000,000", 1000000.00);
482 test("%,3.0f", "10,000,000", 10000000.00);
483 test("%,3.0f", "100,000,000", 100000000.00);
484 test("%,3.0f", "10,000,000", 10000000.00);
485 test("%,3.0f", "100,000,000", 100000000.00);
486
487 //---------------------------------------------------------------------
488 // %f - float, double, Double, BigDecimal
489 //---------------------------------------------------------------------
490 test("%.3f", "3141592.654", mult(pi, 1000000.0));
491 test("%.3f", "-3141592.654", mult(pi, -1000000.0));
492 test("%,.4f", "3,141,592.6536", mult(pi, 1000000.0));
493 test(Locale.FRANCE, "%,.4f", "3\u00a0141\u00a0592,6536", mult(pi, 1000000.0));
494 test("%,.4f", "-3,141,592.6536", mult(pi, -1000000.0));
495 test("%(.4f", "3141592.6536", mult(pi, 1000000.0));
496 test("%(.4f", "(3141592.6536)", mult(pi, -1000000.0));
497 test("%(,.4f", "3,141,592.6536", mult(pi, 1000000.0));
498 test("%(,.4f", "(3,141,592.6536)", mult(pi, -1000000.0));
499
500 //---------------------------------------------------------------------
501 // %g
502 //
503 // Floating-point conversions applicable to float, double, and
504 // BigDecimal.
505 //---------------------------------------------------------------------
506 test("%g", "null", (Object)null);
507 test("%g", "3.14159", pi);
508 test(Locale.FRANCE, "%g", "3,14159", pi);
509 test("%.0g", "1e+01", ten);
510 test("%G", "3.14159", pi);
511 test("%10.3g", " 3.14", pi);
512 test("%10.3g", " -3.14", negate(pi));
513 test("%010.3g", "0000003.14", pi);
514 test("%010.3g", "-000003.14", negate(pi));
515 test("%-12.3g", "3.14 ", pi);
516 test("%-12.3g", "-3.14 ", negate(pi));
517 test("%.3g", "3.14", pi);
518 test("%.3g", "-3.14", negate(pi));
519 test("%.3g", "3.14e+08", mult(pi, 100000000.0));
520 test("%.3g", "-3.14e+08", mult(pi, -100000000.0));
521
522 test("%.3g", "1.00e-05", recip(create(100000.0)));
523 test("%.3g", "-1.00e-05", recip(create(-100000.0)));
524 test("%.0g", "-1e-05", recip(create(-100000.0)));
525 test("%.0g", "1e+05", create(100000.0));
526 test("%.3G", "1.00E-05", recip(create(100000.0)));
527 test("%.3G", "-1.00E-05", recip(create(-100000.0)));
528
529 test("%.1g", "-0", -0.0);
530 test("%3.0g", " -0", -0.0);
531 test("%.1g", "0", 0.0);
532 test("%3.0g", " 0", 0.0);
533 test("%.1g", "0", +0.0);
534 test("%3.0g", " 0", +0.0);
535
536 test("%3.0g", "1e-06", 0.000001);
537 test("%3.0g", "1e-05", 0.00001);
538 test("%3.0g", "1e-05", 0.0000099);
539 test("%3.1g", "1e-05", 0.0000099);
540 test("%3.2g", "9.9e-06", 0.0000099);
541 test("%3.0g", "0.0001", 0.0001);
542 test("%3.0g", "9e-05", 0.00009);
543 test("%3.0g", "0.0001", 0.000099);
544 test("%3.1g", "0.0001", 0.000099);
545 test("%3.2g", "9.9e-05", 0.000099);
546 test("%3.0g", "0.001", 0.001);
547 test("%3.0g", "0.001", 0.00099);
548 test("%3.1g", "0.001", 0.00099);
549 test("%3.2g", "0.00099", 0.00099);
550 test("%3.3g", "0.00100", 0.001);
551 test("%3.4g", "0.001000", 0.001);
552 test("%3.0g", "0.01", 0.01);
553 test("%3.0g", "0.1", 0.1);
554 test("%3.0g", "0.9", 0.9);
555 test("%3.1g", "0.9", 0.9);
556 test("%3.0g", " 1", 1.00);
557 test("%3.2g", " 10", 10.00);
558 test("%3.0g", "1e+01", 10.00);
559 test("%3.0g", "1e+02", 99.19);
560 test("%3.1g", "1e+02", 99.19);
561 test("%3.2g", " 99", 99.19);
562 test("%3.0g", "1e+02", 99.9);
563 test("%3.1g", "1e+02", 99.9);
564 test("%3.2g", "1.0e+02", 99.9);
565 test("%3.0g", "1e+02", 99.99);
566 test("%3.0g", "1e+02", 100.00);
567 test("%3.0g", "1e+03", 999.9);
568 test("%3.1g", "1e+03", 999.9);
569 test("%3.2g", "1.0e+03", 999.9);
570 test("%3.3g", "1.00e+03", 999.9);
571 test("%3.4g", "999.9", 999.9);
572 test("%3.4g", "1000", 999.99);
573 test("%3.0g", "1e+03", 1000.00);
574 test("%3.0g", "1e+04", 10000.00);
575 test("%3.0g", "1e+05", 100000.00);
576 test("%3.0g", "1e+06", 1000000.00);
577 test("%3.0g", "1e+07", 10000000.00);
578 test("%3.9g", "100000000", 100000000.00);
579 test("%3.10g", "100000000.0", 100000000.00);
580
581 tryCatch("%#3.0g", FormatFlagsConversionMismatchException.class, 1000.00);
582
583 // double PI^300
584 // = 13962455701329742638131355433930076081862072808 ... e+149
585
586 test("%.3g", "10.0", ten);
587 test("%.3g", "1.00", one);
588 test("%10.3g", " 1.00", one);
589 test("%+10.3g", " +3.14", pi);
590 test("%+10.3g", " -3.14", negate(pi));
591 test("% .3g", " 3.14", pi);
592 test("% .3g", "-3.14", negate(pi));
593 test("%.0g", "3", create(3.0));
594 test("%.0g", "-3", create(-3.0));
595
596 test("%(.4g", "3.142e+08", mult(pi, 100000000.0));
597 test("%(.4g", "(3.142e+08)", mult(pi, -100000000.0));
598
599 test("%,.11g", "3,141,592.6536", mult(pi, 1000000.0));
600 test("%(,.11g", "(3,141,592.6536)", mult(pi, -1000000.0));
601
602 //---------------------------------------------------------------------
603 // %a
604 //
605 // Floating-point conversions applicable to float, double, and
606 // BigDecimal.
607 //---------------------------------------------------------------------
608 test("%a", "null", (Object)null);
609 test("%.11a", "0x0.00000000000p0", 0.0);
610 test(Locale.FRANCE, "%.11a", "0x0.00000000000p0", 0.0); // no localization
611 test("%.1a", "0x0.0p0", 0.0);
612 test("%.11a", "-0x0.00000000000p0", -0.0);
613 test("%.1a", "-0x0.0p0", -0.0);
614 test("%.11a", "0x1.00000000000p0", 1.0);
615 test("%.1a", "0x1.0p0", 1.0);
616 test("%.11a", "-0x1.00000000000p0", -1.0);
617 test("%.1a", "-0x1.0p0", -1.0);
618 test("%.11a", "0x1.80000000000p1", 3.0);
619 test("%.1a", "0x1.8p1", 3.0);
620 test("%.11a", "0x1.00000000000p-1022", DoubleConsts.MIN_NORMAL);
621 test("%.1a", "0x1.0p-1022", DoubleConsts.MIN_NORMAL);
622 test("%.11a", "0x1.00000000000p-1022",
623 Math.nextDown(DoubleConsts.MIN_NORMAL));
624 test("%.1a", "0x1.0p-1022",
625 Math.nextDown(DoubleConsts.MIN_NORMAL));
626 test("%.11a", "0x1.ffffffffffep-1023", 0x0.fffffffffffp-1022);
627 test("%.1a", "0x1.0p-1022", 0x0.fffffffffffp-1022);
628 test("%.30a", "0x0.000000000000100000000000000000p-1022", Double.MIN_VALUE);
629 test("%.13a", "0x0.0000000000001p-1022", Double.MIN_VALUE);
630 test("%.11a", "0x1.00000000000p-1074", Double.MIN_VALUE);
631 test("%.1a", "0x1.0p-1074", Double.MIN_VALUE);
632
633 test("%.11a", "0x1.08000000000p-1069",
634 Double.MIN_VALUE + Double.MIN_VALUE*32);
635 test("%.1a", "0x1.0p-1069",
636 Double.MIN_VALUE + Double.MIN_VALUE*32);
637 test("%.30a", "0x1.fffffffffffff00000000000000000p1023", Double.MAX_VALUE);
638 test("%.13a", "0x1.fffffffffffffp1023", Double.MAX_VALUE);
639 test("%.11a", "0x1.00000000000p1024", Double.MAX_VALUE);
640 test("%.1a", "0x1.0p1024", Double.MAX_VALUE);
641 test("%.11a", "0x1.18000000000p0", 0x1.18p0);
642 test("%.1a", "0x1.2p0", 0x1.18p0);
643
644 test("%.11a", "0x1.18000000000p0", 0x1.180000000001p0);
645 test("%.1a", "0x1.2p0", 0x1.180000000001p0);
646 test("%.11a", "0x1.28000000000p0", 0x1.28p0);
647 test("%.1a", "0x1.2p0", 0x1.28p0);
648
649 test("%.11a", "0x1.28000000000p0", 0x1.280000000001p0);
650 test("%.1a", "0x1.3p0", 0x1.280000000001p0);
651
652 test("%a", "0x0.123p-1022", 0x0.123p-1022);
653 test("%1.3a", "0x1.230p-1026", 0x0.123p-1022);
654 test("%1.12a", "0x1.230000000000p-1026", 0x0.123p-1022);
655 test("%1.15a", "0x0.123000000000000p-1022", 0x0.123p-1022);
656 test("%1.5a", "0x1.00000p-1074", 0x0.0000000000001p-1022);
657 test("%1.7a", "0x1.0000000p-1022", 0x0.fffffffffffffp-1022);
658
659 test("%1.6a", "0x1.230000p-1026", 0x0.123000057p-1022);
660 test("%1.7a", "0x1.2300005p-1026", 0x0.123000057p-1022);
661 test("%1.8a", "0x1.23000057p-1026", 0x0.123000057p-1022);
662 test("%1.9a", "0x1.230000570p-1026", 0x0.123000057p-1022);
663
664 test("%1.6a", "0x1.230000p-1026", 0x0.123000058p-1022);
665 test("%1.7a", "0x1.2300006p-1026", 0x0.123000058p-1022);
666 test("%1.8a", "0x1.23000058p-1026", 0x0.123000058p-1022);
667 test("%1.9a", "0x1.230000580p-1026", 0x0.123000058p-1022);
668
669 test("%1.6a", "0x1.230000p-1026", 0x0.123000059p-1022);
670 test("%1.7a", "0x1.2300006p-1026", 0x0.123000059p-1022);
671 test("%1.8a", "0x1.23000059p-1026", 0x0.123000059p-1022);
672 test("%1.9a", "0x1.230000590p-1026", 0x0.123000059p-1022);
673
674 test("%1.4a", "0x1.0000p-1022", Math.nextDown(Double.MIN_NORMAL));
675
676 test("%a", "0x1.fffffffffffffp1023", Double.MAX_VALUE);
677 test("%1.1a", "0x1.0p1024", Double.MAX_VALUE);
678 test("%1.2a", "0x1.00p1024", Double.MAX_VALUE);
679 test("%1.6a", "0x1.000000p1024", Double.MAX_VALUE);
680 test("%1.9a", "0x1.000000000p1024", Double.MAX_VALUE);
681 test("%1.11a", "0x1.00000000000p1024", Double.MAX_VALUE);
682 test("%1.12a", "0x1.000000000000p1024", Double.MAX_VALUE);
683 test("%1.13a", "0x1.fffffffffffffp1023", Double.MAX_VALUE);
684
685 //---------------------------------------------------------------------
686 // %f, %e, %g, %a - Boundaries
687 //---------------------------------------------------------------------
688
689 //---------------------------------------------------------------------
690 // %f, %e, %g, %a - Double.MIN_VALUE
691 //---------------------------------------------------------------------
692 test("%f", "0.000000", Double.MIN_VALUE);
693 test("%,f", "0.000000", Double.MIN_VALUE);
694 test("%(f", "(0.000000)", -Double.MIN_VALUE);
695 test("%30.0f", " 0", Double.MIN_VALUE);
696 test("%30.5f", " 0.00000", Double.MIN_VALUE);
697 test("%30.13f", " 0.0000000000000", Double.MIN_VALUE);
698 test("%30.20f", " 0.00000000000000000000", Double.MIN_VALUE);
699 test("%30.350f","0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000490000000000000000000000000",
700 Double.MIN_VALUE);
701 test("%e", "4.900000e-324", Double.MIN_VALUE);
702 test("%E", "4.900000E-324", Double.MIN_VALUE);
703 test("%(.1e", "4.9e-324", Double.MIN_VALUE);
704 test("%(E", "(4.900000E-324)", -Double.MIN_VALUE);
705 test("%30.5e", " 4.90000e-324", Double.MIN_VALUE);
706 test("%30.13e", " 4.9000000000000e-324", Double.MIN_VALUE);
707 test("%30.20e", " 4.90000000000000000000e-324", Double.MIN_VALUE);
708 test("%g", "4.90000e-324", Double.MIN_VALUE);
709 test("%G", "4.90000E-324", Double.MIN_VALUE);
710 test("%(g", "4.90000e-324", Double.MIN_VALUE);
711 test("%,g", "4.90000e-324", Double.MIN_VALUE);
712 test("%30.5g", " 4.9000e-324", Double.MIN_VALUE);
713 test("%30.13g", " 4.900000000000e-324", Double.MIN_VALUE);
714 test("%30.20g", " 4.9000000000000000000e-324", Double.MIN_VALUE);
715 test("%a", "0x0.0000000000001p-1022", Double.MIN_VALUE);
716 test("%A", "0X0.0000000000001P-1022", Double.MIN_VALUE);
717 test("%30a", " 0x0.0000000000001p-1022", Double.MIN_VALUE);
718
719 //---------------------------------------------------------------------
720 // %f, %e, %g, %a - Double.MAX_VALUE
721 //---------------------------------------------------------------------
722 test("%f", "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000",
723 Double.MAX_VALUE);
724 test("%,f", "179,769,313,486,231,570,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000",
725 Double.MAX_VALUE);
726 test("%,(f", "(179,769,313,486,231,570,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.000000)",
727 -Double.MAX_VALUE);
728 test("%,30.5f", "179,769,313,486,231,570,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000.00000",
729 Double.MAX_VALUE);
730 test("%30.13f", "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0000000000000",
731 Double.MAX_VALUE);
732 test("%30.20f", "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.00000000000000000000",
733 Double.MAX_VALUE);
734 test("%e", "1.797693e+308", Double.MAX_VALUE);
735 test("%E", "1.797693E+308", Double.MAX_VALUE);
736 test("%(e", "1.797693e+308", Double.MAX_VALUE);
737 test("%(e", "(1.797693e+308)", -Double.MAX_VALUE);
738 test("%30.5e", " 1.79769e+308", Double.MAX_VALUE);
739 test("%30.13e", " 1.7976931348623e+308", Double.MAX_VALUE);
740 test("%30.20e", " 1.79769313486231570000e+308", Double.MAX_VALUE);
741 test("%g", "1.79769e+308", Double.MAX_VALUE);
742 test("%G", "1.79769E+308", Double.MAX_VALUE);
743 test("%,g", "1.79769e+308", Double.MAX_VALUE);
744 test("%(g", "(1.79769e+308)", -Double.MAX_VALUE);
745 test("%30.5g", " 1.7977e+308", Double.MAX_VALUE);
746 test("%30.13g", " 1.797693134862e+308", Double.MAX_VALUE);
747 test("%30.20g", " 1.7976931348623157000e+308", Double.MAX_VALUE);
748 test("%a", "0x1.fffffffffffffp1023", Double.MAX_VALUE);
749 test("%A", "0X1.FFFFFFFFFFFFFP1023", Double.MAX_VALUE);
750 test("%30a", " 0x1.fffffffffffffp1023", Double.MAX_VALUE);
751
752 //---------------------------------------------------------------------
753 // %t
754 //
755 // Date/Time conversions applicable to Calendar, Date, and long.
756 //---------------------------------------------------------------------
757 test("%tA", "null", (Object)null);
758 test("%TA", "NULL", (Object)null);
759
760 //---------------------------------------------------------------------
761 // %t - errors
762 //---------------------------------------------------------------------
763 tryCatch("%t", UnknownFormatConversionException.class);
764 tryCatch("%T", UnknownFormatConversionException.class);
765 tryCatch("%tP", UnknownFormatConversionException.class);
766 tryCatch("%TP", UnknownFormatConversionException.class);
767 tryCatch("%.5tB", IllegalFormatPrecisionException.class);
768 tryCatch("%#tB", FormatFlagsConversionMismatchException.class);
769 tryCatch("%-tB", MissingFormatWidthException.class);
770
771 //---------------------------------------------------------------------
772 // %n
773 //---------------------------------------------------------------------
774 test("%n", System.getProperty("line.separator"), (Object)null);
775 test("%n", System.getProperty("line.separator"), "");
776
777 tryCatch("%,n", IllegalFormatFlagsException.class);
778 tryCatch("%.n", UnknownFormatConversionException.class);
779 tryCatch("%5.n", UnknownFormatConversionException.class);
780 tryCatch("%5n", IllegalFormatWidthException.class);
781 tryCatch("%.7n", IllegalFormatPrecisionException.class);
782 tryCatch("%<n", IllegalFormatFlagsException.class);
783
784 //---------------------------------------------------------------------
785 // %%
786 //---------------------------------------------------------------------
787 test("%%", "%", (Object)null);
788 test("%%", "%", "");
789 tryCatch("%%%", UnknownFormatConversionException.class);
790 // perhaps an IllegalFormatArgumentIndexException should be defined?
791 tryCatch("%<%", IllegalFormatFlagsException.class);
792 }
793 }