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
40
41
42 import static java.util.Calendar.*;
43
44
45
46
47
48 public class BasicFloat extends Basic {
49
50 private static void test(String fs, String exp, Object ... args) {
51 Formatter f = new Formatter(new StringBuilder(), Locale.US);
52 f.format(fs, args);
53 ck(fs, exp, f.toString());
54
55 f = new Formatter(new StringBuilder(), Locale.US);
56 f.format("foo " + fs + " bar", args);
57 ck(fs, "foo " + exp + " bar", f.toString());
58 }
59
60 private static void test(Locale l, String fs, String exp, Object ... args)
61 {
62 Formatter f = new Formatter(new StringBuilder(), l);
63 f.format(fs, args);
64 ck(fs, exp, f.toString());
65
66 f = new Formatter(new StringBuilder(), l);
67 f.format("foo " + fs + " bar", args);
68 ck(fs, "foo " + exp + " bar", f.toString());
69 }
70
71 private static void test(String fs, Object ... args) {
72 Formatter f = new Formatter(new StringBuilder(), Locale.US);
73 f.format(fs, args);
74 ck(fs, "fail", f.toString());
75 }
76
77 private static void test(String fs) {
78 Formatter f = new Formatter(new StringBuilder(), Locale.US);
79 f.format(fs, "fail");
80 ck(fs, "fail", f.toString());
81 }
82
83 private static void testSysOut(String fs, String exp, Object ... args) {
84 FileOutputStream fos = null;
85 FileInputStream fis = null;
86 try {
87 PrintStream saveOut = System.out;
88 fos = new FileOutputStream("testSysOut");
89 System.setOut(new PrintStream(fos));
90 System.out.format(Locale.US, fs, args);
91 fos.close();
92
93 fis = new FileInputStream("testSysOut");
94 byte [] ba = new byte[exp.length()];
95 int len = fis.read(ba);
96 String got = new String(ba);
97 if (len != ba.length)
98 fail(fs, exp, got);
99 ck(fs, exp, got);
100
101 System.setOut(saveOut);
102 } catch (FileNotFoundException ex) {
103 fail(fs, ex.getClass());
104 } catch (IOException ex) {
105 fail(fs, ex.getClass());
106 } finally {
107 try {
108 if (fos != null)
109 fos.close();
110 if (fis != null)
111 fis.close();
112 } catch (IOException ex) {
113 fail(fs, ex.getClass());
114 }
115 }
116 }
117
118 private static void tryCatch(String fs, Class<?> ex) {
119 boolean caught = false;
120 try {
121 test(fs);
122 } catch (Throwable x) {
123 if (ex.isAssignableFrom(x.getClass()))
124 caught = true;
125 }
126 if (!caught)
127 fail(fs, ex);
128 else
129 pass();
130 }
131
132 private static void tryCatch(String fs, Class<?> ex, Object ... args) {
133 boolean caught = false;
134 try {
135 test(fs, args);
136 } catch (Throwable x) {
137 if (ex.isAssignableFrom(x.getClass()))
138 caught = true;
139 }
140 if (!caught)
141 fail(fs, ex);
142 else
143 pass();
144 }
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272 private static float create(double v) {
273 return (float) v;
274 }
275
276 private static float negate(double v) {
277 return (float) -v;
278 }
279
280 private static float mult(float v, double mul) {
281 return v * (float) mul;
282 }
283
284 private static float recip(float v) {
285 return 1.0f / v;
286 }
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341 public static void test() {
342 TimeZone.setDefault(TimeZone.getTimeZone("GMT-0800"));
343
344 // Any characters not explicitly defined as conversions, date/time
345 // conversion suffixes, or flags are illegal and are reserved for
346 // future extensions. Use of such a character in a format string will
347 // cause an UnknownFormatConversionException or
348 // UnknownFormatFlagsException to be thrown.
349 tryCatch("%q", UnknownFormatConversionException.class);
350 tryCatch("%t&", UnknownFormatConversionException.class);
351 tryCatch("%&d", UnknownFormatConversionException.class);
352 tryCatch("%^b", UnknownFormatConversionException.class);
353
354 //---------------------------------------------------------------------
355 // Formatter.java class javadoc examples
356 //---------------------------------------------------------------------
357 test(Locale.FRANCE, "e = %+10.4f", "e = +2,7183", Math.E);
358 test("%4$2s %3$2s %2$2s %1$2s", " d c b a", "a", "b", "c", "d");
359 test("Amount gained or lost since last statement: $ %,(.2f",
360 "Amount gained or lost since last statement: $ (6,217.58)",
361 (new BigDecimal("-6217.58")));
362 Calendar c = new GregorianCalendar(1969, JULY, 20, 16, 17, 0);
363 testSysOut("Local time: %tT", "Local time: 16:17:00", c);
364
365 test("Unable to open file '%1$s': %2$s",
366 "Unable to open file 'food': No such file or directory",
367 "food", "No such file or directory");
368 Calendar duke = new GregorianCalendar(1995, MAY, 23, 19, 48, 34);
369 duke.set(Calendar.MILLISECOND, 584);
370 test("Duke's Birthday: %1$tB %1$te, %1$tY",
371 "Duke's Birthday: May 23, 1995",
372 duke);
373 test("Duke's Birthday: %1$tB %1$te, %1$tY",
374 "Duke's Birthday: May 23, 1995",
375 duke.getTime());
376 test("Duke's Birthday: %1$tB %1$te, %1$tY",
377 "Duke's Birthday: May 23, 1995",
378 duke.getTimeInMillis());
379
380 test("%4$s %3$s %2$s %1$s %4$s %3$s %2$s %1$s",
381 "d c b a d c b a", "a", "b", "c", "d");
382 test("%s %s %<s %<s", "a b b b", "a", "b", "c", "d");
383 test("%s %s %s %s", "a b c d", "a", "b", "c", "d");
384 test("%2$s %s %<s %s", "b a a b", "a", "b", "c", "d");
385
386 //---------------------------------------------------------------------
387 // %b
388 //
389 // General conversion applicable to any argument.
390 //---------------------------------------------------------------------
391 test("%b", "true", true);
392 test("%b", "false", false);
393 test("%B", "TRUE", true);
394 test("%B", "FALSE", false);
395 test("%b", "true", Boolean.TRUE);
396 test("%b", "false", Boolean.FALSE);
397 test("%B", "TRUE", Boolean.TRUE);
398 test("%B", "FALSE", Boolean.FALSE);
399 test("%14b", " true", true);
400 test("%-14b", "true ", true);
401 test("%5.1b", " f", false);
402 test("%-5.1b", "f ", false);
403
404 test("%b", "true", "foo");
405 test("%b", "false", (Object)null);
406
407 // Boolean.java hardcodes the Strings for "true" and "false", so no
408 // localization is possible.
409 test(Locale.FRANCE, "%b", "true", true);
410 test(Locale.FRANCE, "%b", "false", false);
411
412 // If you pass in a single array to a varargs method, the compiler
413 // uses it as the array of arguments rather than treating it as a
414 // single array-type argument.
415 test("%b", "false", (Object[])new String[2]);
416 test("%b", "true", new String[2], new String[2]);
417
418 int [] ia = { 1, 2, 3 };
419 test("%b", "true", ia);
420
421 //---------------------------------------------------------------------
422 // %b - errors
423 //---------------------------------------------------------------------
424 tryCatch("%#b", FormatFlagsConversionMismatchException.class);
425 tryCatch("%-b", MissingFormatWidthException.class);
426 // correct or side-effect of implementation?
427 tryCatch("%.b", UnknownFormatConversionException.class);
428 tryCatch("%,b", FormatFlagsConversionMismatchException.class);
429
430 //---------------------------------------------------------------------
431 // %c
432 //
433 // General conversion applicable to any argument.
434 //---------------------------------------------------------------------
435 test("%c", "i", 'i');
436 test("%C", "I", 'i');
437 test("%4c", " i", 'i');
438 test("%-4c", "i ", 'i');
439 test("%4C", " I", 'i');
440 test("%-4C", "I ", 'i');
441 test("%c", "i", new Character('i'));
442 test("%c", "H", (byte) 72);
443 test("%c", "i", (short) 105);
444 test("%c", "!", (int) 33);
445 test("%c", "\u007F", Byte.MAX_VALUE);
446 test("%c", new String(Character.toChars(Short.MAX_VALUE)),
447 Short.MAX_VALUE);
448 test("%c", "null", (Object) null);
449
450 //---------------------------------------------------------------------
451 // %c - errors
452 //---------------------------------------------------------------------
453 tryCatch("%c", IllegalFormatConversionException.class,
454 Boolean.TRUE);
455 tryCatch("%c", IllegalFormatConversionException.class,
456 (float) 0.1);
457 tryCatch("%c", IllegalFormatConversionException.class,
458 new Object());
459 tryCatch("%c", IllegalFormatCodePointException.class,
460 Byte.MIN_VALUE);
461 tryCatch("%c", IllegalFormatCodePointException.class,
462 Short.MIN_VALUE);
463 tryCatch("%c", IllegalFormatCodePointException.class,
464 Integer.MIN_VALUE);
465 tryCatch("%c", IllegalFormatCodePointException.class,
466 Integer.MAX_VALUE);
467
468 tryCatch("%#c", FormatFlagsConversionMismatchException.class);
469 tryCatch("%,c", FormatFlagsConversionMismatchException.class);
470 tryCatch("%(c", FormatFlagsConversionMismatchException.class);
471 tryCatch("%$c", UnknownFormatConversionException.class);
472 tryCatch("%.2c", IllegalFormatPrecisionException.class);
473
474 //---------------------------------------------------------------------
475 // %s
476 //
477 // General conversion applicable to any argument.
478 //---------------------------------------------------------------------
479 test("%s", "Hello, Duke", "Hello, Duke");
480 test("%S", "HELLO, DUKE", "Hello, Duke");
481 test("%20S", " HELLO, DUKE", "Hello, Duke");
482 test("%20s", " Hello, Duke", "Hello, Duke");
483 test("%-20s", "Hello, Duke ", "Hello, Duke");
484 test("%-20.5s", "Hello ", "Hello, Duke");
485 test("%s", "null", (Object)null);
486
487 StringBuffer sb = new StringBuffer("foo bar");
488 test("%s", sb.toString(), sb);
489 test("%S", sb.toString().toUpperCase(), sb);
490
491 //---------------------------------------------------------------------
492 // %s - errors
493 //---------------------------------------------------------------------
494 tryCatch("%-s", MissingFormatWidthException.class);
495 tryCatch("%--s", DuplicateFormatFlagsException.class);
496 tryCatch("%#s", FormatFlagsConversionMismatchException.class, 0);
497 tryCatch("%#s", FormatFlagsConversionMismatchException.class, 0.5f);
498 tryCatch("%#s", FormatFlagsConversionMismatchException.class, "hello");
499 tryCatch("%#s", FormatFlagsConversionMismatchException.class, null);
500
501 //---------------------------------------------------------------------
502 // %h
503 //
504 // General conversion applicable to any argument.
505 //---------------------------------------------------------------------
506 test("%h", Integer.toHexString("Hello, Duke".hashCode()),
507 "Hello, Duke");
508 test("%10h", " ddf63471", "Hello, Duke");
509 test("%-10h", "ddf63471 ", "Hello, Duke");
510 test("%-10H", "DDF63471 ", "Hello, Duke");
511 test("%10h", " 402e0000", 15.0);
512 test("%10H", " 402E0000", 15.0);
513
514 //---------------------------------------------------------------------
515 // %h - errors
516 //---------------------------------------------------------------------
517 tryCatch("%#h", FormatFlagsConversionMismatchException.class);
518
519 //---------------------------------------------------------------------
520 // flag/conversion errors
521 //---------------------------------------------------------------------
522 tryCatch("%F", UnknownFormatConversionException.class);
523
524 tryCatch("%#g", FormatFlagsConversionMismatchException.class);
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879 //---------------------------------------------------------------------
880 // %s - float
881 //---------------------------------------------------------------------
882 float one = 1.0f;
883 float ten = 10.0f;
884 float pi = (float) Math.PI;
885
886 test("%s", "3.1415927", pi);
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919 //---------------------------------------------------------------------
920 // flag/conversion errors
921 //---------------------------------------------------------------------
922 tryCatch("%d", IllegalFormatConversionException.class, one);
923 tryCatch("%,.4e", FormatFlagsConversionMismatchException.class, one);
924
925 //---------------------------------------------------------------------
926 // %e
927 //
928 // Floating-point conversions applicable to float, double, and
929 // BigDecimal.
930 //---------------------------------------------------------------------
931 test("%e", "null", (Object)null);
932
933 //---------------------------------------------------------------------
934 // %e - float and double
935 //---------------------------------------------------------------------
936 // double PI = 3.141 592 653 589 793 238 46;
937 test("%e", "3.141593e+00", pi);
938 test("%.0e", "1e+01", ten);
939 test("%#.0e", "1.e+01", ten);
940 test("%E", "3.141593E+00", pi);
941 test("%10.3e", " 3.142e+00", pi);
942 test("%10.3e", "-3.142e+00", negate(pi));
943 test("%010.3e", "03.142e+00", pi);
944 test("%010.3e", "-3.142e+00", negate(pi));
945 test("%-12.3e", "3.142e+00 ", pi);
946 test("%-12.3e", "-3.142e+00 ", negate(pi));
947 test("%.3e", "3.142e+00", pi);
948 test("%.3e", "-3.142e+00", negate(pi));
949 test("%.3e", "3.142e+06", mult(pi, 1000000.0));
950 test("%.3e", "-3.142e+06", mult(pi, -1000000.0));
951
952 test(Locale.FRANCE, "%e", "3,141593e+00", pi);
953
954 // double PI^300
955 // = 13962455701329742638131355433930076081862072808 ... e+149
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987 test("%10.3e", " 1.000e+00", one);
988 test("%+.3e", "+3.142e+00", pi);
989 test("%+.3e", "-3.142e+00", negate(pi));
990 test("% .3e", " 3.142e+00", pi);
991 test("% .3e", "-3.142e+00", negate(pi));
992 test("%#.0e", "3.e+00", create(3.0));
993 test("%#.0e", "-3.e+00", create(-3.0));
994 test("%.0e", "3e+00", create(3.0));
995 test("%.0e", "-3e+00", create(-3.0));
996
997 test("%(.4e", "3.1416e+06", mult(pi, 1000000.0));
998 test("%(.4e", "(3.1416e+06)", mult(pi, -1000000.0));
999
1000 //---------------------------------------------------------------------
1001 // %e - boundary problems
1002 //---------------------------------------------------------------------
1003 test("%3.0e", "1e-06", 0.000001);
1004 test("%3.0e", "1e-05", 0.00001);
1005 test("%3.0e", "1e-04", 0.0001);
1006 test("%3.0e", "1e-03", 0.001);
1007 test("%3.0e", "1e-02", 0.01);
1008 test("%3.0e", "1e-01", 0.1);
1009 test("%3.0e", "9e-01", 0.9);
1010 test("%3.1e", "9.0e-01", 0.9);
1011 test("%3.0e", "1e+00", 1.00);
1012 test("%3.0e", "1e+01", 10.00);
1013 test("%3.0e", "1e+02", 99.19);
1014 test("%3.1e", "9.9e+01", 99.19);
1015 test("%3.0e", "1e+02", 99.99);
1016 test("%3.0e", "1e+02", 100.00);
1017 test("%#3.0e", "1.e+03", 1000.00);
1018 test("%3.0e", "1e+04", 10000.00);
1019 test("%3.0e", "1e+05", 100000.00);
1020 test("%3.0e", "1e+06", 1000000.00);
1021 test("%3.0e", "1e+07", 10000000.00);
1022 test("%3.0e", "1e+08", 100000000.00);
1023
1024 //---------------------------------------------------------------------
1025 // %f
1026 //
1027 // Floating-point conversions applicable to float, double, and
1028 // BigDecimal.
1029 //---------------------------------------------------------------------
1030 test("%f", "null", (Object)null);
1031 test("%f", "3.141593", pi);
1032 test(Locale.FRANCE, "%f", "3,141593", pi);
1033 test("%10.3f", " 3.142", pi);
1034 test("%10.3f", " -3.142", negate(pi));
1035 test("%010.3f", "000003.142", pi);
1036 test("%010.3f", "-00003.142", negate(pi));
1037 test("%-10.3f", "3.142 ", pi);
1038 test("%-10.3f", "-3.142 ", negate(pi));
1039 test("%.3f", "3.142", pi);
1040 test("%.3f", "-3.142", negate(pi));
1041 test("%+.3f", "+3.142", pi);
1042 test("%+.3f", "-3.142", negate(pi));
1043 test("% .3f", " 3.142", pi);
1044 test("% .3f", "-3.142", negate(pi));
1045 test("%#.0f", "3.", create(3.0));
1046 test("%#.0f", "-3.", create(-3.0));
1047 test("%.0f", "3", create(3.0));
1048 test("%.0f", "-3", create(-3.0));
1049 test("%.3f", "10.000", ten);
1050 test("%.3f", "1.000", one);
1051 test("%10.3f", " 1.000", one);
1052
1053 //---------------------------------------------------------------------
1054 // %f - boundary problems
1055 //---------------------------------------------------------------------
1056 test("%3.0f", " 0", 0.000001);
1057 test("%3.0f", " 0", 0.00001);
1058 test("%3.0f", " 0", 0.0001);
1059 test("%3.0f", " 0", 0.001);
1060 test("%3.0f", " 0", 0.01);
1061 test("%3.0f", " 0", 0.1);
1062 test("%3.0f", " 1", 0.9);
1063 test("%3.1f", "0.9", 0.9);
1064 test("%3.0f", " 1", 1.00);
1065 test("%3.0f", " 10", 10.00);
1066 test("%3.0f", " 99", 99.19);
1067 test("%3.1f", "99.2", 99.19);
1068 test("%3.0f", "100", 99.99);
1069 test("%3.0f", "100", 100.00);
1070 test("%#3.0f", "1000.", 1000.00);
1071 test("%3.0f", "10000", 10000.00);
1072 test("%3.0f", "100000", 100000.00);
1073 test("%3.0f", "1000000", 1000000.00);
1074 test("%3.0f", "10000000", 10000000.00);
1075 test("%3.0f", "100000000", 100000000.00);
1076 test("%10.0f", " 1000000", 1000000.00);
1077 test("%,10.0f", " 1,000,000", 1000000.00);
1078 test("%,10.1f", "1,000,000.0", 1000000.00);
1079 test("%,3.0f", "1,000,000", 1000000.00);
1080 test("%,3.0f", "10,000,000", 10000000.00);
1081 test("%,3.0f", "100,000,000", 100000000.00);
1082 test("%,3.0f", "10,000,000", 10000000.00);
1083 test("%,3.0f", "100,000,000", 100000000.00);
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160 //---------------------------------------------------------------------
1161 // %f - float
1162 //---------------------------------------------------------------------
1163 // Float can not accurately store 1e6 * PI.
1164 test("%.3f", "3141.593", mult(pi, 1000.0));
1165 test("%.3f", "-3141.593", mult(pi, -1000.0));
1166
1167 test("%,.2f", "3,141.59", mult(pi, 1000.0));
1168 test(Locale.FRANCE, "%,.2f", "3\u00a0141,59", mult(pi, 1000.0));
1169 test("%,.2f", "-3,141.59", mult(pi, -1000.0));
1170 test("%(.2f", "3141.59", mult(pi, 1000.0));
1171 test("%(.2f", "(3141.59)", mult(pi, -1000.0));
1172 test("%(,.2f", "3,141.59", mult(pi, 1000.0));
1173 test("%(,.2f", "(3,141.59)", mult(pi, -1000.0));
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193 //---------------------------------------------------------------------
1194 // %g
1195 //
1196 // Floating-point conversions applicable to float, double, and
1197 // BigDecimal.
1198 //---------------------------------------------------------------------
1199 test("%g", "null", (Object)null);
1200 test("%g", "3.14159", pi);
1201 test(Locale.FRANCE, "%g", "3,14159", pi);
1202 test("%.0g", "1e+01", ten);
1203 test("%G", "3.14159", pi);
1204 test("%10.3g", " 3.14", pi);
1205 test("%10.3g", " -3.14", negate(pi));
1206 test("%010.3g", "0000003.14", pi);
1207 test("%010.3g", "-000003.14", negate(pi));
1208 test("%-12.3g", "3.14 ", pi);
1209 test("%-12.3g", "-3.14 ", negate(pi));
1210 test("%.3g", "3.14", pi);
1211 test("%.3g", "-3.14", negate(pi));
1212 test("%.3g", "3.14e+08", mult(pi, 100000000.0));
1213 test("%.3g", "-3.14e+08", mult(pi, -100000000.0));
1214
1215 test("%.3g", "1.00e-05", recip(create(100000.0)));
1216 test("%.3g", "-1.00e-05", recip(create(-100000.0)));
1217 test("%.0g", "-1e-05", recip(create(-100000.0)));
1218 test("%.0g", "1e+05", create(100000.0));
1219 test("%.3G", "1.00E-05", recip(create(100000.0)));
1220 test("%.3G", "-1.00E-05", recip(create(-100000.0)));
1221
1222 test("%.1g", "-0", -0.0);
1223 test("%3.0g", " -0", -0.0);
1224 test("%.1g", "0", 0.0);
1225 test("%3.0g", " 0", 0.0);
1226 test("%.1g", "0", +0.0);
1227 test("%3.0g", " 0", +0.0);
1228
1229 test("%3.0g", "1e-06", 0.000001);
1230 test("%3.0g", "1e-05", 0.00001);
1231 test("%3.0g", "1e-05", 0.0000099);
1232 test("%3.1g", "1e-05", 0.0000099);
1233 test("%3.2g", "9.9e-06", 0.0000099);
1234 test("%3.0g", "0.0001", 0.0001);
1235 test("%3.0g", "9e-05", 0.00009);
1236 test("%3.0g", "0.0001", 0.000099);
1237 test("%3.1g", "0.0001", 0.000099);
1238 test("%3.2g", "9.9e-05", 0.000099);
1239 test("%3.0g", "0.001", 0.001);
1240 test("%3.0g", "0.001", 0.00099);
1241 test("%3.1g", "0.001", 0.00099);
1242 test("%3.2g", "0.00099", 0.00099);
1243 test("%3.3g", "0.00100", 0.001);
1244 test("%3.4g", "0.001000", 0.001);
1245 test("%3.0g", "0.01", 0.01);
1246 test("%3.0g", "0.1", 0.1);
1247 test("%3.0g", "0.9", 0.9);
1248 test("%3.1g", "0.9", 0.9);
1249 test("%3.0g", " 1", 1.00);
1250 test("%3.2g", " 10", 10.00);
1251 test("%3.0g", "1e+01", 10.00);
1252 test("%3.0g", "1e+02", 99.19);
1253 test("%3.1g", "1e+02", 99.19);
1254 test("%3.2g", " 99", 99.19);
1255 test("%3.0g", "1e+02", 99.9);
1256 test("%3.1g", "1e+02", 99.9);
1257 test("%3.2g", "1.0e+02", 99.9);
1258 test("%3.0g", "1e+02", 99.99);
1259 test("%3.0g", "1e+02", 100.00);
1260 test("%3.0g", "1e+03", 999.9);
1261 test("%3.1g", "1e+03", 999.9);
1262 test("%3.2g", "1.0e+03", 999.9);
1263 test("%3.3g", "1.00e+03", 999.9);
1264 test("%3.4g", "999.9", 999.9);
1265 test("%3.4g", "1000", 999.99);
1266 test("%3.0g", "1e+03", 1000.00);
1267 test("%3.0g", "1e+04", 10000.00);
1268 test("%3.0g", "1e+05", 100000.00);
1269 test("%3.0g", "1e+06", 1000000.00);
1270 test("%3.0g", "1e+07", 10000000.00);
1271 test("%3.9g", "100000000", 100000000.00);
1272 test("%3.10g", "100000000.0", 100000000.00);
1273
1274 tryCatch("%#3.0g", FormatFlagsConversionMismatchException.class, 1000.00);
1275
1276 // double PI^300
1277 // = 13962455701329742638131355433930076081862072808 ... e+149
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315 test("%.3g", "10.0", ten);
1316 test("%.3g", "1.00", one);
1317 test("%10.3g", " 1.00", one);
1318 test("%+10.3g", " +3.14", pi);
1319 test("%+10.3g", " -3.14", negate(pi));
1320 test("% .3g", " 3.14", pi);
1321 test("% .3g", "-3.14", negate(pi));
1322 test("%.0g", "3", create(3.0));
1323 test("%.0g", "-3", create(-3.0));
1324
1325 test("%(.4g", "3.142e+08", mult(pi, 100000000.0));
1326 test("%(.4g", "(3.142e+08)", mult(pi, -100000000.0));
1327
1328
1329 // Float can not accurately store 1e6 * PI.
1330 test("%,.6g", "3,141.59", mult(pi, 1000.0));
1331 test("%(,.6g", "(3,141.59)", mult(pi, -1000.0));
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425 //---------------------------------------------------------------------
1426 // %f, %e, %g, %a - Boundaries
1427 //---------------------------------------------------------------------
1428
1429 //---------------------------------------------------------------------
1430 // %f, %e, %g, %a - NaN
1431 //---------------------------------------------------------------------
1432 test("%f", "NaN", Float.NaN);
1433 // s
1434 test("%+f", "NaN", Float.NaN);
1435 // test("%F", "NAN", Float.NaN);
1436 test("%e", "NaN", Float.NaN);
1437 test("%+e", "NaN", Float.NaN);
1438 test("%E", "NAN", Float.NaN);
1439 test("%g", "NaN", Float.NaN);
1440 test("%+g", "NaN", Float.NaN);
1441 test("%G", "NAN", Float.NaN);
1442 test("%a", "NaN", Float.NaN);
1443 test("%+a", "NaN", Float.NaN);
1444 test("%A", "NAN", Float.NaN);
1445
1446 //---------------------------------------------------------------------
1447 // %f, %e, %g, %a - +0.0
1448 //---------------------------------------------------------------------
1449 test("%f", "0.000000", +0.0);
1450 test("%+f", "+0.000000", +0.0);
1451 test("% f", " 0.000000", +0.0);
1452 // test("%F", "0.000000", +0.0);
1453 test("%e", "0.000000e+00", 0e0);
1454 test("%e", "0.000000e+00", +0.0);
1455 test("%+e", "+0.000000e+00", +0.0);
1456 test("% e", " 0.000000e+00", +0.0);
1457 test("%E", "0.000000E+00", 0e0);
1458 test("%E", "0.000000E+00", +0.0);
1459 test("%+E", "+0.000000E+00", +0.0);
1460 test("% E", " 0.000000E+00", +0.0);
1461 test("%g", "0.00000", +0.0);
1462 test("%+g", "+0.00000", +0.0);
1463 test("% g", " 0.00000", +0.0);
1464 test("%G", "0.00000", +0.0);
1465 test("% G", " 0.00000", +0.0);
1466 test("%a", "0x0.0p0", +0.0);
1467 test("%+a", "+0x0.0p0", +0.0);
1468 test("% a", " 0x0.0p0", +0.0);
1469 test("%A", "0X0.0P0", +0.0);
1470 test("% A", " 0X0.0P0", +0.0);
1471
1472 //---------------------------------------------------------------------
1473 // %f, %e, %g, %a - -0.0
1474 //---------------------------------------------------------------------
1475 test("%f", "-0.000000", -0.0);
1476 test("%+f", "-0.000000", -0.0);
1477 // test("%F", "-0.000000", -0.0);
1478 test("%e", "-0.000000e+00", -0.0);
1479 test("%+e", "-0.000000e+00", -0.0);
1480 test("%E", "-0.000000E+00", -0.0);
1481 test("%+E", "-0.000000E+00", -0.0);
1482 test("%g", "-0.00000", -0.0);
1483 test("%+g", "-0.00000", -0.0);
1484 test("%G", "-0.00000", -0.0);
1485 test("%a", "-0x0.0p0", -0.0);
1486 test("%+a", "-0x0.0p0", -0.0);
1487 test("%+A", "-0X0.0P0", -0.0);
1488
1489 //---------------------------------------------------------------------
1490 // %f, %e, %g, %a - +Infinity
1491 //---------------------------------------------------------------------
1492 test("%f", "Infinity", Float.POSITIVE_INFINITY);
1493 test("%+f", "+Infinity", Float.POSITIVE_INFINITY);
1494 test("% f", " Infinity", Float.POSITIVE_INFINITY);
1495 // test("%F", "INFINITY", Float.POSITIVE_INFINITY);
1496 test("%e", "Infinity", Float.POSITIVE_INFINITY);
1497 test("%+e", "+Infinity", Float.POSITIVE_INFINITY);
1498 test("% e", " Infinity", Float.POSITIVE_INFINITY);
1499 test("%E", "INFINITY", Float.POSITIVE_INFINITY);
1500 test("%+E", "+INFINITY", Float.POSITIVE_INFINITY);
1501 test("% E", " INFINITY", Float.POSITIVE_INFINITY);
1502 test("%g", "Infinity", Float.POSITIVE_INFINITY);
1503 test("%+g", "+Infinity", Float.POSITIVE_INFINITY);
1504 test("%G", "INFINITY", Float.POSITIVE_INFINITY);
1505 test("% G", " INFINITY", Float.POSITIVE_INFINITY);
1506 test("%+G", "+INFINITY", Float.POSITIVE_INFINITY);
1507 test("%a", "Infinity", Float.POSITIVE_INFINITY);
1508 test("%+a", "+Infinity", Float.POSITIVE_INFINITY);
1509 test("% a", " Infinity", Float.POSITIVE_INFINITY);
1510 test("%A", "INFINITY", Float.POSITIVE_INFINITY);
1511 test("%+A", "+INFINITY", Float.POSITIVE_INFINITY);
1512 test("% A", " INFINITY", Float.POSITIVE_INFINITY);
1513
1514 //---------------------------------------------------------------------
1515 // %f, %e, %g, %a - -Infinity
1516 //---------------------------------------------------------------------
1517 test("%f", "-Infinity", Float.NEGATIVE_INFINITY);
1518 test("%+f", "-Infinity", Float.NEGATIVE_INFINITY);
1519 test("%(f", "(Infinity)", Float.NEGATIVE_INFINITY);
1520 // test("%F", "-INFINITY", Float.NEGATIVE_INFINITY);
1521 test("%e", "-Infinity", Float.NEGATIVE_INFINITY);
1522 test("%+e", "-Infinity", Float.NEGATIVE_INFINITY);
1523 test("%E", "-INFINITY", Float.NEGATIVE_INFINITY);
1524 test("%+E", "-INFINITY", Float.NEGATIVE_INFINITY);
1525 test("%g", "-Infinity", Float.NEGATIVE_INFINITY);
1526 test("%+g", "-Infinity", Float.NEGATIVE_INFINITY);
1527 test("%G", "-INFINITY", Float.NEGATIVE_INFINITY);
1528 test("%+G", "-INFINITY", Float.NEGATIVE_INFINITY);
1529 test("%a", "-Infinity", Float.NEGATIVE_INFINITY);
1530 test("%+a", "-Infinity", Float.NEGATIVE_INFINITY);
1531 test("%A", "-INFINITY", Float.NEGATIVE_INFINITY);
1532 test("%+A", "-INFINITY", Float.NEGATIVE_INFINITY);
1533
1534 //---------------------------------------------------------------------
1535 // %f, %e, %g, %a - Float.MIN_VALUE
1536 //---------------------------------------------------------------------
1537 test("%f", "0.000000", Float.MIN_VALUE);
1538 test("%,f", "0.000000", Float.MIN_VALUE);
1539 test("%(f", "(0.000000)", -Float.MIN_VALUE);
1540 test("%30.0f", " 0", Float.MIN_VALUE);
1541 test("%30.5f", " 0.00000", Float.MIN_VALUE);
1542 test("%30.13f", " 0.0000000000000", Float.MIN_VALUE);
1543 test("%30.20f", " 0.00000000000000000000", Float.MIN_VALUE);
1544 test("%e", "1.401298e-45", Float.MIN_VALUE);
1545 test("%E", "1.401298E-45", Float.MIN_VALUE);
1546 test("%(.1e", "1.4e-45", Float.MIN_VALUE);
1547 test("%(E", "(1.401298E-45)", -Float.MIN_VALUE);
1548 test("%30.5e", " 1.40130e-45", Float.MIN_VALUE);
1549 test("%30.13e", " 1.4012984643248e-45", Float.MIN_VALUE);
1550 test("%30.20e", " 1.40129846432481700000e-45", Float.MIN_VALUE);
1551 test("%g", "1.40130e-45", Float.MIN_VALUE);
1552 test("%G", "1.40130E-45", Float.MIN_VALUE);
1553 test("%(g", "1.40130e-45", Float.MIN_VALUE);
1554 test("%,g", "1.40130e-45", Float.MIN_VALUE);
1555 test("%(G", "(1.40130E-45)", -Float.MIN_VALUE);
1556 test("%30.5g", " 1.4013e-45", Float.MIN_VALUE);
1557 test("%30.13g", " 1.401298464325e-45", Float.MIN_VALUE);
1558 test("%30.20g", " 1.4012984643248170000e-45", Float.MIN_VALUE);
1559 test("%a", "0x1.0p-149", Float.MIN_VALUE);
1560 test("%A", "0X1.0P-149", Float.MIN_VALUE);
1561 test("%20a", " 0x1.0p-149", Float.MIN_VALUE);
1562
1563 //---------------------------------------------------------------------
1564 // %f, %e, %g, %a - Float.MAX_VALUE
1565 //---------------------------------------------------------------------
1566 test("%f", "340282346638528860000000000000000000000.000000", Float.MAX_VALUE);
1567 test("%,f","340,282,346,638,528,860,000,000,000,000,000,000,000.000000",
1568 Float.MAX_VALUE);
1569 test("%(f", "(340282346638528860000000000000000000000.000000)", -Float.MAX_VALUE);
1570 test("%60.5f", " 340282346638528860000000000000000000000.00000",
1571 Float.MAX_VALUE);
1572 test("%60.13f", " 340282346638528860000000000000000000000.0000000000000",
1573 Float.MAX_VALUE);
1574 test("%61.20f", " 340282346638528860000000000000000000000.00000000000000000000",
1575 Float.MAX_VALUE);
1576 test("%e", "3.402823e+38", Float.MAX_VALUE);
1577 test("%E", "3.402823E+38", Float.MAX_VALUE);
1578 test("%(e", "3.402823e+38", Float.MAX_VALUE);
1579 test("%(e", "(3.402823e+38)", -Float.MAX_VALUE);
1580 test("%30.5e", " 3.40282e+38", Float.MAX_VALUE);
1581 test("%30.13e", " 3.4028234663853e+38", Float.MAX_VALUE);
1582 test("%30.20e", " 3.40282346638528860000e+38", Float.MAX_VALUE);
1583 test("%g", "3.40282e+38", Float.MAX_VALUE);
1584 test("%G", "3.40282E+38", Float.MAX_VALUE);
1585 test("%,g", "3.40282e+38", Float.MAX_VALUE);
1586 test("%(g", "(3.40282e+38)", -Float.MAX_VALUE);
1587 test("%30.5g", " 3.4028e+38", Float.MAX_VALUE);
1588 test("%30.13g", " 3.402823466385e+38", Float.MAX_VALUE);
1589 test("%30.20G", " 3.4028234663852886000E+38", Float.MAX_VALUE);
1590 test("%a", "0x1.fffffep127", Float.MAX_VALUE);
1591 test("%A", "0X1.FFFFFEP127", Float.MAX_VALUE);
1592 test("%20a"," 0x1.fffffep127", Float.MAX_VALUE);
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663 //---------------------------------------------------------------------
1664 // %t
1665 //
1666 // Date/Time conversions applicable to Calendar, Date, and long.
1667 //---------------------------------------------------------------------
1668 test("%tA", "null", (Object)null);
1669 test("%TA", "NULL", (Object)null);
1670
1671 //---------------------------------------------------------------------
1672 // %t - errors
1673 //---------------------------------------------------------------------
1674 tryCatch("%t", UnknownFormatConversionException.class);
1675 tryCatch("%T", UnknownFormatConversionException.class);
1676 tryCatch("%tP", UnknownFormatConversionException.class);
1677 tryCatch("%TP", UnknownFormatConversionException.class);
1678 tryCatch("%.5tB", IllegalFormatPrecisionException.class);
1679 tryCatch("%#tB", FormatFlagsConversionMismatchException.class);
1680 tryCatch("%-tB", MissingFormatWidthException.class);
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776 //---------------------------------------------------------------------
1777 // %n
1778 //---------------------------------------------------------------------
1779 test("%n", System.getProperty("line.separator"), (Object)null);
1780 test("%n", System.getProperty("line.separator"), "");
1781
1782 tryCatch("%,n", IllegalFormatFlagsException.class);
1783 tryCatch("%.n", UnknownFormatConversionException.class);
1784 tryCatch("%5.n", UnknownFormatConversionException.class);
1785 tryCatch("%5n", IllegalFormatWidthException.class);
1786 tryCatch("%.7n", IllegalFormatPrecisionException.class);
1787 tryCatch("%<n", IllegalFormatFlagsException.class);
1788
1789 //---------------------------------------------------------------------
1790 // %%
1791 //---------------------------------------------------------------------
1792 test("%%", "%", (Object)null);
1793 test("%%", "%", "");
1794 tryCatch("%%%", UnknownFormatConversionException.class);
1795 // perhaps an IllegalFormatArgumentIndexException should be defined?
1796 tryCatch("%<%", IllegalFormatFlagsException.class);
1797 }
1798 }