• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /* Licensed to the Apache Software Foundation (ASF) under one or more
2  * contributor license agreements.  See the NOTICE file distributed with
3  * this work for additional information regarding copyright ownership.
4  * The ASF licenses this file to You under the Apache License, Version 2.0
5  * (the "License"); you may not use this file except in compliance with
6  * the License.  You may obtain a copy of the License at
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.apache.harmony.tests.java.util;
17 
18 import java.io.BufferedOutputStream;
19 import java.io.Closeable;
20 import java.io.File;
21 import java.io.FileNotFoundException;
22 import java.io.FileOutputStream;
23 import java.io.FilePermission;
24 import java.io.Flushable;
25 import java.io.IOException;
26 import java.io.OutputStream;
27 import java.io.PipedOutputStream;
28 import java.io.PrintStream;
29 import java.io.UnsupportedEncodingException;
30 import java.math.BigDecimal;
31 import java.math.BigInteger;
32 import java.math.MathContext;
33 import java.nio.charset.Charset;
34 import java.security.Permission;
35 import java.util.Arrays;
36 import java.util.Calendar;
37 import java.util.Date;
38 import java.util.GregorianCalendar;
39 import java.util.DuplicateFormatFlagsException;
40 import java.util.FormatFlagsConversionMismatchException;
41 import java.util.Formattable;
42 import java.util.FormattableFlags;
43 import java.util.Formatter;
44 import java.util.FormatterClosedException;
45 import java.util.IllegalFormatCodePointException;
46 import java.util.IllegalFormatConversionException;
47 import java.util.IllegalFormatException;
48 import java.util.IllegalFormatFlagsException;
49 import java.util.IllegalFormatPrecisionException;
50 import java.util.IllegalFormatWidthException;
51 import java.util.Locale;
52 import java.util.MissingFormatArgumentException;
53 import java.util.MissingFormatWidthException;
54 import java.util.TimeZone;
55 import java.util.UnknownFormatConversionException;
56 import java.util.Formatter.BigDecimalLayoutForm;
57 
58 import junit.framework.TestCase;
59 
60 @SuppressWarnings("FormatString")  // This test tests illegal format strings.
61 public class FormatterTest extends TestCase {
62     private boolean root;
63 
64     class MockAppendable implements Appendable {
append(CharSequence arg0)65         public Appendable append(CharSequence arg0) throws IOException {
66             return null;
67         }
68 
append(char arg0)69         public Appendable append(char arg0) throws IOException {
70             return null;
71         }
72 
append(CharSequence arg0, int arg1, int arg2)73         public Appendable append(CharSequence arg0, int arg1, int arg2)
74                 throws IOException {
75             return null;
76         }
77     }
78 
79     class MockFormattable implements Formattable {
formatTo(Formatter formatter, int flags, int width, int precision)80         public void formatTo(Formatter formatter, int flags, int width,
81                 int precision) throws IllegalFormatException {
82             if ((flags & FormattableFlags.UPPERCASE) != 0) {
83                 formatter.format("CUSTOMIZED FORMAT FUNCTION" + " WIDTH: "
84                         + width + " PRECISION: " + precision);
85             } else {
86                 formatter.format("customized format function" + " width: "
87                         + width + " precision: " + precision);
88             }
89         }
90 
toString()91         public String toString() {
92             return "formattable object";
93         }
94 
hashCode()95         public int hashCode() {
96             return 0xf;
97         }
98     }
99 
100     class MockDestination implements Appendable, Flushable {
101 
102         private StringBuilder data = new StringBuilder();
103 
104         private boolean enabled = false;
105 
append(char c)106         public Appendable append(char c) throws IOException {
107             if (enabled) {
108                 data.append(c);
109                 enabled = true; // enable it after the first append
110             } else {
111                 throw new IOException();
112             }
113             return this;
114         }
115 
append(CharSequence csq)116         public Appendable append(CharSequence csq) throws IOException {
117             if (enabled) {
118                 data.append(csq);
119                 enabled = true; // enable it after the first append
120             } else {
121                 throw new IOException();
122             }
123             return this;
124         }
125 
append(CharSequence csq, int start, int end)126         public Appendable append(CharSequence csq, int start, int end)
127                 throws IOException {
128             if (enabled) {
129                 data.append(csq, start, end);
130                 enabled = true; // enable it after the first append
131             } else {
132                 throw new IOException();
133             }
134             return this;
135         }
136 
flush()137         public void flush() throws IOException {
138             throw new IOException("Always throw IOException");
139         }
140 
toString()141         public String toString() {
142             return data.toString();
143         }
144     }
145 
146     private File notExist;
147 
148     private File fileWithContent;
149 
150     private File readOnly;
151 
152     private File secret;
153 
154     private TimeZone defaultTimeZone;
155 
156     private Locale defaultLocale;
157 
158     /**
159      * java.util.Formatter#Formatter()
160      */
test_Constructor()161     public void test_Constructor() {
162         Formatter f = new Formatter();
163         assertNotNull(f);
164         assertTrue(f.out() instanceof StringBuilder);
165         assertEquals(f.locale(), Locale.getDefault());
166         assertNotNull(f.toString());
167     }
168 
169     /**
170      * java.util.Formatter#Formatter(Appendable)
171      */
test_ConstructorLjava_lang_Appendable()172     public void test_ConstructorLjava_lang_Appendable() {
173         MockAppendable ma = new MockAppendable();
174         Formatter f1 = new Formatter(ma);
175         assertEquals(ma, f1.out());
176         assertEquals(f1.locale(), Locale.getDefault());
177         assertNotNull(f1.toString());
178 
179         Formatter f2 = new Formatter((Appendable) null);
180         /*
181          * If a(the input param) is null then a StringBuilder will be created
182          * and the output can be attained by invoking the out() method. But RI
183          * raises an error of FormatterClosedException when invoking out() or
184          * toString().
185          */
186         Appendable sb = f2.out();
187         assertTrue(sb instanceof StringBuilder);
188         assertNotNull(f2.toString());
189     }
190 
191     /**
192      * java.util.Formatter#Formatter(Locale)
193      */
test_ConstructorLjava_util_Locale()194     public void test_ConstructorLjava_util_Locale() {
195         Formatter f1 = new Formatter(Locale.FRANCE);
196         assertTrue(f1.out() instanceof StringBuilder);
197         assertEquals(f1.locale(), Locale.FRANCE);
198         assertNotNull(f1.toString());
199 
200         Formatter f2 = new Formatter((Locale) null);
201         assertNull(f2.locale());
202         assertTrue(f2.out() instanceof StringBuilder);
203         assertNotNull(f2.toString());
204     }
205 
206     /**
207      * java.util.Formatter#Formatter(Appendable, Locale)
208      */
test_ConstructorLjava_lang_AppendableLjava_util_Locale()209     public void test_ConstructorLjava_lang_AppendableLjava_util_Locale() {
210         MockAppendable ma = new MockAppendable();
211         Formatter f1 = new Formatter(ma, Locale.CANADA);
212         assertEquals(ma, f1.out());
213         assertEquals(f1.locale(), Locale.CANADA);
214 
215         Formatter f2 = new Formatter(ma, null);
216         assertNull(f2.locale());
217         assertEquals(ma, f1.out());
218 
219         Formatter f3 = new Formatter(null, Locale.GERMAN);
220         assertEquals(f3.locale(), Locale.GERMAN);
221         assertTrue(f3.out() instanceof StringBuilder);
222     }
223 
224     /**
225      * java.util.Formatter#Formatter(String)
226      */
test_ConstructorLjava_lang_String()227     public void test_ConstructorLjava_lang_String() throws IOException {
228         Formatter f = null;
229         try {
230             f = new Formatter((String) null);
231             fail("should throw NullPointerException");
232         } catch (NullPointerException e1) {
233             // expected
234         }
235 
236         f = new Formatter(notExist.getPath());
237         assertEquals(f.locale(), Locale.getDefault());
238         f.close();
239 
240         f = new Formatter(fileWithContent.getPath());
241         assertEquals(0, fileWithContent.length());
242         f.close();
243 
244         if (!root) {
245             try {
246                 f = new Formatter(readOnly.getPath());
247                 fail("should throw FileNotFoundException");
248             } catch (FileNotFoundException e) {
249                 // expected
250             }
251         }
252     }
253 
254     /**
255      * java.util.Formatter#Formatter(String, String)
256      */
test_ConstructorLjava_lang_StringLjava_lang_String()257     public void test_ConstructorLjava_lang_StringLjava_lang_String()
258             throws IOException {
259         Formatter f = null;
260         try {
261             f = new Formatter((String) null, Charset.defaultCharset().name());
262             fail("should throw NullPointerException");
263         } catch (NullPointerException e1) {
264             // expected
265         }
266 
267         try {
268             f = new Formatter(notExist.getPath(), null);
269             fail("should throw NullPointerException");
270         } catch (NullPointerException e2) {
271             // expected
272         }
273 
274         f = new Formatter(notExist.getPath(), Charset.defaultCharset().name());
275         assertEquals(f.locale(), Locale.getDefault());
276         f.close();
277 
278         try {
279             f = new Formatter(notExist.getPath(), "ISO 1111-1");
280             fail("should throw UnsupportedEncodingException");
281         } catch (UnsupportedEncodingException e1) {
282             // expected
283         }
284 
285         f = new Formatter(fileWithContent.getPath(), "UTF-16BE");
286         assertEquals(0, fileWithContent.length());
287         f.close();
288 
289         if (!root) {
290             try {
291                 f = new Formatter(readOnly.getPath(), "UTF-16BE");
292                 fail("should throw FileNotFoundException");
293             } catch (FileNotFoundException e) {
294                 // expected
295             }
296         }
297     }
298 
299     /**
300      * java.util.Formatter#Formatter(String, String, Locale)
301      */
test_ConstructorLjava_lang_StringLjava_lang_StringLjava_util_Locale()302     public void test_ConstructorLjava_lang_StringLjava_lang_StringLjava_util_Locale()
303             throws IOException {
304         Formatter f = null;
305         try {
306             f = new Formatter((String) null, Charset.defaultCharset().name(),
307                     Locale.KOREA);
308             fail("should throw NullPointerException");
309         } catch (NullPointerException e1) {
310             // expected
311         }
312 
313         try {
314             f = new Formatter(notExist.getPath(), (String) null, Locale.KOREA);
315             fail("should throw NullPointerException");
316         } catch (NullPointerException e2) {
317             // expected
318         }
319 
320         f = new Formatter(notExist.getPath(), Charset.defaultCharset().name(),
321                 null);
322         assertNotNull(f);
323         f.close();
324 
325         f = new Formatter(notExist.getPath(), Charset.defaultCharset().name(),
326                 Locale.KOREA);
327         assertEquals(f.locale(), Locale.KOREA);
328         f.close();
329 
330         try {
331             f = new Formatter(notExist.getPath(), "ISO 1111-1", Locale.CHINA);
332             fail("should throw UnsupportedEncodingException");
333         } catch (UnsupportedEncodingException e1) {
334             // expected
335         }
336 
337         f = new Formatter(fileWithContent.getPath(), "UTF-16BE",
338                 Locale.CANADA_FRENCH);
339         assertEquals(0, fileWithContent.length());
340         f.close();
341 
342         if (!root) {
343             try {
344                 f = new Formatter(readOnly.getPath(), Charset.defaultCharset()
345                         .name(), Locale.ITALY);
346                 fail("should throw FileNotFoundException");
347             } catch (FileNotFoundException e) {
348                 // expected
349             }
350         }
351     }
352 
353     /**
354      * java.util.Formatter#Formatter(File)
355      */
test_ConstructorLjava_io_File()356     public void test_ConstructorLjava_io_File() throws IOException {
357         Formatter f = null;
358         try {
359             f = new Formatter((File) null);
360             fail("should throw NullPointerException");
361         } catch (NullPointerException e1) {
362             // expected
363         }
364 
365         f = new Formatter(notExist);
366         assertEquals(f.locale(), Locale.getDefault());
367         f.close();
368 
369         f = new Formatter(fileWithContent);
370         assertEquals(0, fileWithContent.length());
371         f.close();
372 
373         if (!root) {
374             try {
375                 f = new Formatter(readOnly);
376                 fail("should throw FileNotFoundException");
377             } catch (FileNotFoundException e) {
378                 // expected
379             }
380         }
381     }
382 
383     /**
384      * java.util.Formatter#Formatter(File, String)
385      */
test_ConstructorLjava_io_FileLjava_lang_String()386     public void test_ConstructorLjava_io_FileLjava_lang_String()
387             throws IOException {
388         Formatter f = null;
389         try {
390             f = new Formatter((File) null, Charset.defaultCharset().name());
391             fail("should throw NullPointerException");
392         } catch (NullPointerException e1) {
393             // expected
394         }
395 
396         f = new Formatter(notExist, Charset.defaultCharset().name());
397         assertEquals(f.locale(), Locale.getDefault());
398         f.close();
399 
400         f = new Formatter(fileWithContent, "UTF-16BE");
401         assertEquals(0, fileWithContent.length());
402         f.close();
403 
404         if (!root) {
405             try {
406                 f = new Formatter(readOnly, Charset.defaultCharset().name());
407                 fail("should throw FileNotFoundException");
408             } catch (FileNotFoundException e) {
409                 // expected
410             }
411         }
412 
413         try {
414             f = new Formatter(notExist, null);
415             fail("should throw NullPointerException");
416         } catch (NullPointerException e2) {
417             // expected
418         } finally {
419             if (notExist.exists()) {
420                 // Fail on RI on Windows, because output stream is created and
421                 // not closed when exception thrown
422                 assertTrue(notExist.delete());
423             }
424         }
425 
426         try {
427             f = new Formatter(notExist, "ISO 1111-1");
428             fail("should throw UnsupportedEncodingException");
429         } catch (UnsupportedEncodingException e1) {
430             // expected
431         } finally {
432             if (notExist.exists()) {
433                 // Fail on RI on Windows, because output stream is created and
434                 // not closed when exception thrown
435                 assertTrue(notExist.delete());
436             }
437         }
438     }
439 
440     /**
441      * java.util.Formatter#Formatter(File, String, Locale)
442      */
test_ConstructorLjava_io_FileLjava_lang_StringLjava_util_Locale()443     public void test_ConstructorLjava_io_FileLjava_lang_StringLjava_util_Locale()
444             throws IOException {
445         Formatter f = null;
446         try {
447             f = new Formatter((File) null, Charset.defaultCharset().name(),
448                     Locale.KOREA);
449             fail("should throw NullPointerException");
450         } catch (NullPointerException e1) {
451             // expected
452         }
453 
454         try {
455             f = new Formatter(notExist, (String) null, Locale.KOREA);
456             fail("should throw NullPointerException");
457         } catch (NullPointerException e2) {
458             // expected
459         }
460 
461         f = new Formatter(notExist, Charset.defaultCharset().name(), null);
462         assertNotNull(f);
463         f.close();
464 
465         f = new Formatter(notExist, Charset.defaultCharset().name(),
466                 Locale.KOREA);
467         assertEquals(f.locale(), Locale.KOREA);
468         f.close();
469 
470         try {
471             f = new Formatter(notExist, "ISO 1111-1", Locale.CHINA);
472             fail("should throw UnsupportedEncodingException");
473         } catch (UnsupportedEncodingException e1) {
474             // expected
475         }
476         f = new Formatter(fileWithContent.getPath(), "UTF-16BE",
477                 Locale.CANADA_FRENCH);
478         assertEquals(0, fileWithContent.length());
479         f.close();
480 
481         if (!root) {
482             try {
483                 f = new Formatter(readOnly.getPath(), Charset.defaultCharset()
484                         .name(), Locale.ITALY);
485                 fail("should throw FileNotFoundException");
486             } catch (FileNotFoundException e) {
487                 // expected
488             }
489         }
490     }
491 
492     /**
493      * java.util.Formatter#Formatter(PrintStream)
494      */
test_ConstructorLjava_io_PrintStream()495     public void test_ConstructorLjava_io_PrintStream() throws IOException {
496         Formatter f = null;
497         try {
498             f = new Formatter((PrintStream) null);
499             fail("should throw NullPointerException");
500         } catch (NullPointerException e1) {
501             // expected
502         }
503 
504         PrintStream ps = new PrintStream(notExist, "UTF-16BE");
505         f = new Formatter(ps);
506         assertEquals(Locale.getDefault(), f.locale());
507         f.close();
508     }
509 
510     /**
511      * java.util.Formatter#Formatter(OutputStream)
512      */
test_ConstructorLjava_io_OutputStream()513     public void test_ConstructorLjava_io_OutputStream() throws IOException {
514         Formatter f = null;
515         try {
516             f = new Formatter((OutputStream) null);
517             fail("should throw NullPointerException");
518         } catch (NullPointerException e1) {
519             // expected
520         }
521 
522         OutputStream os = new FileOutputStream(notExist);
523         f = new Formatter(os);
524         assertEquals(Locale.getDefault(), f.locale());
525         f.close();
526     }
527 
528     /**
529      * java.util.Formatter#Formatter(OutputStream, String)
530      */
test_ConstructorLjava_io_OutputStreamLjava_lang_String()531     public void test_ConstructorLjava_io_OutputStreamLjava_lang_String()
532             throws IOException {
533         Formatter f = null;
534         try {
535             f = new Formatter((OutputStream) null, Charset.defaultCharset()
536                     .name());
537             fail("should throw NullPointerException");
538         } catch (NullPointerException e1) {
539             // expected
540         }
541 
542         OutputStream os = null;
543         try {
544             os = new FileOutputStream(notExist);
545             f = new Formatter(os, null);
546             fail("should throw NullPointerException");
547         } catch (NullPointerException e2) {
548             // expected
549         } finally {
550             os.close();
551         }
552 
553         try {
554             os = new PipedOutputStream();
555             f = new Formatter(os, "TMP-1111");
556             fail("should throw UnsupportedEncodingException");
557         } catch (UnsupportedEncodingException e1) {
558             // expected
559         } finally {
560             os.close();
561         }
562 
563         os = new FileOutputStream(fileWithContent);
564         f = new Formatter(os, "UTF-16BE");
565         assertEquals(Locale.getDefault(), f.locale());
566         f.close();
567     }
568 
569     /**
570      * Test method for 'java.util.Formatter.Formatter(OutputStream, String,
571      * Locale)
572      */
test_ConstructorLjava_io_OutputStreamLjava_lang_StringLjava_util_Locale()573     public void test_ConstructorLjava_io_OutputStreamLjava_lang_StringLjava_util_Locale()
574             throws IOException {
575         Formatter f = null;
576         try {
577             f = new Formatter((OutputStream) null, Charset.defaultCharset()
578                     .name(), Locale.getDefault());
579             fail("should throw NullPointerException");
580         } catch (NullPointerException e1) {
581             // expected
582         }
583 
584         OutputStream os = null;
585         try {
586             os = new FileOutputStream(notExist);
587             f = new Formatter(os, (String) null, Locale.getDefault());
588             fail("should throw NullPointerException");
589         } catch (NullPointerException e2) {
590             // expected
591         } finally {
592             os.close();
593         }
594 
595         os = new FileOutputStream(notExist);
596         f = new Formatter(os, Charset.defaultCharset().name(), null);
597         f.close();
598 
599         try {
600             os = new PipedOutputStream();
601             f = new Formatter(os, "TMP-1111", Locale.getDefault());
602             fail("should throw UnsupportedEncodingException");
603         } catch (UnsupportedEncodingException e1) {
604             // expected
605         }
606 
607         os = new FileOutputStream(fileWithContent);
608         f = new Formatter(os, "UTF-16BE", Locale.ENGLISH);
609         assertEquals(Locale.ENGLISH, f.locale());
610         f.close();
611     }
612 
613     /**
614      * java.util.Formatter#locale()
615      */
test_locale()616     public void test_locale() {
617         Formatter f = null;
618         f = new Formatter((Locale) null);
619         assertNull(f.locale());
620 
621         f.close();
622         try {
623             f.locale();
624             fail("should throw FormatterClosedException");
625         } catch (FormatterClosedException e) {
626             // expected
627         }
628     }
629 
630     /**
631      * java.util.Formatter#out()
632      */
test_out()633     public void test_out() {
634         Formatter f = null;
635         f = new Formatter();
636         assertNotNull(f.out());
637         assertTrue(f.out() instanceof StringBuilder);
638         f.close();
639         try {
640             f.out();
641             fail("should throw FormatterClosedException");
642         } catch (FormatterClosedException e) {
643             // expected
644         }
645 
646     }
647 
648     /**
649      * java.util.Formatter#flush()
650      */
test_flush()651     public void test_flush() throws IOException {
652         Formatter f = null;
653         f = new Formatter(notExist);
654         assertTrue(f instanceof Flushable);
655         f.close();
656         try {
657             f.flush();
658             fail("should throw FormatterClosedException");
659         } catch (FormatterClosedException e) {
660             // expected
661         }
662 
663         f = new Formatter();
664         // For destination that does not implement Flushable
665         // No exception should be thrown
666         f.flush();
667     }
668 
669     /**
670      * java.util.Formatter#close()
671      */
test_close()672     public void test_close() throws IOException {
673         Formatter f = new Formatter(notExist);
674         assertTrue(f instanceof Closeable);
675         f.close();
676         // close next time will not throw exception
677         f.close();
678         assertNull(f.ioException());
679     }
680 
681     /**
682      * java.util.Formatter#toString()
683      */
test_toString()684     public void test_toString() {
685         Formatter f = new Formatter();
686         assertNotNull(f.toString());
687         assertEquals(f.out().toString(), f.toString());
688         f.close();
689         try {
690             f.toString();
691             fail("should throw FormatterClosedException");
692         } catch (FormatterClosedException e) {
693             // expected
694         }
695     }
696 
697     /**
698      * java.util.Formatter#ioException()
699      */
test_ioException()700     public void test_ioException() throws IOException {
701         Formatter f = null;
702         f = new Formatter(new MockDestination());
703         assertNull(f.ioException());
704         f.flush();
705         assertNotNull(f.ioException());
706         f.close();
707 
708         MockDestination md = new MockDestination();
709         f = new Formatter(md);
710         f.format("%s%s", "1", "2");
711         // format stop working after IOException
712         assertNotNull(f.ioException());
713         assertEquals("", f.toString());
714     }
715 
716     /**
717      * java.util.Formatter#format(String, Object...) for null parameter
718      */
test_formatLjava_lang_String$Ljava_lang_Object_null()719     public void test_formatLjava_lang_String$Ljava_lang_Object_null() {
720         Formatter f = new Formatter();
721         try {
722             f.format((String) null, "parameter");
723             fail("should throw NullPointerException");
724         } catch (NullPointerException e) {
725             // expected
726         }
727 
728         f = new Formatter();
729         f.format("hello", (Object[]) null);
730         assertEquals("hello", f.toString());
731     }
732 
733     /**
734      * java.util.Formatter#format(String, Object...) for argument index
735      */
test_formatLjava_lang_String$Ljava_lang_Object_ArgIndex()736     public void test_formatLjava_lang_String$Ljava_lang_Object_ArgIndex() {
737         Formatter formatter = new Formatter(Locale.US);
738         formatter.format("%1$s%2$s%3$s%4$s%5$s%6$s%7$s%8$s%9$s%11$s%10$s", "1",
739                 "2", "3", "4", "5", "6", "7", "8", "9", "10", "11");
740         assertEquals("1234567891110", formatter.toString());
741 
742         formatter = new Formatter(Locale.JAPAN);
743         formatter.format("%0$s", "hello");
744         assertEquals("hello", formatter.toString());
745 
746         try {
747             formatter = new Formatter(Locale.US);
748             formatter.format("%-1$s", "1", "2");
749             fail("should throw UnknownFormatConversionException");
750         } catch (UnknownFormatConversionException e) {
751             // expected
752         }
753 
754         try {
755             formatter = new Formatter(Locale.US);
756             formatter.format("%$s", "hello", "2");
757             fail("should throw UnknownFormatConversionException");
758         } catch (UnknownFormatConversionException e) {
759             // expected
760         }
761 
762         try {
763             Formatter f = new Formatter(Locale.US);
764             f.format("%", "string");
765             fail("should throw UnknownFormatConversionException");
766         } catch (UnknownFormatConversionException e) {
767             // expected
768         }
769 
770         formatter = new Formatter(Locale.FRANCE);
771         formatter.format("%1$s%2$s%3$s%4$s%5$s%6$s%7$s%8$s%<s%s%s%<s", "1",
772                 "2", "3", "4", "5", "6", "7", "8", "9", "10", "11");
773         assertEquals("123456788122", formatter.toString());
774 
775         formatter = new Formatter(Locale.FRANCE);
776         formatter.format(
777                 "xx%1$s22%2$s%s%<s%5$s%<s&%7$h%2$s%8$s%<s%s%s%<ssuffix", "1",
778                 "2", "3", "4", "5", "6", 7, "8", "9", "10", "11");
779         assertEquals("xx12221155&7288233suffix", formatter.toString());
780 
781         try {
782             formatter.format("%<s", "hello");
783             fail("should throw MissingFormatArgumentException");
784         } catch (MissingFormatArgumentException e) {
785             // expected
786         }
787 
788         formatter = new Formatter(Locale.US);
789         try {
790             formatter.format("%123$s", "hello");
791             fail("should throw MissingFormatArgumentException");
792         } catch (MissingFormatArgumentException e) {
793             // expected
794         }
795 
796         formatter = new Formatter(Locale.US);
797         try {
798             // 2147483648 is the value of Integer.MAX_VALUE + 1
799             formatter.format("%2147483648$s", "hello");
800             fail("should throw MissingFormatArgumentException");
801         } catch (MissingFormatArgumentException e) {
802             // expected
803         }
804 
805         try {
806             // 2147483647 is the value of Integer.MAX_VALUE
807             formatter.format("%2147483647$s", "hello");
808             fail("should throw MissingFormatArgumentException");
809         } catch (MissingFormatArgumentException e) {
810             // expected
811         }
812 
813         formatter = new Formatter(Locale.US);
814         try {
815             formatter.format("%s%s", "hello");
816             fail("should throw MissingFormatArgumentException");
817         } catch (MissingFormatArgumentException e) {
818             // expected
819         }
820 
821         formatter = new Formatter(Locale.US);
822         formatter.format("$100", 100);
823         assertEquals("$100", formatter.toString());
824 
825         formatter = new Formatter(Locale.UK);
826         formatter.format("%01$s", "string");
827         assertEquals("string", formatter.toString());
828     }
829 
830     /**
831      * java.util.Formatter#format(String, Object...) for width
832      */
test_formatLjava_lang_String$Ljava_lang_Object_Width()833     public void test_formatLjava_lang_String$Ljava_lang_Object_Width() {
834         Formatter f = new Formatter(Locale.US);
835         f.format("%1$8s", "1");
836         assertEquals("       1", f.toString());
837 
838         f = new Formatter(Locale.US);
839         f.format("%1$-1%", "string");
840         assertEquals("%", f.toString());
841 
842         f = new Formatter(Locale.ITALY);
843         // 2147483648 is the value of Integer.MAX_VALUE + 1
844         f.format("%2147483648s", "string");
845         assertEquals("string", f.toString());
846 
847         // the value of Integer.MAX_VALUE will allocate about 4G bytes of
848         // memory.
849         // It may cause OutOfMemoryError, so this value is not tested
850     }
851 
852     /**
853      * java.util.Formatter#format(String, Object...) for precision
854      */
test_formatLjava_lang_String$Ljava_lang_Object_Precision()855     public void test_formatLjava_lang_String$Ljava_lang_Object_Precision() {
856         Formatter f = new Formatter(Locale.US);
857         f.format("%.5s", "123456");
858         assertEquals("12345", f.toString());
859 
860         f = new Formatter(Locale.US);
861         // 2147483648 is the value of Integer.MAX_VALUE + 1
862         f.format("%.2147483648s", "...");
863         assertEquals("...", f.toString());
864 
865         // the value of Integer.MAX_VALUE will allocate about 4G bytes of
866         // memory.
867         // It may cause OutOfMemoryError, so this value is not tested
868 
869         f = new Formatter(Locale.US);
870         f.format("%10.0b", Boolean.TRUE);
871         assertEquals("          ", f.toString());
872 
873         f = new Formatter(Locale.US);
874         f.format("%10.01s", "hello");
875         assertEquals("         h", f.toString());
876 
877         try {
878             f = new Formatter(Locale.US);
879             f.format("%.s", "hello", "2");
880             fail("should throw Exception");
881         } catch (UnknownFormatConversionException
882                  | IllegalFormatPrecisionException expected) {
883             // expected
884         }
885 
886         try {
887             f = new Formatter(Locale.US);
888             f.format("%.-5s", "123456");
889             fail("should throw Exception");
890         } catch (UnknownFormatConversionException
891                  | IllegalFormatPrecisionException expected) {
892             // expected
893         }
894 
895         try {
896             f = new Formatter(Locale.US);
897             f.format("%1.s", "hello", "2");
898             fail("should throw Exception");
899         } catch (UnknownFormatConversionException
900                  | IllegalFormatPrecisionException expected) {
901             // expected
902         }
903 
904         f = new Formatter(Locale.US);
905         f.format("%5.1s", "hello");
906         assertEquals("    h", f.toString());
907 
908         f = new Formatter(Locale.FRANCE);
909         f.format("%.0s", "hello", "2");
910         assertEquals("", f.toString());
911     }
912 
913     /**
914      * java.util.Formatter#format(String, Object...) for line sperator
915      */
test_formatLjava_lang_String$Ljava_lang_Object_LineSeparator()916     public void test_formatLjava_lang_String$Ljava_lang_Object_LineSeparator() {
917         Formatter f = null;
918 
919         String oldSeparator = System.getProperty("line.separator");
920         try {
921             System.setProperty("line.separator", "!\n");
922 
923             f = new Formatter(Locale.US);
924             f.format("%1$n", 1);
925             assertEquals("!\n", f.toString());
926 
927             f = new Formatter(Locale.KOREAN);
928             f.format("head%1$n%2$n", 1, new Date());
929             assertEquals("head!\n!\n", f.toString());
930 
931             f = new Formatter(Locale.US);
932             f.format("%n%s", "hello");
933             assertEquals("!\nhello", f.toString());
934         } finally {
935             System.setProperty("line.separator", oldSeparator);
936         }
937 
938         f = new Formatter(Locale.US);
939         try {
940             f.format("%-n");
941             fail("should throw IllegalFormatFlagsException: %-n");
942         } catch (IllegalFormatFlagsException e) {
943             // expected
944         }
945         try {
946             f.format("%+n");
947             fail("should throw IllegalFormatFlagsException: %+n");
948         } catch (IllegalFormatFlagsException e) {
949             // expected
950         }
951         try {
952             f.format("%#n");
953             fail("should throw IllegalFormatFlagsException: %#n");
954         } catch (IllegalFormatFlagsException e) {
955             // expected
956         }
957         try {
958             f.format("% n");
959             fail("should throw IllegalFormatFlagsException: % n");
960         } catch (IllegalFormatFlagsException e) {
961             // expected
962         }
963         try {
964             f.format("%0n");
965             fail("should throw IllegalFormatFlagsException: %0n");
966         } catch (IllegalFormatFlagsException e) {
967             // expected
968         }
969         try {
970             f.format("%,n");
971             fail("should throw IllegalFormatFlagsException: %,n");
972         } catch (IllegalFormatFlagsException e) {
973             // expected
974         }
975         try {
976             f.format("%(n");
977             fail("should throw IllegalFormatFlagsException: %(n");
978         } catch (IllegalFormatFlagsException e) {
979             // expected
980         }
981 
982         f = new Formatter(Locale.US);
983         try {
984             f.format("%4n");
985             fail("should throw IllegalFormatWidthException");
986         } catch (IllegalFormatWidthException e) {
987             // expected
988         }
989 
990         f = new Formatter(Locale.US);
991         try {
992             f.format("%-4n");
993             fail("should throw IllegalFormatWidthException");
994         } catch (IllegalFormatWidthException e) {
995             // expected
996         }
997 
998         f = new Formatter(Locale.US);
999         try {
1000             f.format("%.9n");
1001             fail("should throw IllegalFormatPrecisionException");
1002         } catch (IllegalFormatPrecisionException e) {
1003             // expected
1004         }
1005 
1006         f = new Formatter(Locale.US);
1007         try {
1008             f.format("%5.9n");
1009             fail("should throw IllegalFormatPrecisionException");
1010         } catch (IllegalFormatPrecisionException e) {
1011             // expected
1012         }
1013 
1014         System.setProperty("line.separator", oldSeparator);
1015     }
1016 
1017     /**
1018      * java.util.Formatter#format(String, Object...) for percent
1019      */
test_formatLjava_lang_String$Ljava_lang_Object_Percent()1020     public void test_formatLjava_lang_String$Ljava_lang_Object_Percent() {
1021         Formatter f = null;
1022 
1023         f = new Formatter(Locale.ENGLISH);
1024         f.format("%1$%", 100);
1025         assertEquals("%", f.toString());
1026 
1027         f = new Formatter(Locale.CHINA);
1028         f.format("%1$%%%", "hello", new Object());
1029         assertEquals("%%", f.toString());
1030 
1031         f = new Formatter(Locale.CHINA);
1032         f.format("%%%s", "hello");
1033         assertEquals("%hello", f.toString());
1034 
1035         f = new Formatter(Locale.US);
1036         try {
1037             f.format("%.9%");
1038             fail("should throw IllegalFormatPrecisionException");
1039         } catch (IllegalFormatPrecisionException e) {
1040             // expected
1041         }
1042 
1043         f = new Formatter(Locale.US);
1044         try {
1045             f.format("%5.9%");
1046             fail("should throw IllegalFormatPrecisionException");
1047         } catch (IllegalFormatPrecisionException e) {
1048             // expected
1049         }
1050 
1051         f = new Formatter(Locale.US);
1052         assertFormatFlagsConversionMismatchException(f, "%+%");
1053         assertFormatFlagsConversionMismatchException(f, "%#%");
1054         assertFormatFlagsConversionMismatchException(f, "% %");
1055         assertFormatFlagsConversionMismatchException(f, "%0%");
1056         assertFormatFlagsConversionMismatchException(f, "%,%");
1057         assertFormatFlagsConversionMismatchException(f, "%(%");
1058 
1059 
1060         f = new Formatter(Locale.KOREAN);
1061         f.format("%4%", 1);
1062         /*
1063          * fail on RI the output string should be right justified by appending
1064          * spaces till the whole string is 4 chars width.
1065          */
1066         assertEquals("   %", f.toString());
1067 
1068         f = new Formatter(Locale.US);
1069         f.format("%-4%", 100);
1070         /*
1071          * fail on RI, throw UnknownFormatConversionException the output string
1072          * should be left justified by appending spaces till the whole string is
1073          * 4 chars width.
1074          */
1075         assertEquals("%   ", f.toString());
1076     }
1077 
assertFormatFlagsConversionMismatchException(Formatter f, String str)1078     private void assertFormatFlagsConversionMismatchException(Formatter f, String str) {
1079         try {
1080             f.format(str);
1081             fail("should throw FormatFlagsConversionMismatchException: "
1082                     + str);
1083             /*
1084             * error on RI, throw IllegalFormatFlagsException specification
1085             * says FormatFlagsConversionMismatchException should be thrown
1086             */
1087         } catch (FormatFlagsConversionMismatchException e) {
1088             // expected
1089         }
1090     }
1091 
1092     /**
1093      * java.util.Formatter#format(String, Object...) for flag
1094      */
test_formatLjava_lang_String$Ljava_lang_Object_Flag()1095     public void test_formatLjava_lang_String$Ljava_lang_Object_Flag() {
1096         Formatter f = new Formatter(Locale.US);
1097         try {
1098             f.format("%1$-#-8s", "something");
1099             fail("should throw DuplicateFormatFlagsException");
1100         } catch (DuplicateFormatFlagsException e) {
1101             // expected
1102         }
1103 
1104         final char[] chars = { '-', '#', '+', ' ', '0', ',', '(', '%', '<' };
1105         Arrays.sort(chars);
1106         f = new Formatter(Locale.US);
1107         for (char i = 0; i <= 256; i++) {
1108             // test 8 bit character
1109             if (Arrays.binarySearch(chars, i) >= 0 || Character.isDigit(i)
1110                     || Character.isLetter(i)) {
1111                 // Do not test 0-9, a-z, A-Z and characters in the chars array.
1112                 // They are characters used as flags, width or conversions
1113                 continue;
1114             }
1115             try {
1116                 f.format("%" + i + "s", 1);
1117                 fail("should throw UnknownFormatConversionException");
1118             } catch (UnknownFormatConversionException e) {
1119                 // expected
1120             } catch (IllegalFormatPrecisionException e) {
1121                 // If i is '.', s can also be interpreted as an illegal precision.
1122                 if (i != '.') {
1123                     throw e;
1124                 }
1125             }
1126         }
1127     }
1128 
1129     /**
1130      * java.util.Formatter#format(String, Object...) for general
1131      * conversion b/B
1132      */
test_format_LString$LObject_GeneralConversionB()1133     public void test_format_LString$LObject_GeneralConversionB() {
1134         final Object[][] triple = {
1135                 { Boolean.FALSE, "%3.2b", " fa", },
1136                 { Boolean.FALSE, "%-4.6b", "false", },
1137                 { Boolean.FALSE, "%.2b", "fa", },
1138                 { Boolean.TRUE, "%3.2b", " tr", },
1139                 { Boolean.TRUE, "%-4.6b", "true", },
1140                 { Boolean.TRUE, "%.2b", "tr", },
1141                 { Character.valueOf('c'), "%3.2b", " tr", },
1142                 { Character.valueOf('c'), "%-4.6b", "true", },
1143                 { Character.valueOf('c'), "%.2b", "tr", },
1144                 { Byte.valueOf((byte) 0x01), "%3.2b", " tr", },
1145                 { Byte.valueOf((byte) 0x01), "%-4.6b", "true", },
1146                 { Byte.valueOf((byte) 0x01), "%.2b", "tr", },
1147                 { Short.valueOf((short) 0x0001), "%3.2b", " tr", },
1148                 { Short.valueOf((short) 0x0001), "%-4.6b", "true", },
1149                 { Short.valueOf((short) 0x0001), "%.2b", "tr", },
1150                 { Integer.valueOf(1), "%3.2b", " tr", },
1151                 { Integer.valueOf(1), "%-4.6b", "true", },
1152                 { Integer.valueOf(1), "%.2b", "tr", },
1153                 { Float.valueOf(1.1f), "%3.2b", " tr", },
1154                 { Float.valueOf(1.1f), "%-4.6b", "true", },
1155                 { Float.valueOf(1.1f), "%.2b", "tr", },
1156                 { Double.valueOf(1.1d), "%3.2b", " tr", },
1157                 { Double.valueOf(1.1d), "%-4.6b", "true", },
1158                 { Double.valueOf(1.1d), "%.2b", "tr", },
1159                 { "", "%3.2b", " tr", },
1160                 { "", "%-4.6b", "true", },
1161                 { "", "%.2b", "tr", },
1162                 { "string content", "%3.2b", " tr", },
1163                 { "string content", "%-4.6b", "true", },
1164                 { "string content", "%.2b", "tr", },
1165                 { new MockFormattable(), "%3.2b", " tr", },
1166                 { new MockFormattable(), "%-4.6b", "true", },
1167                 { new MockFormattable(), "%.2b", "tr", },
1168                 { (Object) null, "%3.2b", " fa", },
1169                 { (Object) null, "%-4.6b", "false", },
1170                 { (Object) null, "%.2b", "fa", },
1171         };
1172 
1173 
1174         final int input = 0;
1175         final int pattern = 1;
1176         final int output = 2;
1177         Formatter f = null;
1178         for (int i = 0; i < triple.length; i++) {
1179             f = new Formatter(Locale.FRANCE);
1180             f.format((String) triple[i][pattern], triple[i][input]);
1181             assertEquals("triple[" + i + "]:" + triple[i][input]
1182                     + ",pattern[" + i + "]:" + triple[i][pattern], triple[i][output], f.toString());
1183 
1184             f = new Formatter(Locale.GERMAN);
1185             f.format(((String) triple[i][pattern]).toUpperCase(Locale.US), triple[i][input]);
1186             assertEquals("triple[" + i + "]:" + triple[i][input]
1187                     + ",pattern[" + i + "]:" + triple[i][pattern], ((String) triple[i][output])
1188                     .toUpperCase(Locale.US), f.toString());
1189         }
1190     }
1191 
1192     /**
1193      * java.util.Formatter#format(String, Object...) for general
1194      * conversion type 's' and 'S'
1195      */
test_format_LString$LObject_GeneralConversionS()1196     public void test_format_LString$LObject_GeneralConversionS() {
1197 
1198         final Object[][] triple = {
1199                 { Boolean.FALSE, "%2.3s", "fal", },
1200                 { Boolean.FALSE, "%-6.4s", "fals  ", },
1201                 { Boolean.FALSE, "%.5s", "false", },
1202                 { Boolean.TRUE, "%2.3s", "tru", },
1203                 { Boolean.TRUE, "%-6.4s", "true  ", },
1204                 { Boolean.TRUE, "%.5s", "true", },
1205                 { Character.valueOf('c'), "%2.3s", " c", },
1206                 { Character.valueOf('c'), "%-6.4s", "c     ", },
1207                 { Character.valueOf('c'), "%.5s", "c", },
1208                 { Byte.valueOf((byte) 0x01), "%2.3s", " 1", },
1209                 { Byte.valueOf((byte) 0x01), "%-6.4s", "1     ", },
1210                 { Byte.valueOf((byte) 0x01), "%.5s", "1", },
1211                 { Short.valueOf((short) 0x0001), "%2.3s", " 1", },
1212                 { Short.valueOf((short) 0x0001), "%-6.4s", "1     ", },
1213                 { Short.valueOf((short) 0x0001), "%.5s", "1", },
1214                 { Integer.valueOf(1), "%2.3s", " 1", },
1215                 { Integer.valueOf(1), "%-6.4s", "1     ", },
1216                 { Integer.valueOf(1), "%.5s", "1", },
1217                 { Float.valueOf(1.1f), "%2.3s", "1.1", },
1218                 { Float.valueOf(1.1f), "%-6.4s", "1.1   ", },
1219                 { Float.valueOf(1.1f), "%.5s", "1.1", },
1220                 { Double.valueOf(1.1d), "%2.3s", "1.1", },
1221                 { Double.valueOf(1.1d), "%-6.4s", "1.1   ", },
1222                 { Double.valueOf(1.1d), "%.5s", "1.1", },
1223                 { "", "%2.3s", "  ", },
1224                 { "", "%-6.4s", "      ", },
1225                 { "", "%.5s", "", },
1226                 { "string content", "%2.3s", "str", },
1227                 { "string content", "%-6.4s", "stri  ", },
1228                 { "string content", "%.5s", "strin", },
1229                 { new MockFormattable(), "%2.3s", "customized format function width: 2 precision: 3", },
1230                 { new MockFormattable(), "%-6.4s", "customized format function width: 6 precision: 4", },
1231                 { new MockFormattable(), "%.5s", "customized format function width: -1 precision: 5", },
1232                 { (Object) null, "%2.3s", "nul", },
1233                 { (Object) null, "%-6.4s", "null  ", },
1234                 { (Object) null, "%.5s", "null", },
1235         };
1236 
1237 
1238         final int input = 0;
1239         final int pattern = 1;
1240         final int output = 2;
1241         Formatter f = null;
1242         for (int i = 0; i < triple.length; i++) {
1243             f = new Formatter(Locale.FRANCE);
1244             f.format((String) triple[i][pattern], triple[i][input]);
1245             assertEquals("triple[" + i + "]:" + triple[i][input]
1246                     + ",pattern[" + i + "]:" + triple[i][pattern], triple[i][output], f.toString());
1247 
1248             f = new Formatter(Locale.GERMAN);
1249             f.format(((String) triple[i][pattern]).toUpperCase(Locale.US), triple[i][input]);
1250             assertEquals("triple[" + i + "]:" + triple[i][input]
1251                     + ",pattern[" + i + "]:" + triple[i][pattern], ((String) triple[i][output])
1252                     .toUpperCase(Locale.US), f.toString());
1253         }
1254     }
1255 
1256     /**
1257      * java.util.Formatter#format(String, Object...) for general
1258      * conversion type 'h' and 'H'
1259      */
test_format_LString$LObject_GeneralConversionH()1260     public void test_format_LString$LObject_GeneralConversionH() {
1261 
1262         final Object[] input = {
1263                 Boolean.FALSE,
1264                 Boolean.TRUE,
1265                 Character.valueOf('c'),
1266                 Byte.valueOf((byte) 0x01),
1267                 Short.valueOf((short) 0x0001),
1268                 Integer.valueOf(1),
1269                 Float.valueOf(1.1f),
1270                 Double.valueOf(1.1d),
1271                 "",
1272                 "string content",
1273                 new MockFormattable(),
1274                 (Object) null,
1275         };
1276 
1277         Formatter f = null;
1278         for (int i = 0; i < input.length - 1; i++) {
1279             f = new Formatter(Locale.FRANCE);
1280             f.format("%h", input[i]);
1281             assertEquals("triple[" + i + "]:" + input[i],
1282                     Integer.toHexString(input[i].hashCode()), f.toString());
1283 
1284             f = new Formatter(Locale.GERMAN);
1285             f.format("%H", input[i]);
1286             assertEquals("triple[" + i + "]:" + input[i],
1287                     Integer.toHexString(input[i].hashCode()).toUpperCase(Locale.US), f.toString());
1288         }
1289     }
1290 
1291     /**
1292      * java.util.Formatter#format(String, Object...) for general
1293      * conversion other cases
1294      */
test_formatLjava_lang_String$Ljava_lang_Object_GeneralConversionOther()1295     public void test_formatLjava_lang_String$Ljava_lang_Object_GeneralConversionOther() {
1296         /*
1297          * In Turkish locale, the upper case of '\u0069' is '\u0130'. The
1298          * following test indicate that '\u0069' is coverted to upper case
1299          * without using the turkish locale.
1300          */
1301         Formatter f = new Formatter(new Locale("tr"));
1302         f.format("%S", "\u0069");
1303         assertEquals("\u0049", f.toString());
1304 
1305         final Object[] input = {
1306                 Boolean.FALSE,
1307                 Boolean.TRUE,
1308                 Character.valueOf('c'),
1309                 Byte.valueOf((byte) 0x01),
1310                 Short.valueOf((short) 0x0001),
1311                 Integer.valueOf(1),
1312                 Float.valueOf(1.1f),
1313                 Double.valueOf(1.1d),
1314                 "",
1315                 "string content",
1316                 new MockFormattable(),
1317                 (Object) null,
1318         };
1319         f = new Formatter(Locale.GERMAN);
1320         for (int i = 0; i < input.length; i++) {
1321             if (!(input[i] instanceof Formattable)) {
1322                 try {
1323                     f.format("%#s", input[i]);
1324                     /*
1325                      * fail on RI, spec says if the '#' flag is present and the
1326                      * argument is not a Formattable , then a
1327                      * FormatFlagsConversionMismatchException will be thrown.
1328                      */
1329                     fail("should throw FormatFlagsConversionMismatchException");
1330                 } catch (FormatFlagsConversionMismatchException e) {
1331                     // expected
1332                 }
1333             } else {
1334                 f.format("%#s%<-#8s", input[i]);
1335                 assertEquals(
1336                         "customized format function width: -1 precision: -1customized format function width: 8 precision: -1",
1337                         f.toString());
1338             }
1339         }
1340     }
1341 
1342     /**
1343      * java.util.Formatter#format(String, Object...) for general
1344      * conversion exception
1345      */
test_formatLjava_lang_String$Ljava_lang_Object_GeneralConversionException()1346     public void test_formatLjava_lang_String$Ljava_lang_Object_GeneralConversionException() {
1347         final String[] flagMismatch = { "%#b", "%+b", "% b", "%0b", "%,b",
1348                 "%(b", "%#B", "%+B", "% B", "%0B", "%,B", "%(B", "%#h", "%+h",
1349                 "% h", "%0h", "%,h", "%(h", "%#H", "%+H", "% H", "%0H", "%,H",
1350                 "%(H", "%+s", "% s", "%0s", "%,s", "%(s", "%+S", "% S", "%0S",
1351                 "%,S", "%(S" };
1352 
1353         Formatter f = new Formatter(Locale.US);
1354 
1355         for (int i = 0; i < flagMismatch.length; i++) {
1356             try {
1357                 f.format(flagMismatch[i], "something");
1358                 fail("should throw FormatFlagsConversionMismatchException");
1359             } catch (FormatFlagsConversionMismatchException e) {
1360                 // expected
1361             }
1362         }
1363 
1364         final String[] missingWidth = { "%-b", "%-B", "%-h", "%-H", "%-s",
1365                 "%-S", };
1366         for (int i = 0; i < missingWidth.length; i++) {
1367             try {
1368                 f.format(missingWidth[i], "something");
1369                 fail("should throw MissingFormatWidthException");
1370             } catch (MissingFormatWidthException e) {
1371                 // expected
1372             }
1373         }
1374 
1375         // Regression test
1376         f = new Formatter();
1377         try {
1378             f.format("%c", (byte) -0x0001);
1379             fail("Should throw IllegalFormatCodePointException");
1380         } catch (IllegalFormatCodePointException e) {
1381             // expected
1382         }
1383 
1384         f = new Formatter();
1385         try {
1386             f.format("%c", (short) -0x0001);
1387             fail("Should throw IllegalFormatCodePointException");
1388         } catch (IllegalFormatCodePointException e) {
1389             // expected
1390         }
1391 
1392         f = new Formatter();
1393         try {
1394             f.format("%c", -0x0001);
1395             fail("Should throw IllegalFormatCodePointException");
1396         } catch (IllegalFormatCodePointException e) {
1397             // expected
1398         }
1399     }
1400 
1401     /**
1402      * java.util.Formatter#format(String, Object...) for Character
1403      * conversion
1404      */
test_formatLjava_lang_String$Ljava_lang_Object_CharacterConversion()1405     public void test_formatLjava_lang_String$Ljava_lang_Object_CharacterConversion() {
1406         Formatter f = new Formatter(Locale.US);
1407         final Object[] illArgs = { Boolean.TRUE, Float.valueOf(1.1f),
1408                 Double.valueOf(1.1d), "string content", Float.valueOf(1.1f), new Date() };
1409         for (int i = 0; i < illArgs.length; i++) {
1410             try {
1411                 f.format("%c", illArgs[i]);
1412                 fail("should throw IllegalFormatConversionException");
1413             } catch (IllegalFormatConversionException e) {
1414                 // expected
1415             }
1416         }
1417 
1418         try {
1419             f.format("%c", Integer.MAX_VALUE);
1420             fail("should throw IllegalFormatCodePointException");
1421         } catch (IllegalFormatCodePointException e) {
1422             // expected
1423         }
1424 
1425         try {
1426             f.format("%#c", 'c');
1427             fail("should throw FormatFlagsConversionMismatchException");
1428         } catch (FormatFlagsConversionMismatchException e) {
1429             // expected
1430         }
1431 
1432         final Object[][] triple = {
1433                 { 'c', "%c", "c" },
1434                 { 'c', "%-2c", "c " },
1435                 { '\u0123', "%c", "\u0123" },
1436                 { '\u0123', "%-2c", "\u0123 " },
1437                 { (byte) 0x11, "%c", "\u0011" },
1438                 { (byte) 0x11, "%-2c", "\u0011 " },
1439                 { (short) 0x1111, "%c", "\u1111" },
1440                 { (short) 0x1111, "%-2c", "\u1111 " },
1441                 { 0x11, "%c", "\u0011" },
1442                 { 0x11, "%-2c", "\u0011 " },
1443         };
1444 
1445         final int input = 0;
1446         final int pattern = 1;
1447         final int output = 2;
1448         for (int i = 0; i < triple.length; i++) {
1449             f = new Formatter(Locale.US);
1450             f.format((String) triple[i][pattern], triple[i][input]);
1451             assertEquals(triple[i][output], f.toString());
1452         }
1453 
1454         f = new Formatter(Locale.US);
1455         f.format("%c", 0x10000);
1456         assertEquals(0x10000, f.toString().codePointAt(0));
1457 
1458         try {
1459             f.format("%2.2c", 'c');
1460             fail("should throw IllegalFormatPrecisionException");
1461         } catch (IllegalFormatPrecisionException e) {
1462             // expected
1463         }
1464 
1465         f = new Formatter(Locale.US);
1466         f.format("%C", 'w');
1467         // error on RI, throw UnknownFormatConversionException
1468         // RI do not support converter 'C'
1469         assertEquals("W", f.toString());
1470 
1471         f = new Formatter(Locale.JAPAN);
1472         f.format("%Ced", 0x1111);
1473         // error on RI, throw UnknownFormatConversionException
1474         // RI do not support converter 'C'
1475         assertEquals("\u1111ed", f.toString());
1476     }
1477 
1478 
1479     /**
1480      * java.util.Formatter#format(String, Object...) for legal
1481      * Byte/Short/Integer/Long conversion type 'd'
1482      */
test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionD()1483     public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionD() {
1484         final Object[][] triple = {
1485                 { 0, "%d", "0" },
1486                 { 0, "%10d", "         0" },
1487                 { 0, "%-1d", "0" },
1488                 { 0, "%+d", "+0" },
1489                 { 0, "% d", " 0" },
1490                 { 0, "%,d", "0" },
1491                 { 0, "%(d", "0" },
1492                 { 0, "%08d", "00000000" },
1493                 { 0, "%-+,(11d", "+0         " },
1494                 { 0, "%0 ,(11d", " 0000000000" },
1495 
1496                 { (byte) 0xff, "%d", "-1" },
1497                 { (byte) 0xff, "%10d", "        -1" },
1498                 { (byte) 0xff, "%-1d", "-1" },
1499                 { (byte) 0xff, "%+d", "-1" },
1500                 { (byte) 0xff, "% d", "-1" },
1501                 { (byte) 0xff, "%,d", "-1" },
1502                 { (byte) 0xff, "%(d", "(1)" },
1503                 { (byte) 0xff, "%08d", "-0000001" },
1504                 { (byte) 0xff, "%-+,(11d", "(1)        " },
1505                 { (byte) 0xff, "%0 ,(11d", "(000000001)" },
1506 
1507                 { (short) 0xf123, "%d", "-3805" },
1508                 { (short) 0xf123, "%10d", "     -3805" },
1509                 { (short) 0xf123, "%-1d", "-3805" },
1510                 { (short) 0xf123, "%+d", "-3805" },
1511                 { (short) 0xf123, "% d", "-3805" },
1512                 { (short) 0xf123, "%,d", "-3.805" },
1513                 { (short) 0xf123, "%(d", "(3805)" },
1514                 { (short) 0xf123, "%08d", "-0003805" },
1515                 { (short) 0xf123, "%-+,(11d", "(3.805)    " },
1516                 { (short) 0xf123, "%0 ,(11d", "(00003.805)" },
1517 
1518                 { 0x123456, "%d", "1193046" },
1519                 { 0x123456, "%10d", "   1193046" },
1520                 { 0x123456, "%-1d", "1193046" },
1521                 { 0x123456, "%+d", "+1193046" },
1522                 { 0x123456, "% d", " 1193046" },
1523                 { 0x123456, "%,d", "1.193.046" },
1524                 { 0x123456, "%(d", "1193046" },
1525                 { 0x123456, "%08d", "01193046" },
1526                 { 0x123456, "%-+,(11d", "+1.193.046 " },
1527                 { 0x123456, "%0 ,(11d", " 01.193.046" },
1528 
1529                 { -3, "%d", "-3" },
1530                 { -3, "%10d", "        -3" },
1531                 { -3, "%-1d", "-3" },
1532                 { -3, "%+d", "-3" },
1533                 { -3, "% d", "-3" },
1534                 { -3, "%,d", "-3" },
1535                 { -3, "%(d", "(3)" },
1536                 { -3, "%08d", "-0000003" },
1537                 { -3, "%-+,(11d", "(3)        " },
1538                 { -3, "%0 ,(11d", "(000000003)" },
1539 
1540                 { 0x7654321L, "%d", "124076833" },
1541                 { 0x7654321L, "%10d", " 124076833" },
1542                 { 0x7654321L, "%-1d", "124076833" },
1543                 { 0x7654321L, "%+d", "+124076833" },
1544                 { 0x7654321L, "% d", " 124076833" },
1545                 { 0x7654321L, "%,d", "124.076.833" },
1546                 { 0x7654321L, "%(d", "124076833" },
1547                 { 0x7654321L, "%08d", "124076833" },
1548                 { 0x7654321L, "%-+,(11d", "+124.076.833" },
1549                 { 0x7654321L, "%0 ,(11d", " 124.076.833" },
1550 
1551                 { -1L, "%d", "-1" },
1552                 { -1L, "%10d", "        -1" },
1553                 { -1L, "%-1d", "-1" },
1554                 { -1L, "%+d", "-1" },
1555                 { -1L, "% d", "-1" },
1556                 { -1L, "%,d", "-1" },
1557                 { -1L, "%(d", "(1)" },
1558                 { -1L, "%08d", "-0000001" },
1559                 { -1L, "%-+,(11d", "(1)        " },
1560                 { -1L, "%0 ,(11d", "(000000001)" },
1561         };
1562 
1563         final int input = 0;
1564         final int pattern = 1;
1565         final int output = 2;
1566         Formatter f;
1567         for (int i = 0; i < triple.length; i++) {
1568             f = new Formatter(Locale.GERMAN);
1569             f.format((String) triple[i][pattern],
1570                     triple[i][input]);
1571             assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern["
1572                     + i + "]:" + triple[i][pattern], triple[i][output], f
1573                     .toString());
1574         }
1575     }
1576 
1577     /**
1578      * java.util.Formatter#format(String, Object...) for legal
1579      * Byte/Short/Integer/Long conversion type 'o'
1580      */
test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionO()1581     public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionO() {
1582         final Object[][] triple = {
1583                 { 0, "%o", "0" },
1584                 { 0, "%-6o", "0     " },
1585                 { 0, "%08o", "00000000" },
1586                 { 0, "%#o", "00" },
1587                 { 0, "%0#11o", "00000000000" },
1588                 { 0, "%-#9o", "00       " },
1589 
1590                 { (byte) 0xff, "%o", "377" },
1591                 { (byte) 0xff, "%-6o", "377   " },
1592                 { (byte) 0xff, "%08o", "00000377" },
1593                 { (byte) 0xff, "%#o", "0377" },
1594                 { (byte) 0xff, "%0#11o", "00000000377" },
1595                 { (byte) 0xff, "%-#9o", "0377     " },
1596 
1597                 { (short) 0xf123, "%o", "170443" },
1598                 { (short) 0xf123, "%-6o", "170443" },
1599                 { (short) 0xf123, "%08o", "00170443" },
1600                 { (short) 0xf123, "%#o", "0170443" },
1601                 { (short) 0xf123, "%0#11o", "00000170443" },
1602                 { (short) 0xf123, "%-#9o", "0170443  " },
1603 
1604                 { 0x123456, "%o", "4432126" },
1605                 { 0x123456, "%-6o", "4432126" },
1606                 { 0x123456, "%08o", "04432126" },
1607                 { 0x123456, "%#o", "04432126" },
1608                 { 0x123456, "%0#11o", "00004432126" },
1609                 { 0x123456, "%-#9o", "04432126 " },
1610 
1611                 { -3, "%o", "37777777775" },
1612                 { -3, "%-6o", "37777777775" },
1613                 { -3, "%08o", "37777777775" },
1614                 { -3, "%#o", "037777777775" },
1615                 { -3, "%0#11o", "037777777775" },
1616                 { -3, "%-#9o", "037777777775" },
1617 
1618                 { 0x7654321L, "%o", "731241441" },
1619                 { 0x7654321L, "%-6o", "731241441" },
1620                 { 0x7654321L, "%08o", "731241441" },
1621                 { 0x7654321L, "%#o", "0731241441" },
1622                 { 0x7654321L, "%0#11o", "00731241441" },
1623                 { 0x7654321L, "%-#9o", "0731241441" },
1624 
1625                 { -1L, "%o", "1777777777777777777777" },
1626                 { -1L, "%-6o", "1777777777777777777777" },
1627                 { -1L, "%08o", "1777777777777777777777" },
1628                 { -1L, "%#o", "01777777777777777777777" },
1629                 { -1L, "%0#11o", "01777777777777777777777" },
1630                 { -1L, "%-#9o", "01777777777777777777777" },
1631         };
1632 
1633         final int input = 0;
1634         final int pattern = 1;
1635         final int output = 2;
1636         Formatter f;
1637         for (int i = 0; i < triple.length; i++) {
1638             f = new Formatter(Locale.ITALY);
1639             f.format((String) triple[i][pattern],
1640                     triple[i][input]);
1641             assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern["
1642                     + i + "]:" + triple[i][pattern], triple[i][output], f
1643                     .toString());
1644         }
1645     }
1646 
1647     /**
1648      * java.util.Formatter#format(String, Object...) for legal
1649      * Byte/Short/Integer/Long conversion type 'x' and 'X'
1650      */
test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionX()1651     public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongConversionX() {
1652         final Object[][] triple = {
1653                 { 0, "%x", "0" },
1654                 { 0, "%-8x", "0       " },
1655                 { 0, "%06x", "000000" },
1656                 { 0, "%#x", "0x0" },
1657                 { 0, "%0#12x", "0x0000000000" },
1658                 { 0, "%-#9x", "0x0      " },
1659 
1660                 { (byte) 0xff, "%x", "ff" },
1661                 { (byte) 0xff, "%-8x", "ff      " },
1662                 { (byte) 0xff, "%06x", "0000ff" },
1663                 { (byte) 0xff, "%#x", "0xff" },
1664                 { (byte) 0xff, "%0#12x", "0x00000000ff" },
1665                 { (byte) 0xff, "%-#9x", "0xff     " },
1666 
1667                 { (short) 0xf123, "%x", "f123" },
1668                 { (short) 0xf123, "%-8x", "f123    " },
1669                 { (short) 0xf123, "%06x", "00f123" },
1670                 { (short) 0xf123, "%#x", "0xf123" },
1671                 { (short) 0xf123, "%0#12x", "0x000000f123" },
1672                 { (short) 0xf123, "%-#9x", "0xf123   " },
1673 
1674                 { 0x123456, "%x", "123456" },
1675                 { 0x123456, "%-8x", "123456  " },
1676                 { 0x123456, "%06x", "123456" },
1677                 { 0x123456, "%#x", "0x123456" },
1678                 { 0x123456, "%0#12x", "0x0000123456" },
1679                 { 0x123456, "%-#9x", "0x123456 " },
1680 
1681                 { -3, "%x", "fffffffd" },
1682                 { -3, "%-8x", "fffffffd" },
1683                 { -3, "%06x", "fffffffd" },
1684                 { -3, "%#x", "0xfffffffd" },
1685                 { -3, "%0#12x", "0x00fffffffd" },
1686                 { -3, "%-#9x", "0xfffffffd" },
1687 
1688                 { 0x7654321L, "%x", "7654321" },
1689                 { 0x7654321L, "%-8x", "7654321 " },
1690                 { 0x7654321L, "%06x", "7654321" },
1691                 { 0x7654321L, "%#x", "0x7654321" },
1692                 { 0x7654321L, "%0#12x", "0x0007654321" },
1693                 { 0x7654321L, "%-#9x", "0x7654321" },
1694 
1695                 { -1L, "%x", "ffffffffffffffff" },
1696                 { -1L, "%-8x", "ffffffffffffffff" },
1697                 { -1L, "%06x", "ffffffffffffffff" },
1698                 { -1L, "%#x", "0xffffffffffffffff" },
1699                 { -1L, "%0#12x", "0xffffffffffffffff" },
1700                 { -1L, "%-#9x", "0xffffffffffffffff" },
1701         };
1702 
1703         final int input = 0;
1704         final int pattern = 1;
1705         final int output = 2;
1706         Formatter f;
1707         for (int i = 0; i < triple.length; i++) {
1708             f = new Formatter(Locale.FRANCE);
1709             f.format((String) triple[i][pattern],
1710                     triple[i][input]);
1711             assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern["
1712                     + i + "]:" + triple[i][pattern], triple[i][output], f
1713                     .toString());
1714 
1715             f = new Formatter(Locale.FRANCE);
1716             f.format((String) triple[i][pattern],
1717                     triple[i][input]);
1718             assertEquals("triple[" + i + "]:" + triple[i][input] + ",pattern["
1719                     + i + "]:" + triple[i][pattern], triple[i][output], f
1720                     .toString());
1721         }
1722     }
1723 
1724     /**
1725      * java.util.Formatter#format(String, Object...) for Date/Time
1726      * conversion
1727      */
test_formatLjava_lang_String$Ljava_lang_Object_DateTimeConversion()1728     public void test_formatLjava_lang_String$Ljava_lang_Object_DateTimeConversion() {
1729         Formatter f = null;
1730         Date now = new Date(1147327147578L);
1731 
1732         Calendar paris = Calendar.getInstance(TimeZone
1733                 .getTimeZone("Europe/Paris"), Locale.FRANCE);
1734         paris.set(2006, 4, 8, 12, 0, 0);
1735         paris.set(Calendar.MILLISECOND, 453);
1736         Calendar china = Calendar.getInstance(
1737                 TimeZone.getTimeZone("GMT-08:00"), Locale.CHINA);
1738         china.set(2006, 4, 8, 12, 0, 0);
1739         china.set(Calendar.MILLISECOND, 609);
1740 
1741         final Object[][] lowerCaseGermanTriple = {
1742                 { 0L, 'a', "Do." },  //$NON-NLS-2$
1743                 { Long.MAX_VALUE, 'a', "So." },  //$NON-NLS-2$
1744                 { -1000L, 'a', "Do." },  //$NON-NLS-2$
1745                 { new Date(1147327147578L), 'a', "Do." },  //$NON-NLS-2$
1746                 { paris, 'a', "Mo." },  //$NON-NLS-2$
1747                 { china, 'a', "Mo." },  //$NON-NLS-2$
1748                 { 0L, 'b', "Jan" },  //$NON-NLS-2$
1749                 { Long.MAX_VALUE, 'b', "Aug" },  //$NON-NLS-2$
1750                 { -1000L, 'b', "Jan" },  //$NON-NLS-2$
1751                 { new Date(1147327147578L), 'b', "Mai" },  //$NON-NLS-2$
1752                 { paris, 'b', "Mai" },  //$NON-NLS-2$
1753                 { china, 'b', "Mai" },  //$NON-NLS-2$
1754                 { 0L, 'c', "Do. Jan 01 08:00:00 GMT+08:00 1970" },  //$NON-NLS-2$
1755                 { Long.MAX_VALUE, 'c', "So. Aug 17 15:18:47 GMT+08:00 292278994" },  //$NON-NLS-2$
1756                 { -1000L, 'c', "Do. Jan 01 07:59:59 GMT+08:00 1970" },  //$NON-NLS-2$
1757                 { new Date(1147327147578L), 'c', "Do. Mai 11 13:59:07 GMT+08:00 2006" },  //$NON-NLS-2$
1758                 { paris, 'c', "Mo. Mai 08 12:00:00 MESZ 2006" },  //$NON-NLS-2$
1759                 { china, 'c', "Mo. Mai 08 12:00:00 GMT-08:00 2006" },  //$NON-NLS-2$
1760                 { 0L, 'd', "01" },  //$NON-NLS-2$
1761                 { Long.MAX_VALUE, 'd', "17" },  //$NON-NLS-2$
1762                 { -1000L, 'd', "01" },  //$NON-NLS-2$
1763                 { new Date(1147327147578L), 'd', "11" },  //$NON-NLS-2$
1764                 { paris, 'd', "08" },  //$NON-NLS-2$
1765                 { china, 'd', "08" },  //$NON-NLS-2$
1766                 { 0L, 'e', "1" },  //$NON-NLS-2$
1767                 { Long.MAX_VALUE, 'e', "17" },  //$NON-NLS-2$
1768                 { -1000L, 'e', "1" },  //$NON-NLS-2$
1769                 { new Date(1147327147578L), 'e', "11" },  //$NON-NLS-2$
1770                 { paris, 'e', "8" },  //$NON-NLS-2$
1771                 { china, 'e', "8" },  //$NON-NLS-2$
1772                 { 0L, 'h', "Jan" },  //$NON-NLS-2$
1773                 { Long.MAX_VALUE, 'h', "Aug" },  //$NON-NLS-2$
1774                 { -1000L, 'h', "Jan" },  //$NON-NLS-2$
1775                 { new Date(1147327147578L), 'h', "Mai" },  //$NON-NLS-2$
1776                 { paris, 'h', "Mai" },  //$NON-NLS-2$
1777                 { china, 'h', "Mai" },  //$NON-NLS-2$
1778                 { 0L, 'j', "001" },  //$NON-NLS-2$
1779                 { Long.MAX_VALUE, 'j', "229" },  //$NON-NLS-2$
1780                 { -1000L, 'j', "001" },  //$NON-NLS-2$
1781                 { new Date(1147327147578L), 'j', "131" },  //$NON-NLS-2$
1782                 { paris, 'j', "128" },  //$NON-NLS-2$
1783                 { china, 'j', "128" },  //$NON-NLS-2$
1784                 { 0L, 'k', "8" },  //$NON-NLS-2$
1785                 { Long.MAX_VALUE, 'k', "15" },  //$NON-NLS-2$
1786                 { -1000L, 'k', "7" },  //$NON-NLS-2$
1787                 { new Date(1147327147578L), 'k', "13" },  //$NON-NLS-2$
1788                 { paris, 'k', "12" },  //$NON-NLS-2$
1789                 { china, 'k', "12" },  //$NON-NLS-2$
1790                 { 0L, 'l', "8" }, //$NON-NLS-2$
1791                 { Long.MAX_VALUE, 'l', "3" }, //$NON-NLS-2$
1792                 { -1000L, 'l', "7" }, //$NON-NLS-2$
1793                 { new Date(1147327147578L), 'l', "1" }, //$NON-NLS-2$
1794                 { paris, 'l', "12" }, //$NON-NLS-2$
1795                 { china, 'l', "12" }, //$NON-NLS-2$
1796                 { 0L, 'm', "01" }, //$NON-NLS-2$
1797                 { Long.MAX_VALUE, 'm', "08" }, //$NON-NLS-2$
1798                 { -1000L, 'm', "01" }, //$NON-NLS-2$
1799                 { new Date(1147327147578L), 'm', "05" }, //$NON-NLS-2$
1800                 { paris, 'm', "05" }, //$NON-NLS-2$
1801                 { china, 'm', "05" }, //$NON-NLS-2$
1802                 { 0L, 'p', "vorm." }, //$NON-NLS-2$
1803                 { Long.MAX_VALUE, 'p', "nachm." }, //$NON-NLS-2$
1804                 { -1000L, 'p', "vorm." }, //$NON-NLS-2$
1805                 { new Date(1147327147578L), 'p', "nachm." }, //$NON-NLS-2$
1806                 { paris, 'p', "nachm." }, //$NON-NLS-2$
1807                 { china, 'p', "nachm." }, //$NON-NLS-2$
1808                 { 0L, 'r', "08:00:00 vorm." }, //$NON-NLS-2$
1809                 { Long.MAX_VALUE, 'r', "03:18:47 nachm." }, //$NON-NLS-2$
1810                 { -1000L, 'r', "07:59:59 vorm." }, //$NON-NLS-2$
1811                 { new Date(1147327147578L), 'r', "01:59:07 nachm." }, //$NON-NLS-2$
1812                 { paris, 'r', "12:00:00 nachm." }, //$NON-NLS-2$
1813                 { china, 'r', "12:00:00 nachm." }, //$NON-NLS-2$
1814                 { 0L, 's', "0" }, //$NON-NLS-2$
1815                 { Long.MAX_VALUE, 's', "9223372036854775" }, //$NON-NLS-2$
1816                 { -1000L, 's', "-1" }, //$NON-NLS-2$
1817                 { new Date(1147327147578L), 's', "1147327147" }, //$NON-NLS-2$
1818                 { paris, 's', "1147082400" }, //$NON-NLS-2$
1819                 { china, 's', "1147118400" }, //$NON-NLS-2$
1820                 { 0L, 'y', "70" }, //$NON-NLS-2$
1821                 { Long.MAX_VALUE, 'y', "94" }, //$NON-NLS-2$
1822                 { -1000L, 'y', "70" }, //$NON-NLS-2$
1823                 { new Date(1147327147578L), 'y', "06" }, //$NON-NLS-2$
1824                 { paris, 'y', "06" }, //$NON-NLS-2$
1825                 { china, 'y', "06" }, //$NON-NLS-2$
1826                 { 0L, 'z', "+0800" }, //$NON-NLS-2$
1827                 { Long.MAX_VALUE, 'z', "+0800" }, //$NON-NLS-2$
1828                 { -1000L, 'z', "+0800" }, //$NON-NLS-2$
1829                 { new Date(1147327147578L), 'z', "+0800" }, //$NON-NLS-2$
1830                 { paris, 'z', "+0100" }, //$NON-NLS-2$
1831                 { china, 'z', "-0800" }, //$NON-NLS-2$
1832 
1833         };
1834 
1835         final Object[][] lowerCaseFranceTriple = {
1836                 { 0L, 'a', "jeu." }, //$NON-NLS-2$
1837                 { Long.MAX_VALUE, 'a', "dim." }, //$NON-NLS-2$
1838                 { -1000L, 'a', "jeu." }, //$NON-NLS-2$
1839                 { new Date(1147327147578L), 'a', "jeu." }, //$NON-NLS-2$
1840                 { paris, 'a', "lun." }, //$NON-NLS-2$
1841                 { china, 'a', "lun." }, //$NON-NLS-2$
1842                 { 0L, 'b', "janv." }, //$NON-NLS-2$
1843                 { Long.MAX_VALUE, 'b', "ao\u00fbt" }, //$NON-NLS-2$
1844                 { -1000L, 'b', "janv." }, //$NON-NLS-2$
1845                 { new Date(1147327147578L), 'b', "mai" }, //$NON-NLS-2$
1846                 { paris, 'b', "mai" }, //$NON-NLS-2$
1847                 { china, 'b', "mai" }, //$NON-NLS-2$
1848                 { 0L, 'c', "jeu. janv. 01 08:00:00 UTC+08:00 1970" }, //$NON-NLS-2$
1849                 { Long.MAX_VALUE, 'c', "dim. ao\u00fbt 17 15:18:47 UTC+08:00 292278994" }, //$NON-NLS-2$
1850                 { -1000L, 'c', "jeu. janv. 01 07:59:59 UTC+08:00 1970" }, //$NON-NLS-2$
1851                 { new Date(1147327147578L), 'c', "jeu. mai 11 13:59:07 UTC+08:00 2006" }, //$NON-NLS-2$
1852                 { paris, 'c', "lun. mai 08 12:00:00 HAEC 2006" }, //$NON-NLS-2$
1853                 { china, 'c', "lun. mai 08 12:00:00 UTC-08:00 2006" }, //$NON-NLS-2$
1854                 { 0L, 'd', "01" }, //$NON-NLS-2$
1855                 { Long.MAX_VALUE, 'd', "17" }, //$NON-NLS-2$
1856                 { -1000L, 'd', "01" }, //$NON-NLS-2$
1857                 { new Date(1147327147578L), 'd', "11" }, //$NON-NLS-2$
1858                 { paris, 'd', "08" }, //$NON-NLS-2$
1859                 { china, 'd', "08" }, //$NON-NLS-2$
1860                 { 0L, 'e', "1" }, //$NON-NLS-2$
1861                 { Long.MAX_VALUE, 'e', "17" }, //$NON-NLS-2$
1862                 { -1000L, 'e', "1" }, //$NON-NLS-2$
1863                 { new Date(1147327147578L), 'e', "11" }, //$NON-NLS-2$
1864                 { paris, 'e', "8" }, //$NON-NLS-2$
1865                 { china, 'e', "8" }, //$NON-NLS-2$
1866                 { 0L, 'h', "janv." }, //$NON-NLS-2$
1867                 { Long.MAX_VALUE, 'h', "ao\u00fbt" }, //$NON-NLS-2$
1868                 { -1000L, 'h', "janv." }, //$NON-NLS-2$
1869                 { new Date(1147327147578L), 'h', "mai" }, //$NON-NLS-2$
1870                 { paris, 'h', "mai" }, //$NON-NLS-2$
1871                 { china, 'h', "mai" }, //$NON-NLS-2$
1872                 { 0L, 'j', "001" }, //$NON-NLS-2$
1873                 { Long.MAX_VALUE, 'j', "229" }, //$NON-NLS-2$
1874                 { -1000L, 'j', "001" }, //$NON-NLS-2$
1875                 { new Date(1147327147578L), 'j', "131" }, //$NON-NLS-2$
1876                 { paris, 'j', "128" }, //$NON-NLS-2$
1877                 { china, 'j', "128" }, //$NON-NLS-2$
1878                 { 0L, 'k', "8" }, //$NON-NLS-2$
1879                 { Long.MAX_VALUE, 'k', "15" }, //$NON-NLS-2$
1880                 { -1000L, 'k', "7" }, //$NON-NLS-2$
1881                 { new Date(1147327147578L), 'k', "13" }, //$NON-NLS-2$
1882                 { paris, 'k', "12" }, //$NON-NLS-2$
1883                 { china, 'k', "12" }, //$NON-NLS-2$
1884                 { 0L, 'l', "8" }, //$NON-NLS-2$
1885                 { Long.MAX_VALUE, 'l', "3" }, //$NON-NLS-2$
1886                 { -1000L, 'l', "7" }, //$NON-NLS-2$
1887                 { new Date(1147327147578L), 'l', "1" }, //$NON-NLS-2$
1888                 { paris, 'l', "12" }, //$NON-NLS-2$
1889                 { china, 'l', "12" }, //$NON-NLS-2$
1890                 { 0L, 'm', "01" }, //$NON-NLS-2$
1891                 { Long.MAX_VALUE, 'm', "08" }, //$NON-NLS-2$
1892                 { -1000L, 'm', "01" }, //$NON-NLS-2$
1893                 { new Date(1147327147578L), 'm', "05" }, //$NON-NLS-2$
1894                 { paris, 'm', "05" }, //$NON-NLS-2$
1895                 { china, 'm', "05" }, //$NON-NLS-2$
1896                 { 0L, 'p', "am" }, //$NON-NLS-2$
1897                 { Long.MAX_VALUE, 'p', "pm" }, //$NON-NLS-2$
1898                 { -1000L, 'p', "am" }, //$NON-NLS-2$
1899                 { new Date(1147327147578L), 'p', "pm" }, //$NON-NLS-2$
1900                 { paris, 'p', "pm" }, //$NON-NLS-2$
1901                 { china, 'p', "pm" }, //$NON-NLS-2$
1902                 { 0L, 'r', "08:00:00 AM" }, //$NON-NLS-2$
1903                 { Long.MAX_VALUE, 'r', "03:18:47 PM" }, //$NON-NLS-2$
1904                 { -1000L, 'r', "07:59:59 AM" }, //$NON-NLS-2$
1905                 { new Date(1147327147578L), 'r', "01:59:07 PM" }, //$NON-NLS-2$
1906                 { paris, 'r', "12:00:00 PM" }, //$NON-NLS-2$
1907                 { china, 'r', "12:00:00 PM" }, //$NON-NLS-2$
1908                 { 0L, 's', "0" }, //$NON-NLS-2$
1909                 { Long.MAX_VALUE, 's', "9223372036854775" }, //$NON-NLS-2$
1910                 { -1000L, 's', "-1" }, //$NON-NLS-2$
1911                 { new Date(1147327147578L), 's', "1147327147" }, //$NON-NLS-2$
1912                 { paris, 's', "1147082400" }, //$NON-NLS-2$
1913                 { china, 's', "1147118400" }, //$NON-NLS-2$
1914                 { 0L, 'y', "70" }, //$NON-NLS-2$
1915                 { Long.MAX_VALUE, 'y', "94" }, //$NON-NLS-2$
1916                 { -1000L, 'y', "70" }, //$NON-NLS-2$
1917                 { new Date(1147327147578L), 'y', "06" }, //$NON-NLS-2$
1918                 { paris, 'y', "06" }, //$NON-NLS-2$
1919                 { china, 'y', "06" }, //$NON-NLS-2$
1920                 { 0L, 'z', "+0800" }, //$NON-NLS-2$
1921                 { Long.MAX_VALUE, 'z', "+0800" }, //$NON-NLS-2$
1922                 { -1000L, 'z', "+0800" }, //$NON-NLS-2$
1923                 { new Date(1147327147578L), 'z', "+0800" }, //$NON-NLS-2$
1924                 { paris, 'z', "+0100" }, //$NON-NLS-2$
1925                 { china, 'z', "-0800" }, //$NON-NLS-2$
1926 
1927         };
1928 
1929         final Object[][] lowerCaseJapanTriple = {
1930                 { 0L, 'a', "\u6728" }, //$NON-NLS-2$
1931                 { Long.MAX_VALUE, 'a', "\u65e5" }, //$NON-NLS-2$
1932                 { -1000L, 'a', "\u6728" }, //$NON-NLS-2$
1933                 { new Date(1147327147578L), 'a', "\u6728" }, //$NON-NLS-2$
1934                 { paris, 'a', "\u6708" }, //$NON-NLS-2$
1935                 { china, 'a', "\u6708" }, //$NON-NLS-2$
1936                 { 0L, 'b', "1\u6708" }, //$NON-NLS-2$
1937                 { Long.MAX_VALUE, 'b', "8\u6708" }, //$NON-NLS-2$
1938                 { -1000L, 'b', "1\u6708" }, //$NON-NLS-2$
1939                 { new Date(1147327147578L), 'b', "5\u6708" }, //$NON-NLS-2$
1940                 { paris, 'b', "5\u6708" }, //$NON-NLS-2$
1941                 { china, 'b', "5\u6708" }, //$NON-NLS-2$
1942                 { 0L, 'c', "\u6728 1\u6708 01 08:00:00 GMT+08:00 1970" }, //$NON-NLS-2$
1943                 { Long.MAX_VALUE, 'c', "\u65e5 8\u6708 17 15:18:47 GMT+08:00 292278994" }, //$NON-NLS-2$
1944                 { -1000L, 'c', "\u6728 1\u6708 01 07:59:59 GMT+08:00 1970" }, //$NON-NLS-2$
1945                 { new Date(1147327147578L), 'c', "\u6728 5\u6708 11 13:59:07 GMT+08:00 2006" }, //$NON-NLS-2$
1946                 { paris, 'c', "\u6708 5\u6708 08 12:00:00 GMT+02:00 2006" }, //$NON-NLS-2$
1947                 { china, 'c', "\u6708 5\u6708 08 12:00:00 GMT-08:00 2006" }, //$NON-NLS-2$
1948                 { 0L, 'd', "01" }, //$NON-NLS-2$
1949                 { Long.MAX_VALUE, 'd', "17" }, //$NON-NLS-2$
1950                 { -1000L, 'd', "01" }, //$NON-NLS-2$
1951                 { new Date(1147327147578L), 'd', "11" }, //$NON-NLS-2$
1952                 { paris, 'd', "08" }, //$NON-NLS-2$
1953                 { china, 'd', "08" }, //$NON-NLS-2$
1954                 { 0L, 'e', "1" }, //$NON-NLS-2$
1955                 { Long.MAX_VALUE, 'e', "17" }, //$NON-NLS-2$
1956                 { -1000L, 'e', "1" }, //$NON-NLS-2$
1957                 { new Date(1147327147578L), 'e', "11" }, //$NON-NLS-2$
1958                 { paris, 'e', "8" }, //$NON-NLS-2$
1959                 { china, 'e', "8" }, //$NON-NLS-2$
1960                 { 0L, 'h', "1\u6708" }, //$NON-NLS-2$
1961                 { Long.MAX_VALUE, 'h', "8\u6708" }, //$NON-NLS-2$
1962                 { -1000L, 'h', "1\u6708" }, //$NON-NLS-2$
1963                 { new Date(1147327147578L), 'h', "5\u6708" }, //$NON-NLS-2$
1964                 { paris, 'h', "5\u6708" }, //$NON-NLS-2$
1965                 { china, 'h', "5\u6708" }, //$NON-NLS-2$
1966                 { 0L, 'j', "001" }, //$NON-NLS-2$
1967                 { Long.MAX_VALUE, 'j', "229" }, //$NON-NLS-2$
1968                 { -1000L, 'j', "001" }, //$NON-NLS-2$
1969                 { new Date(1147327147578L), 'j', "131" }, //$NON-NLS-2$
1970                 { paris, 'j', "128" }, //$NON-NLS-2$
1971                 { china, 'j', "128" }, //$NON-NLS-2$
1972                 { 0L, 'k', "8" }, //$NON-NLS-2$
1973                 { Long.MAX_VALUE, 'k', "15" }, //$NON-NLS-2$
1974                 { -1000L, 'k', "7" }, //$NON-NLS-2$
1975                 { new Date(1147327147578L), 'k', "13" }, //$NON-NLS-2$
1976                 { paris, 'k', "12" }, //$NON-NLS-2$
1977                 { china, 'k', "12" }, //$NON-NLS-2$
1978                 { 0L, 'l', "8" }, //$NON-NLS-2$
1979                 { Long.MAX_VALUE, 'l', "3" }, //$NON-NLS-2$
1980                 { -1000L, 'l', "7" }, //$NON-NLS-2$
1981                 { new Date(1147327147578L), 'l', "1" }, //$NON-NLS-2$
1982                 { paris, 'l', "12" }, //$NON-NLS-2$
1983                 { china, 'l', "12" }, //$NON-NLS-2$
1984                 { 0L, 'm', "01" }, //$NON-NLS-2$
1985                 { Long.MAX_VALUE, 'm', "08" }, //$NON-NLS-2$
1986                 { -1000L, 'm', "01" }, //$NON-NLS-2$
1987                 { new Date(1147327147578L), 'm', "05" }, //$NON-NLS-2$
1988                 { paris, 'm', "05" }, //$NON-NLS-2$
1989                 { china, 'm', "05" }, //$NON-NLS-2$
1990                 { 0L, 'p', "\u5348\u524d" }, //$NON-NLS-2$
1991                 { Long.MAX_VALUE, 'p', "\u5348\u5f8c" }, //$NON-NLS-2$
1992                 { -1000L, 'p', "\u5348\u524d" }, //$NON-NLS-2$
1993                 { new Date(1147327147578L), 'p', "\u5348\u5f8c" }, //$NON-NLS-2$
1994                 { paris, 'p', "\u5348\u5f8c" }, //$NON-NLS-2$
1995                 { china, 'p', "\u5348\u5f8c" }, //$NON-NLS-2$
1996                 { 0L, 'r', "08:00:00 \u5348\u524d" }, //$NON-NLS-2$
1997                 { Long.MAX_VALUE, 'r', "03:18:47 \u5348\u5f8c" }, //$NON-NLS-2$
1998                 { -1000L, 'r', "07:59:59 \u5348\u524d" }, //$NON-NLS-2$
1999                 { new Date(1147327147578L), 'r', "01:59:07 \u5348\u5f8c" }, //$NON-NLS-2$
2000                 { paris, 'r', "12:00:00 \u5348\u5f8c" }, //$NON-NLS-2$
2001                 { china, 'r', "12:00:00 \u5348\u5f8c" }, //$NON-NLS-2$
2002                 { 0L, 's', "0" }, //$NON-NLS-2$
2003                 { Long.MAX_VALUE, 's', "9223372036854775" }, //$NON-NLS-2$
2004                 { -1000L, 's', "-1" }, //$NON-NLS-2$
2005                 { new Date(1147327147578L), 's', "1147327147" }, //$NON-NLS-2$
2006                 { paris, 's', "1147082400" }, //$NON-NLS-2$
2007                 { china, 's', "1147118400" }, //$NON-NLS-2$
2008                 { 0L, 'y', "70" }, //$NON-NLS-2$
2009                 { Long.MAX_VALUE, 'y', "94" }, //$NON-NLS-2$
2010                 { -1000L, 'y', "70" }, //$NON-NLS-2$
2011                 { new Date(1147327147578L), 'y', "06" }, //$NON-NLS-2$
2012                 { paris, 'y', "06" }, //$NON-NLS-2$
2013                 { china, 'y', "06" }, //$NON-NLS-2$
2014                 { 0L, 'z', "+0800" }, //$NON-NLS-2$
2015                 { Long.MAX_VALUE, 'z', "+0800" }, //$NON-NLS-2$
2016                 { -1000L, 'z', "+0800" }, //$NON-NLS-2$
2017                 { new Date(1147327147578L), 'z', "+0800" }, //$NON-NLS-2$
2018                 { paris, 'z', "+0100" }, //$NON-NLS-2$
2019                 { china, 'z', "-0800" }, //$NON-NLS-2$
2020         };
2021 
2022         final int input = 0;
2023         final int pattern = 1;
2024         final int output = 2;
2025         for (int i = 0; i < 90; i++) {
2026             // go through legal conversion
2027             String formatSpecifier = "%t" + lowerCaseGermanTriple[i][pattern]; //$NON-NLS-2$
2028             String formatSpecifierUpper = "%T" + lowerCaseGermanTriple[i][pattern]; //$NON-NLS-2$
2029             // test '%t'
2030             f = new Formatter(Locale.GERMAN);
2031             f.format(formatSpecifier, lowerCaseGermanTriple[i][input]);
2032             assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$
2033                     + " Argument: " + lowerCaseGermanTriple[i][input], //$NON-NLS-2$
2034                     lowerCaseGermanTriple[i][output], f.toString());
2035 
2036             f = new Formatter(Locale.GERMAN);
2037             f.format(Locale.FRANCE, formatSpecifier, lowerCaseFranceTriple[i][input]);
2038             assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$
2039                     + " Argument: " + lowerCaseFranceTriple[i][input], //$NON-NLS-2$
2040                     lowerCaseFranceTriple[i][output], f.toString());
2041 
2042             f = new Formatter(Locale.GERMAN);
2043             f.format(Locale.JAPAN, formatSpecifier, lowerCaseJapanTriple[i][input]);
2044             assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$
2045                     + " Argument: " + lowerCaseJapanTriple[i][input], //$NON-NLS-2$
2046                     lowerCaseJapanTriple[i][output], f.toString());
2047 
2048             // test '%T'
2049             f = new Formatter(Locale.GERMAN);
2050             f.format(formatSpecifierUpper, lowerCaseGermanTriple[i][input]);
2051             assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$
2052                     + " Argument: " + lowerCaseGermanTriple[i][input], //$NON-NLS-2$
2053                     ((String) lowerCaseGermanTriple[i][output])
2054                             .toUpperCase(Locale.US), f.toString());
2055 
2056             f = new Formatter(Locale.GERMAN);
2057             f.format(Locale.FRANCE, formatSpecifierUpper, lowerCaseFranceTriple[i][input]);
2058             assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$
2059                     + " Argument: " + lowerCaseFranceTriple[i][input], //$NON-NLS-2$
2060                     ((String) lowerCaseFranceTriple[i][output])
2061                             .toUpperCase(Locale.US), f.toString());
2062 
2063             f = new Formatter(Locale.GERMAN);
2064             f.format(Locale.JAPAN, formatSpecifierUpper, lowerCaseJapanTriple[i][input]);
2065             assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$
2066                     + " Argument: " + lowerCaseJapanTriple[i][input], //$NON-NLS-2$
2067                     ((String) lowerCaseJapanTriple[i][output])
2068                             .toUpperCase(Locale.US), f.toString());
2069         }
2070 
2071         final Object[][] upperCaseGermanTriple = {
2072                 { 0L, 'A', "Donnerstag" }, //$NON-NLS-2$
2073                 { Long.MAX_VALUE, 'A', "Sonntag" }, //$NON-NLS-2$
2074                 { -1000L, 'A', "Donnerstag" }, //$NON-NLS-2$
2075                 { new Date(1147327147578L), 'A', "Donnerstag" }, //$NON-NLS-2$
2076                 { paris, 'A', "Montag" }, //$NON-NLS-2$
2077                 { china, 'A', "Montag" }, //$NON-NLS-2$
2078                 { 0L, 'B', "Januar" }, //$NON-NLS-2$
2079                 { Long.MAX_VALUE, 'B', "August" }, //$NON-NLS-2$
2080                 { -1000L, 'B', "Januar" }, //$NON-NLS-2$
2081                 { new Date(1147327147578L), 'B', "Mai" }, //$NON-NLS-2$
2082                 { paris, 'B', "Mai" }, //$NON-NLS-2$
2083                 { china, 'B', "Mai" }, //$NON-NLS-2$
2084                 { 0L, 'C', "19" }, //$NON-NLS-2$
2085                 { Long.MAX_VALUE, 'C', "2922789" }, //$NON-NLS-2$
2086                 { -1000L, 'C', "19" }, //$NON-NLS-2$
2087                 { new Date(1147327147578L), 'C', "20" }, //$NON-NLS-2$
2088                 { paris, 'C', "20" }, //$NON-NLS-2$
2089                 { china, 'C', "20" }, //$NON-NLS-2$
2090                 { 0L, 'D', "01/01/70" }, //$NON-NLS-2$
2091                 { Long.MAX_VALUE, 'D', "08/17/94" }, //$NON-NLS-2$
2092                 { -1000L, 'D', "01/01/70" }, //$NON-NLS-2$
2093                 { new Date(1147327147578L), 'D', "05/11/06" }, //$NON-NLS-2$
2094                 { paris, 'D', "05/08/06" }, //$NON-NLS-2$
2095                 { china, 'D', "05/08/06" }, //$NON-NLS-2$
2096                 { 0L, 'F', "1970-01-01" }, //$NON-NLS-2$
2097                 { Long.MAX_VALUE, 'F', "292278994-08-17" }, //$NON-NLS-2$
2098                 { -1000L, 'F', "1970-01-01" }, //$NON-NLS-2$
2099                 { new Date(1147327147578L), 'F', "2006-05-11" }, //$NON-NLS-2$
2100                 { paris, 'F', "2006-05-08" }, //$NON-NLS-2$
2101                 { china, 'F', "2006-05-08" }, //$NON-NLS-2$
2102                 { 0L, 'H', "08" }, //$NON-NLS-2$
2103                 { Long.MAX_VALUE, 'H', "15" }, //$NON-NLS-2$
2104                 { -1000L, 'H', "07" }, //$NON-NLS-2$
2105                 { new Date(1147327147578L), 'H', "13" }, //$NON-NLS-2$
2106                 { paris, 'H', "12" }, //$NON-NLS-2$
2107                 { china, 'H', "12" }, //$NON-NLS-2$
2108                 { 0L, 'I', "08" }, //$NON-NLS-2$
2109                 { Long.MAX_VALUE, 'I', "03" }, //$NON-NLS-2$
2110                 { -1000L, 'I', "07" }, //$NON-NLS-2$
2111                 { new Date(1147327147578L), 'I', "01" }, //$NON-NLS-2$
2112                 { paris, 'I', "12" }, //$NON-NLS-2$
2113                 { china, 'I', "12" }, //$NON-NLS-2$
2114                 { 0L, 'L', "000" }, //$NON-NLS-2$
2115                 { Long.MAX_VALUE, 'L', "807" }, //$NON-NLS-2$
2116                 { -1000L, 'L', "000" }, //$NON-NLS-2$
2117                 { new Date(1147327147578L), 'L', "578" }, //$NON-NLS-2$
2118                 { paris, 'L', "453" }, //$NON-NLS-2$
2119                 { china, 'L', "609" }, //$NON-NLS-2$
2120                 { 0L, 'M', "00" }, //$NON-NLS-2$
2121                 { Long.MAX_VALUE, 'M', "18" }, //$NON-NLS-2$
2122                 { -1000L, 'M', "59" }, //$NON-NLS-2$
2123                 { new Date(1147327147578L), 'M', "59" }, //$NON-NLS-2$
2124                 { paris, 'M', "00" }, //$NON-NLS-2$
2125                 { china, 'M', "00" }, //$NON-NLS-2$
2126                 { 0L, 'N', "000000000" }, //$NON-NLS-2$
2127                 { Long.MAX_VALUE, 'N', "807000000" }, //$NON-NLS-2$
2128                 { -1000L, 'N', "000000000" }, //$NON-NLS-2$
2129                 { new Date(1147327147578L), 'N', "578000000" }, //$NON-NLS-2$
2130                 { paris, 'N', "609000000" }, //$NON-NLS-2$
2131                 { china, 'N', "609000000" }, //$NON-NLS-2$
2132                 { 0L, 'Q', "0" }, //$NON-NLS-2$
2133                 { Long.MAX_VALUE, 'Q', "9223372036854775807" }, //$NON-NLS-2$
2134                 { -1000L, 'Q', "-1000" }, //$NON-NLS-2$
2135                 { new Date(1147327147578L), 'Q', "1147327147578" }, //$NON-NLS-2$
2136                 { paris, 'Q', "1147082400453" }, //$NON-NLS-2$
2137                 { china, 'Q', "1147118400609" }, //$NON-NLS-2$
2138                 { 0L, 'R', "08:00" }, //$NON-NLS-2$
2139                 { Long.MAX_VALUE, 'R', "15:18" }, //$NON-NLS-2$
2140                 { -1000L, 'R', "07:59" }, //$NON-NLS-2$
2141                 { new Date(1147327147578L), 'R', "13:59" }, //$NON-NLS-2$
2142                 { paris, 'R', "12:00" }, //$NON-NLS-2$
2143                 { china, 'R', "12:00" }, //$NON-NLS-2$
2144                 { 0L, 'S', "00" }, //$NON-NLS-2$
2145                 { Long.MAX_VALUE, 'S', "47" }, //$NON-NLS-2$
2146                 { -1000L, 'S', "59" }, //$NON-NLS-2$
2147                 { new Date(1147327147578L), 'S', "07" }, //$NON-NLS-2$
2148                 { paris, 'S', "00" }, //$NON-NLS-2$
2149                 { china, 'S', "00" }, //$NON-NLS-2$
2150                 { 0L, 'T', "08:00:00" }, //$NON-NLS-2$
2151                 { Long.MAX_VALUE, 'T', "15:18:47" }, //$NON-NLS-2$
2152                 { -1000L, 'T', "07:59:59" }, //$NON-NLS-2$
2153                 { new Date(1147327147578L), 'T', "13:59:07" }, //$NON-NLS-2$
2154                 { paris, 'T', "12:00:00" }, //$NON-NLS-2$
2155                 { china, 'T', "12:00:00" }, //$NON-NLS-2$
2156                 { 0L, 'Y', "1970" }, //$NON-NLS-2$
2157                 { Long.MAX_VALUE, 'Y', "292278994" }, //$NON-NLS-2$
2158                 { -1000L, 'Y', "1970" }, //$NON-NLS-2$
2159                 { new Date(1147327147578L), 'Y', "2006" }, //$NON-NLS-2$
2160                 { paris, 'Y', "2006" }, //$NON-NLS-2$
2161                 { china, 'Y', "2006" }, //$NON-NLS-2$
2162                 { 0L, 'Z', "CST" }, //$NON-NLS-2$
2163                 { Long.MAX_VALUE, 'Z', "CST" }, //$NON-NLS-2$
2164                 { -1000L, 'Z', "CST" }, //$NON-NLS-2$
2165                 { new Date(1147327147578L), 'Z', "CST" }, //$NON-NLS-2$
2166                 { paris, 'Z', "CEST" }, //$NON-NLS-2$
2167                 { china, 'Z', "GMT-08:00" }, //$NON-NLS-2$
2168 
2169         };
2170 
2171         final Object[][] upperCaseFranceTriple = {
2172                 { 0L, 'A', "jeudi" }, //$NON-NLS-2$
2173                 { Long.MAX_VALUE, 'A', "dimanche" }, //$NON-NLS-2$
2174                 { -1000L, 'A', "jeudi" }, //$NON-NLS-2$
2175                 { new Date(1147327147578L), 'A', "jeudi" }, //$NON-NLS-2$
2176                 { paris, 'A', "lundi" }, //$NON-NLS-2$
2177                 { china, 'A', "lundi" }, //$NON-NLS-2$
2178                 { 0L, 'B', "janvier" }, //$NON-NLS-2$
2179                 { Long.MAX_VALUE, 'B', "ao\u00fbt" }, //$NON-NLS-2$
2180                 { -1000L, 'B', "janvier" }, //$NON-NLS-2$
2181                 { new Date(1147327147578L), 'B', "mai" }, //$NON-NLS-2$
2182                 { paris, 'B', "mai" }, //$NON-NLS-2$
2183                 { china, 'B', "mai" }, //$NON-NLS-2$
2184                 { 0L, 'C', "19" }, //$NON-NLS-2$
2185                 { Long.MAX_VALUE, 'C', "2922789" }, //$NON-NLS-2$
2186                 { -1000L, 'C', "19" }, //$NON-NLS-2$
2187                 { new Date(1147327147578L), 'C', "20" }, //$NON-NLS-2$
2188                 { paris, 'C', "20" }, //$NON-NLS-2$
2189                 { china, 'C', "20" }, //$NON-NLS-2$
2190                 { 0L, 'D', "01/01/70" }, //$NON-NLS-2$
2191                 { Long.MAX_VALUE, 'D', "08/17/94" }, //$NON-NLS-2$
2192                 { -1000L, 'D', "01/01/70" }, //$NON-NLS-2$
2193                 { new Date(1147327147578L), 'D', "05/11/06" }, //$NON-NLS-2$
2194                 { paris, 'D', "05/08/06" }, //$NON-NLS-2$
2195                 { china, 'D', "05/08/06" }, //$NON-NLS-2$
2196                 { 0L, 'F', "1970-01-01" }, //$NON-NLS-2$
2197                 { Long.MAX_VALUE, 'F', "292278994-08-17" }, //$NON-NLS-2$
2198                 { -1000L, 'F', "1970-01-01" }, //$NON-NLS-2$
2199                 { new Date(1147327147578L), 'F', "2006-05-11" }, //$NON-NLS-2$
2200                 { paris, 'F', "2006-05-08" }, //$NON-NLS-2$
2201                 { china, 'F', "2006-05-08" }, //$NON-NLS-2$
2202                 { 0L, 'H', "08" }, //$NON-NLS-2$
2203                 { Long.MAX_VALUE, 'H', "15" }, //$NON-NLS-2$
2204                 { -1000L, 'H', "07" }, //$NON-NLS-2$
2205                 { new Date(1147327147578L), 'H', "13" }, //$NON-NLS-2$
2206                 { paris, 'H', "12" }, //$NON-NLS-2$
2207                 { china, 'H', "12" }, //$NON-NLS-2$
2208                 { 0L, 'I', "08" }, //$NON-NLS-2$
2209                 { Long.MAX_VALUE, 'I', "03" }, //$NON-NLS-2$
2210                 { -1000L, 'I', "07" }, //$NON-NLS-2$
2211                 { new Date(1147327147578L), 'I', "01" }, //$NON-NLS-2$
2212                 { paris, 'I', "12" }, //$NON-NLS-2$
2213                 { china, 'I', "12" }, //$NON-NLS-2$
2214                 { 0L, 'L', "000" }, //$NON-NLS-2$
2215                 { Long.MAX_VALUE, 'L', "807" }, //$NON-NLS-2$
2216                 { -1000L, 'L', "000" }, //$NON-NLS-2$
2217                 { new Date(1147327147578L), 'L', "578" }, //$NON-NLS-2$
2218                 { paris, 'L', "453" }, //$NON-NLS-2$
2219                 { china, 'L', "609" }, //$NON-NLS-2$
2220                 { 0L, 'M', "00" }, //$NON-NLS-2$
2221                 { Long.MAX_VALUE, 'M', "18" }, //$NON-NLS-2$
2222                 { -1000L, 'M', "59" }, //$NON-NLS-2$
2223                 { new Date(1147327147578L), 'M', "59" }, //$NON-NLS-2$
2224                 { paris, 'M', "00" }, //$NON-NLS-2$
2225                 { china, 'M', "00" }, //$NON-NLS-2$
2226                 { 0L, 'N', "000000000" }, //$NON-NLS-2$
2227                 { Long.MAX_VALUE, 'N', "807000000" }, //$NON-NLS-2$
2228                 { -1000L, 'N', "000000000" }, //$NON-NLS-2$
2229                 { new Date(1147327147578L), 'N', "578000000" }, //$NON-NLS-2$
2230                 { paris, 'N', "453000000" }, //$NON-NLS-2$
2231                 { china, 'N', "468000000" }, //$NON-NLS-2$
2232                 { 0L, 'Q', "0" }, //$NON-NLS-2$
2233                 { Long.MAX_VALUE, 'Q', "9223372036854775807" }, //$NON-NLS-2$
2234                 { -1000L, 'Q', "-1000" }, //$NON-NLS-2$
2235                 { new Date(1147327147578L), 'Q', "1147327147578" }, //$NON-NLS-2$
2236                 { paris, 'Q', "1147082400453" }, //$NON-NLS-2$
2237                 { china, 'Q', "1147118400609" }, //$NON-NLS-2$
2238                 { 0L, 'R', "08:00" }, //$NON-NLS-2$
2239                 { Long.MAX_VALUE, 'R', "15:18" }, //$NON-NLS-2$
2240                 { -1000L, 'R', "07:59" }, //$NON-NLS-2$
2241                 { new Date(1147327147578L), 'R', "13:59" }, //$NON-NLS-2$
2242                 { paris, 'R', "12:00" }, //$NON-NLS-2$
2243                 { china, 'R', "12:00" }, //$NON-NLS-2$
2244                 { 0L, 'S', "00" }, //$NON-NLS-2$
2245                 { Long.MAX_VALUE, 'S', "47" }, //$NON-NLS-2$
2246                 { -1000L, 'S', "59" }, //$NON-NLS-2$
2247                 { new Date(1147327147578L), 'S', "07" }, //$NON-NLS-2$
2248                 { paris, 'S', "00" }, //$NON-NLS-2$
2249                 { china, 'S', "00" }, //$NON-NLS-2$
2250                 { 0L, 'T', "08:00:00" }, //$NON-NLS-2$
2251                 { Long.MAX_VALUE, 'T', "15:18:47" }, //$NON-NLS-2$
2252                 { -1000L, 'T', "07:59:59" }, //$NON-NLS-2$
2253                 { new Date(1147327147578L), 'T', "13:59:07" }, //$NON-NLS-2$
2254                 { paris, 'T', "12:00:00" }, //$NON-NLS-2$
2255                 { china, 'T', "12:00:00" }, //$NON-NLS-2$
2256                 { 0L, 'Y', "1970" }, //$NON-NLS-2$
2257                 { Long.MAX_VALUE, 'Y', "292278994" }, //$NON-NLS-2$
2258                 { -1000L, 'Y', "1970" }, //$NON-NLS-2$
2259                 { new Date(1147327147578L), 'Y', "2006" }, //$NON-NLS-2$
2260                 { paris, 'Y', "2006" }, //$NON-NLS-2$
2261                 { china, 'Y', "2006" }, //$NON-NLS-2$
2262                 { 0L, 'Z', "CST" }, //$NON-NLS-2$
2263                 { Long.MAX_VALUE, 'Z', "CST" }, //$NON-NLS-2$
2264                 { -1000L, 'Z', "CST" }, //$NON-NLS-2$
2265                 { new Date(1147327147578L), 'Z', "CST" }, //$NON-NLS-2$
2266                 { paris, 'Z', "CEST" }, //$NON-NLS-2$
2267                 { china, 'Z', "GMT-08:00" }, //$NON-NLS-2$
2268 
2269         };
2270 
2271         final Object[][] upperCaseJapanTriple = {
2272                 { 0L, 'A', "\u6728\u66dc\u65e5" }, //$NON-NLS-2$
2273                 { Long.MAX_VALUE, 'A', "\u65e5\u66dc\u65e5" }, //$NON-NLS-2$
2274                 { -1000L, 'A', "\u6728\u66dc\u65e5" }, //$NON-NLS-2$
2275                 { new Date(1147327147578L), 'A', "\u6728\u66dc\u65e5" }, //$NON-NLS-2$
2276                 { paris, 'A', "\u6708\u66dc\u65e5" }, //$NON-NLS-2$
2277                 { china, 'A', "\u6708\u66dc\u65e5" }, //$NON-NLS-2$
2278                 { 0L, 'B', "1\u6708" }, //$NON-NLS-2$
2279                 { Long.MAX_VALUE, 'B', "8\u6708" }, //$NON-NLS-2$
2280                 { -1000L, 'B', "1\u6708" }, //$NON-NLS-2$
2281                 { new Date(1147327147578L), 'B', "5\u6708" }, //$NON-NLS-2$
2282                 { paris, 'B', "5\u6708" }, //$NON-NLS-2$
2283                 { china, 'B', "5\u6708" }, //$NON-NLS-2$
2284                 { 0L, 'C', "19" }, //$NON-NLS-2$
2285                 { Long.MAX_VALUE, 'C', "2922789" }, //$NON-NLS-2$
2286                 { -1000L, 'C', "19" }, //$NON-NLS-2$
2287                 { new Date(1147327147578L), 'C', "20" }, //$NON-NLS-2$
2288                 { paris, 'C', "20" }, //$NON-NLS-2$
2289                 { china, 'C', "20" }, //$NON-NLS-2$
2290                 { 0L, 'D', "01/01/70" }, //$NON-NLS-2$
2291                 { Long.MAX_VALUE, 'D', "08/17/94" }, //$NON-NLS-2$
2292                 { -1000L, 'D', "01/01/70" }, //$NON-NLS-2$
2293                 { new Date(1147327147578L), 'D', "05/11/06" }, //$NON-NLS-2$
2294                 { paris, 'D', "05/08/06" }, //$NON-NLS-2$
2295                 { china, 'D', "05/08/06" }, //$NON-NLS-2$
2296                 { 0L, 'F', "1970-01-01" }, //$NON-NLS-2$
2297                 { Long.MAX_VALUE, 'F', "292278994-08-17" }, //$NON-NLS-2$
2298                 { -1000L, 'F', "1970-01-01" }, //$NON-NLS-2$
2299                 { new Date(1147327147578L), 'F', "2006-05-11" }, //$NON-NLS-2$
2300                 { paris, 'F', "2006-05-08" }, //$NON-NLS-2$
2301                 { china, 'F', "2006-05-08" }, //$NON-NLS-2$
2302                 { 0L, 'H', "08" }, //$NON-NLS-2$
2303                 { Long.MAX_VALUE, 'H', "15" }, //$NON-NLS-2$
2304                 { -1000L, 'H', "07" }, //$NON-NLS-2$
2305                 { new Date(1147327147578L), 'H', "13" }, //$NON-NLS-2$
2306                 { paris, 'H', "12" }, //$NON-NLS-2$
2307                 { china, 'H', "12" }, //$NON-NLS-2$
2308                 { 0L, 'I', "08" }, //$NON-NLS-2$
2309                 { Long.MAX_VALUE, 'I', "03" }, //$NON-NLS-2$
2310                 { -1000L, 'I', "07" }, //$NON-NLS-2$
2311                 { new Date(1147327147578L), 'I', "01" }, //$NON-NLS-2$
2312                 { paris, 'I', "12" }, //$NON-NLS-2$
2313                 { china, 'I', "12" }, //$NON-NLS-2$
2314                 { 0L, 'L', "000" }, //$NON-NLS-2$
2315                 { Long.MAX_VALUE, 'L', "807" }, //$NON-NLS-2$
2316                 { -1000L, 'L', "000" }, //$NON-NLS-2$
2317                 { new Date(1147327147578L), 'L', "578" }, //$NON-NLS-2$
2318                 { paris, 'L', "453" }, //$NON-NLS-2$
2319                 { china, 'L', "609" }, //$NON-NLS-2$
2320                 { 0L, 'M', "00" }, //$NON-NLS-2$
2321                 { Long.MAX_VALUE, 'M', "18" }, //$NON-NLS-2$
2322                 { -1000L, 'M', "59" }, //$NON-NLS-2$
2323                 { new Date(1147327147578L), 'M', "59" }, //$NON-NLS-2$
2324                 { paris, 'M', "00" }, //$NON-NLS-2$
2325                 { china, 'M', "00" }, //$NON-NLS-2$
2326                 { 0L, 'N', "000000000" }, //$NON-NLS-2$
2327                 { Long.MAX_VALUE, 'N', "807000000" }, //$NON-NLS-2$
2328                 { -1000L, 'N', "000000000" }, //$NON-NLS-2$
2329                 { new Date(1147327147578L), 'N', "578000000" }, //$NON-NLS-2$
2330                 { paris, 'N', "453000000" }, //$NON-NLS-2$
2331                 { china, 'N', "468000000" }, //$NON-NLS-2$
2332                 { 0L, 'Q', "0" }, //$NON-NLS-2$
2333                 { Long.MAX_VALUE, 'Q', "9223372036854775807" }, //$NON-NLS-2$
2334                 { -1000L, 'Q', "-1000" }, //$NON-NLS-2$
2335                 { new Date(1147327147578L), 'Q', "1147327147578" }, //$NON-NLS-2$
2336                 { paris, 'Q', "1147082400453" }, //$NON-NLS-2$
2337                 { china, 'Q', "1147118400609" }, //$NON-NLS-2$
2338                 { 0L, 'R', "08:00" }, //$NON-NLS-2$
2339                 { Long.MAX_VALUE, 'R', "15:18" }, //$NON-NLS-2$
2340                 { -1000L, 'R', "07:59" }, //$NON-NLS-2$
2341                 { new Date(1147327147578L), 'R', "13:59" }, //$NON-NLS-2$
2342                 { paris, 'R', "12:00" }, //$NON-NLS-2$
2343                 { china, 'R', "12:00" }, //$NON-NLS-2$
2344                 { 0L, 'S', "00" }, //$NON-NLS-2$
2345                 { Long.MAX_VALUE, 'S', "47" }, //$NON-NLS-2$
2346                 { -1000L, 'S', "59" }, //$NON-NLS-2$
2347                 { new Date(1147327147578L), 'S', "07" }, //$NON-NLS-2$
2348                 { paris, 'S', "00" }, //$NON-NLS-2$
2349                 { china, 'S', "00" }, //$NON-NLS-2$
2350                 { 0L, 'T', "08:00:00" }, //$NON-NLS-2$
2351                 { Long.MAX_VALUE, 'T', "15:18:47" }, //$NON-NLS-2$
2352                 { -1000L, 'T', "07:59:59" }, //$NON-NLS-2$
2353                 { new Date(1147327147578L), 'T', "13:59:07" }, //$NON-NLS-2$
2354                 { paris, 'T', "12:00:00" }, //$NON-NLS-2$
2355                 { china, 'T', "12:00:00" }, //$NON-NLS-2$
2356                 { 0L, 'Y', "1970" }, //$NON-NLS-2$
2357                 { Long.MAX_VALUE, 'Y', "292278994" }, //$NON-NLS-2$
2358                 { -1000L, 'Y', "1970" }, //$NON-NLS-2$
2359                 { new Date(1147327147578L), 'Y', "2006" }, //$NON-NLS-2$
2360                 { paris, 'Y', "2006" }, //$NON-NLS-2$
2361                 { china, 'Y', "2006" }, //$NON-NLS-2$
2362                 { 0L, 'Z', "CST" }, //$NON-NLS-2$
2363                 { Long.MAX_VALUE, 'Z', "CST" }, //$NON-NLS-2$
2364                 { -1000L, 'Z', "CST" }, //$NON-NLS-2$
2365                 { new Date(1147327147578L), 'Z', "CST" }, //$NON-NLS-2$
2366                 { paris, 'Z', "CEST" }, //$NON-NLS-2$
2367                 { china, 'Z', "GMT-08:00" }, //$NON-NLS-2$
2368         };
2369 
2370 
2371         for (int i = 0; i < 90; i++) {
2372             String formatSpecifier = "%t" + upperCaseGermanTriple[i][pattern]; //$NON-NLS-2$
2373             String formatSpecifierUpper = "%T" + upperCaseGermanTriple[i][pattern]; //$NON-NLS-2$
2374             if ((Character) upperCaseGermanTriple[i][pattern] == 'N') {
2375                 // result can't be predicted on RI, so skip this test
2376                 continue;
2377             }
2378             // test '%t'
2379             f = new Formatter(Locale.JAPAN);
2380             f.format(formatSpecifier, upperCaseJapanTriple[i][input]);
2381             assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$
2382                     + " Argument: " + upperCaseJapanTriple[i][input], //$NON-NLS-2$
2383                     upperCaseJapanTriple[i][output], f.toString());
2384 
2385             f = new Formatter(Locale.JAPAN);
2386             f.format(Locale.GERMAN, formatSpecifier, upperCaseGermanTriple[i][input]);
2387             assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$
2388                     + " Argument: " + upperCaseGermanTriple[i][input], //$NON-NLS-2$
2389                     upperCaseGermanTriple[i][output], f.toString());
2390 
2391             f = new Formatter(Locale.JAPAN);
2392             f.format(Locale.FRANCE, formatSpecifier, upperCaseFranceTriple[i][input]);
2393             assertEquals("Format pattern: " + formatSpecifier //$NON-NLS-2$
2394                     + " Argument: " + upperCaseFranceTriple[i][input], //$NON-NLS-2$
2395                     upperCaseFranceTriple[i][output], f.toString());
2396 
2397             // test '%T'
2398             f = new Formatter(Locale.GERMAN);
2399             f.format(formatSpecifierUpper, upperCaseGermanTriple[i][input]);
2400             assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$
2401                     + " Argument: " + upperCaseGermanTriple[i][input], //$NON-NLS-2$
2402                     ((String) upperCaseGermanTriple[i][output])
2403                             .toUpperCase(Locale.US), f.toString());
2404 
2405             f = new Formatter(Locale.GERMAN);
2406             f.format(Locale.JAPAN, formatSpecifierUpper, upperCaseJapanTriple[i][input]);
2407             assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$
2408                     + " Argument: " + upperCaseJapanTriple[i][input], //$NON-NLS-2$
2409                     ((String) upperCaseJapanTriple[i][output])
2410                             .toUpperCase(Locale.US), f.toString());
2411 
2412             f = new Formatter(Locale.GERMAN);
2413             f.format(Locale.FRANCE, formatSpecifierUpper, upperCaseFranceTriple[i][input]);
2414             assertEquals("Format pattern: " + formatSpecifierUpper //$NON-NLS-2$
2415                     + " Argument: " + upperCaseFranceTriple[i][input], //$NON-NLS-2$
2416                     ((String) upperCaseFranceTriple[i][output])
2417                             .toUpperCase(Locale.US), f.toString());
2418         }
2419 
2420         f = new Formatter(Locale.US);
2421         f.format("%-10ta", now); //$NON-NLS-2$
2422         assertEquals("Thu       ", f.toString()); //$NON-NLS-2$
2423 
2424         f = new Formatter(Locale.US);
2425         f.format("%10000000000000000000000000000000001ta", now); //$NON-NLS-2$
2426         assertEquals("Thu", f.toString().trim()); //$NON-NLS-2$
2427     }
2428 
2429     /**
2430      * java.util.Formatter#format(String, Object...) for null argment for
2431      * Byte/Short/Integer/Long/BigInteger conversion
2432      */
test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongNullConversion()2433     public void test_formatLjava_lang_String$Ljava_lang_Object_ByteShortIntegerLongNullConversion() {
2434 
2435         Formatter f = new Formatter(Locale.FRANCE);
2436         f.format("%d%<o%<x%<5X", (Integer) null);
2437         assertEquals("nullnullnull NULL", f.toString());
2438 
2439         f = new Formatter(Locale.GERMAN);
2440         f.format("%d%<#03o %<0#4x%<6X", (Long) null);
2441         assertEquals("nullnull null  NULL", f.toString());
2442 
2443         f = new Formatter(Locale.GERMAN);
2444         f.format("%(+,07d%<o %<x%<6X", (Byte) null);
2445         assertEquals("   nullnull null  NULL", f.toString());
2446 
2447         f = new Formatter(Locale.ITALY);
2448         f.format("%(+,07d%<o %<x%<0#6X", (Short) null);
2449         assertEquals("   nullnull null  NULL", f.toString());
2450 
2451         f = new Formatter(Locale.GERMAN);
2452         f.format("%(+,-7d%<( o%<+(x %<( 06X", (BigInteger) null);
2453         assertEquals("null   nullnull   NULL", f.toString());
2454     }
2455 
2456     /**
2457      * java.util.Formatter#format(String, Object...) for legal
2458      * BigInteger conversion type 'd'
2459      */
test_formatLjava_lang_String$LBigInteger()2460     public void test_formatLjava_lang_String$LBigInteger() {
2461         final Object[][] tripleD = {
2462                 { new BigInteger("123456789012345678901234567890"), "%d", "123456789012345678901234567890" }, //$NON-NLS-2$
2463                 { new BigInteger("123456789012345678901234567890"), "%10d", "123456789012345678901234567890" }, //$NON-NLS-2$
2464                 { new BigInteger("123456789012345678901234567890"), "%-1d", "123456789012345678901234567890" }, //$NON-NLS-2$
2465                 { new BigInteger("123456789012345678901234567890"), "%+d", "+123456789012345678901234567890" }, //$NON-NLS-2$
2466                 { new BigInteger("123456789012345678901234567890"), "% d", " 123456789012345678901234567890" }, //$NON-NLS-2$
2467                 { new BigInteger("123456789012345678901234567890"), "%,d", "123.456.789.012.345.678.901.234.567.890" }, //$NON-NLS-2$
2468                 { new BigInteger("123456789012345678901234567890"), "%(d", "123456789012345678901234567890" }, //$NON-NLS-2$
2469                 { new BigInteger("123456789012345678901234567890"), "%08d", "123456789012345678901234567890" }, //$NON-NLS-2$
2470                 { new BigInteger("123456789012345678901234567890"), "%-+,(11d", "+123.456.789.012.345.678.901.234.567.890" }, //$NON-NLS-2$
2471                 { new BigInteger("123456789012345678901234567890"), "%0 ,(11d", " 123.456.789.012.345.678.901.234.567.890" }, //$NON-NLS-2$
2472                 { new BigInteger("-9876543210987654321098765432100000"), "%d", "-9876543210987654321098765432100000" }, //$NON-NLS-2$
2473                 { new BigInteger("-9876543210987654321098765432100000"), "%10d", "-9876543210987654321098765432100000" }, //$NON-NLS-2$
2474                 { new BigInteger("-9876543210987654321098765432100000"), "%-1d", "-9876543210987654321098765432100000" }, //$NON-NLS-2$
2475                 { new BigInteger("-9876543210987654321098765432100000"), "%+d", "-9876543210987654321098765432100000" }, //$NON-NLS-2$
2476                 { new BigInteger("-9876543210987654321098765432100000"), "% d", "-9876543210987654321098765432100000" }, //$NON-NLS-2$
2477                 { new BigInteger("-9876543210987654321098765432100000"), "%,d", "-9.876.543.210.987.654.321.098.765.432.100.000" }, //$NON-NLS-2$
2478                 { new BigInteger("-9876543210987654321098765432100000"), "%(d", "(9876543210987654321098765432100000)" }, //$NON-NLS-2$
2479                 { new BigInteger("-9876543210987654321098765432100000"), "%08d", "-9876543210987654321098765432100000" }, //$NON-NLS-2$
2480                 { new BigInteger("-9876543210987654321098765432100000"), "%-+,(11d", "(9.876.543.210.987.654.321.098.765.432.100.000)" }, //$NON-NLS-2$
2481                 { new BigInteger("-9876543210987654321098765432100000"), "%0 ,(11d", "(9.876.543.210.987.654.321.098.765.432.100.000)" }, //$NON-NLS-2$
2482         };
2483 
2484         final int input = 0;
2485         final int pattern = 1;
2486         final int output = 2;
2487         Formatter f;
2488         for (int i = 0; i < tripleD.length; i++) {
2489             f = new Formatter(Locale.GERMAN);
2490             f.format((String) tripleD[i][pattern],
2491                     tripleD[i][input]);
2492             assertEquals("triple[" + i + "]:" + tripleD[i][input] + ",pattern["
2493                     + i + "]:" + tripleD[i][pattern], tripleD[i][output], f
2494                     .toString());
2495 
2496         }
2497 
2498         final Object[][] tripleO = {
2499                 { new BigInteger("123456789012345678901234567890"), "%o", "143564417755415637016711617605322" }, //$NON-NLS-2$
2500                 { new BigInteger("123456789012345678901234567890"), "%-6o", "143564417755415637016711617605322" }, //$NON-NLS-2$
2501                 { new BigInteger("123456789012345678901234567890"), "%08o", "143564417755415637016711617605322" }, //$NON-NLS-2$
2502                 { new BigInteger("123456789012345678901234567890"), "%#o", "0143564417755415637016711617605322" }, //$NON-NLS-2$
2503                 { new BigInteger("123456789012345678901234567890"), "%0#11o", "0143564417755415637016711617605322" }, //$NON-NLS-2$
2504                 { new BigInteger("123456789012345678901234567890"), "%-#9o", "0143564417755415637016711617605322" }, //$NON-NLS-2$
2505                 { new BigInteger("-9876543210987654321098765432100000"), "%o", "-36336340043453651353467270113157312240" }, //$NON-NLS-2$
2506                 { new BigInteger("-9876543210987654321098765432100000"), "%-6o", "-36336340043453651353467270113157312240" }, //$NON-NLS-2$
2507                 { new BigInteger("-9876543210987654321098765432100000"), "%08o", "-36336340043453651353467270113157312240" }, //$NON-NLS-2$
2508                 { new BigInteger("-9876543210987654321098765432100000"), "%#o", "-036336340043453651353467270113157312240" }, //$NON-NLS-2$
2509                 { new BigInteger("-9876543210987654321098765432100000"), "%0#11o", "-036336340043453651353467270113157312240" }, //$NON-NLS-2$
2510                 { new BigInteger("-9876543210987654321098765432100000"), "%-#9o", "-036336340043453651353467270113157312240" }, //$NON-NLS-2$
2511         };
2512         for (int i = 0; i < tripleO.length; i++) {
2513             f = new Formatter(Locale.ITALY);
2514             f.format((String) tripleO[i][pattern],
2515                     tripleO[i][input]);
2516             assertEquals("triple[" + i + "]:" + tripleO[i][input] + ",pattern["
2517                     + i + "]:" + tripleO[i][pattern], tripleO[i][output], f
2518                     .toString());
2519 
2520         }
2521 
2522         final Object[][] tripleX = {
2523                 { new BigInteger("123456789012345678901234567890"), "%x", "18ee90ff6c373e0ee4e3f0ad2" }, //$NON-NLS-2$
2524                 { new BigInteger("123456789012345678901234567890"), "%-8x", "18ee90ff6c373e0ee4e3f0ad2" }, //$NON-NLS-2$
2525                 { new BigInteger("123456789012345678901234567890"), "%06x", "18ee90ff6c373e0ee4e3f0ad2" }, //$NON-NLS-2$
2526                 { new BigInteger("123456789012345678901234567890"), "%#x", "0x18ee90ff6c373e0ee4e3f0ad2" }, //$NON-NLS-2$
2527                 { new BigInteger("123456789012345678901234567890"), "%0#12x", "0x18ee90ff6c373e0ee4e3f0ad2" }, //$NON-NLS-2$
2528                 { new BigInteger("123456789012345678901234567890"), "%-#9x", "0x18ee90ff6c373e0ee4e3f0ad2" }, //$NON-NLS-2$
2529                 { new BigInteger("-9876543210987654321098765432100000"), "%x", "-1e6f380472bd4bae6eb8259bd94a0" }, //$NON-NLS-2$
2530                 { new BigInteger("-9876543210987654321098765432100000"), "%-8x", "-1e6f380472bd4bae6eb8259bd94a0" }, //$NON-NLS-2$
2531                 { new BigInteger("-9876543210987654321098765432100000"), "%06x", "-1e6f380472bd4bae6eb8259bd94a0" }, //$NON-NLS-2$
2532                 { new BigInteger("-9876543210987654321098765432100000"), "%#x", "-0x1e6f380472bd4bae6eb8259bd94a0" }, //$NON-NLS-2$
2533                 { new BigInteger("-9876543210987654321098765432100000"), "%0#12x", "-0x1e6f380472bd4bae6eb8259bd94a0" }, //$NON-NLS-2$
2534                 { new BigInteger("-9876543210987654321098765432100000"), "%-#9x", "-0x1e6f380472bd4bae6eb8259bd94a0" }, //$NON-NLS-2$
2535         };
2536 
2537         for (int i = 0; i < tripleX.length; i++) {
2538             f = new Formatter(Locale.FRANCE);
2539             f.format((String) tripleX[i][pattern],
2540                     tripleX[i][input]);
2541             assertEquals("triple[" + i + "]:" + tripleX[i][input] + ",pattern["
2542                     + i + "]:" + tripleX[i][pattern], tripleX[i][output], f
2543                     .toString());
2544 
2545         }
2546 
2547         f = new Formatter(Locale.GERMAN);
2548         f.format("%(+,-7d%<( o%<+(x %<( 06X", (BigInteger) null);
2549         assertEquals("null   nullnull   NULL", f.toString());
2550     }
2551 
2552     /**
2553      * java.util.Formatter#format(String, Object...) for padding of
2554      * BigInteger conversion
2555      */
test_formatLjava_lang_String$Ljava_lang_Object_BigIntegerPaddingConversion()2556     public void test_formatLjava_lang_String$Ljava_lang_Object_BigIntegerPaddingConversion() {
2557         Formatter f = null;
2558 
2559         BigInteger bigInt = new BigInteger("123456789012345678901234567890");
2560         f = new Formatter(Locale.GERMAN);
2561         f.format("%32d", bigInt);
2562         assertEquals("  123456789012345678901234567890", f.toString());
2563 
2564         f = new Formatter(Locale.GERMAN);
2565         f.format("%+32x", bigInt);
2566         assertEquals("      +18ee90ff6c373e0ee4e3f0ad2", f.toString());
2567 
2568         f = new Formatter(Locale.GERMAN);
2569         f.format("% 32o", bigInt);
2570         assertEquals(" 143564417755415637016711617605322", f.toString());
2571 
2572         BigInteger negBigInt = new BigInteger(
2573                 "-1234567890123456789012345678901234567890");
2574         f = new Formatter(Locale.GERMAN);
2575         f.format("%( 040X", negBigInt);
2576         assertEquals("(000003A0C92075C0DBF3B8ACBC5F96CE3F0AD2)", f.toString());
2577 
2578         f = new Formatter(Locale.GERMAN);
2579         f.format("%+(045d", negBigInt);
2580         assertEquals("(0001234567890123456789012345678901234567890)", f
2581                 .toString());
2582 
2583         f = new Formatter(Locale.GERMAN);
2584         f.format("%+,-(60d", negBigInt);
2585         assertEquals(
2586                 "(1.234.567.890.123.456.789.012.345.678.901.234.567.890)     ",
2587                 f.toString());
2588     }
2589 
2590     /**
2591      * java.util.Formatter#format(String, Object...) for BigInteger
2592      * conversion exception
2593      */
test_formatLjava_lang_String$Ljava_lang_Object_BigIntegerConversionException()2594     public void test_formatLjava_lang_String$Ljava_lang_Object_BigIntegerConversionException() {
2595         Formatter f = null;
2596 
2597         final String[] flagsConversionMismatches = { "%#d", "%,o", "%,x", "%,X" };
2598         for (int i = 0; i < flagsConversionMismatches.length; i++) {
2599             try {
2600                 f = new Formatter(Locale.CHINA);
2601                 f.format(flagsConversionMismatches[i], new BigInteger("1"));
2602                 fail("should throw FormatFlagsConversionMismatchException");
2603             } catch (FormatFlagsConversionMismatchException e) {
2604                 // expected
2605             }
2606         }
2607 
2608         final String[] missingFormatWidths = { "%-0d", "%0d", "%-d", "%-0o",
2609                 "%0o", "%-o", "%-0x", "%0x", "%-x", "%-0X", "%0X", "%-X" };
2610         for (int i = 0; i < missingFormatWidths.length; i++) {
2611             try {
2612                 f = new Formatter(Locale.KOREA);
2613                 f.format(missingFormatWidths[i], new BigInteger("1"));
2614                 fail("should throw MissingFormatWidthException");
2615             } catch (MissingFormatWidthException e) {
2616                 // expected
2617             }
2618         }
2619 
2620         final String[] illFlags = { "%+ d", "%-08d", "%+ o", "%-08o", "%+ x",
2621                 "%-08x", "%+ X", "%-08X" };
2622         for (int i = 0; i < illFlags.length; i++) {
2623             try {
2624                 f = new Formatter(Locale.CANADA);
2625                 f.format(illFlags[i], new BigInteger("1"));
2626                 fail("should throw IllegalFormatFlagsException");
2627             } catch (IllegalFormatFlagsException e) {
2628                 // expected
2629             }
2630         }
2631 
2632         final String[] precisionExceptions = { "%.4d", "%2.5o", "%8.6x",
2633                 "%11.17X" };
2634         for (int i = 0; i < precisionExceptions.length; i++) {
2635             try {
2636                 f = new Formatter(Locale.US);
2637                 f.format(precisionExceptions[i], new BigInteger("1"));
2638                 fail("should throw IllegalFormatPrecisionException");
2639             } catch (IllegalFormatPrecisionException e) {
2640                 // expected
2641             }
2642         }
2643 
2644         f = new Formatter(Locale.US);
2645         try {
2646             f.format("%D", new BigInteger("1"));
2647             fail("should throw UnknownFormatConversionException");
2648         } catch (UnknownFormatConversionException e) {
2649             // expected
2650         }
2651 
2652         f = new Formatter(Locale.US);
2653         try {
2654             f.format("%O", new BigInteger("1"));
2655             fail("should throw UnknownFormatConversionException");
2656         } catch (UnknownFormatConversionException e) {
2657             // expected
2658         }
2659 
2660         try {
2661             f = new Formatter();
2662             f.format("%010000000000000000000000000000000001d", new BigInteger(
2663                     "1"));
2664             fail("should throw MissingFormatWidthException");
2665         } catch (MissingFormatWidthException e) {
2666             // expected
2667         }
2668     }
2669 
2670     /**
2671      * java.util.Formatter#format(String, Object...) for BigInteger
2672      * exception throwing order
2673      */
test_formatLjava_lang_String$Ljava_lang_Object_BigIntegerExceptionOrder()2674     public void test_formatLjava_lang_String$Ljava_lang_Object_BigIntegerExceptionOrder() {
2675         Formatter f = null;
2676         BigInteger big = new BigInteger("100");
2677 
2678         /*
2679          * Order summary: UnknownFormatConversionException >
2680          * MissingFormatWidthException > IllegalFormatFlagsException >
2681          * IllegalFormatPrecisionException > IllegalFormatConversionException >
2682          * FormatFlagsConversionMismatchException
2683          *
2684          */
2685         f = new Formatter(Locale.US);
2686         try {
2687             f.format("%(o", false);
2688             fail();
2689         } catch (FormatFlagsConversionMismatchException expected) {
2690         } catch (IllegalFormatConversionException expected) {
2691         }
2692 
2693         try {
2694             f.format("%.4o", false);
2695             fail();
2696         } catch (IllegalFormatPrecisionException expected) {
2697         } catch (IllegalFormatConversionException expected) {
2698         }
2699 
2700         try {
2701             f.format("%+ .4o", big);
2702             fail();
2703         } catch (IllegalFormatPrecisionException expected) {
2704         } catch (IllegalFormatFlagsException expected) {
2705         }
2706 
2707         try {
2708             f.format("%+ -o", big);
2709             fail();
2710         } catch (MissingFormatWidthException expected) {
2711         } catch (IllegalFormatFlagsException expected) {
2712         }
2713 
2714         try {
2715             f.format("%-O", big);
2716             fail();
2717         } catch (MissingFormatWidthException expected) {
2718         } catch (UnknownFormatConversionException expected) {
2719         }
2720     }
2721 
2722     /**
2723      * java.util.Formatter#format(String, Object...) for Float/Double
2724      * conversion type 'e' and 'E'
2725      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionE()2726     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionE() {
2727         Formatter f = null;
2728         final Object[][] tripleE = {
2729                 { 0f, "%e", "0.000000e+00" },
2730                 { 0f, "%#.0e", "0.e+00" },
2731                 { 0f, "%#- (9.8e", " 0.00000000e+00" },
2732                 { 0f, "%#+0(8.4e", "+0.0000e+00" },
2733                 { 0f, "%-+(1.6e", "+0.000000e+00" },
2734                 { 0f, "% 0(12e", " 0.000000e+00" },
2735 
2736                 { 101f, "%e", "1.010000e+02" },
2737                 { 101f, "%#.0e", "1.e+02" },
2738                 { 101f, "%#- (9.8e", " 1.01000000e+02" },
2739                 { 101f, "%#+0(8.4e", "+1.0100e+02" },
2740                 { 101f, "%-+(1.6e", "+1.010000e+02" },
2741                 { 101f, "% 0(12e", " 1.010000e+02" },
2742 
2743                 { 1.f, "%e", "1.000000e+00" },
2744                 { 1.f, "%#.0e", "1.e+00" },
2745                 { 1.f, "%#- (9.8e", " 1.00000000e+00" },
2746                 { 1.f, "%#+0(8.4e", "+1.0000e+00" },
2747                 { 1.f, "%-+(1.6e", "+1.000000e+00" },
2748                 { 1.f, "% 0(12e", " 1.000000e+00" },
2749 
2750                 { -98f, "%e", "-9.800000e+01" },
2751                 { -98f, "%#.0e", "-1.e+02" },
2752                 { -98f, "%#- (9.8e", "(9.80000000e+01)" },
2753                 { -98f, "%#+0(8.4e", "(9.8000e+01)" },
2754                 { -98f, "%-+(1.6e", "(9.800000e+01)" },
2755                 { -98f, "% 0(12e", "(9.800000e+01)" },
2756 
2757                 { 1.23f, "%e", "1.230000e+00" },
2758                 { 1.23f, "%#.0e", "1.e+00" },
2759                 { 1.23f, "%#- (9.8e", " 1.23000002e+00" },
2760                 { 1.23f, "%#+0(8.4e", "+1.2300e+00" },
2761                 { 1.23f, "%-+(1.6e", "+1.230000e+00" },
2762                 { 1.23f, "% 0(12e", " 1.230000e+00" },
2763 
2764                 { 34.1234567f, "%e", "3.412346e+01" },
2765                 { 34.1234567f, "%#.0e", "3.e+01" },
2766                 { 34.1234567f, "%#- (9.8e", " 3.41234550e+01" },
2767                 { 34.1234567f, "%#+0(8.4e", "+3.4123e+01" },
2768                 { 34.1234567f, "%-+(1.6e", "+3.412346e+01" },
2769                 { 34.1234567f, "% 0(12e", " 3.412346e+01" },
2770 
2771                 { -.12345f, "%e", "-1.234500e-01" },
2772                 { -.12345f, "%#.0e", "-1.e-01" },
2773                 { -.12345f, "%#- (9.8e", "(1.23450004e-01)" },
2774                 { -.12345f, "%#+0(8.4e", "(1.2345e-01)" },
2775                 { -.12345f, "%-+(1.6e", "(1.234500e-01)" },
2776                 { -.12345f, "% 0(12e", "(1.234500e-01)" },
2777 
2778                 { -9876.1234567f, "%e", "-9.876123e+03" },
2779                 { -9876.1234567f, "%#.0e", "-1.e+04" },
2780                 { -9876.1234567f, "%#- (9.8e", "(9.87612305e+03)" },
2781                 { -9876.1234567f, "%#+0(8.4e", "(9.8761e+03)" },
2782                 { -9876.1234567f, "%-+(1.6e", "(9.876123e+03)" },
2783                 { -9876.1234567f, "% 0(12e", "(9.876123e+03)" },
2784 
2785                 { Float.MAX_VALUE, "%e", "3.402823e+38" },
2786                 { Float.MAX_VALUE, "%#.0e", "3.e+38" },
2787                 { Float.MAX_VALUE, "%#- (9.8e", " 3.40282347e+38" },
2788                 { Float.MAX_VALUE, "%#+0(8.4e", "+3.4028e+38" },
2789                 { Float.MAX_VALUE, "%-+(1.6e", "+3.402823e+38" },
2790                 { Float.MAX_VALUE, "% 0(12e", " 3.402823e+38" },
2791 
2792                 { Float.MIN_VALUE, "%e", "1.401298e-45" },
2793                 { Float.MIN_VALUE, "%#.0e", "1.e-45" },
2794                 { Float.MIN_VALUE, "%#- (9.8e", " 1.40129846e-45" },
2795                 { Float.MIN_VALUE, "%#+0(8.4e", "+1.4013e-45" },
2796                 { Float.MIN_VALUE, "%-+(1.6e", "+1.401298e-45" },
2797                 { Float.MIN_VALUE, "% 0(12e", " 1.401298e-45" },
2798 
2799                 { Float.NaN, "%e", "NaN" },
2800                 { Float.NaN, "%#.0e", "NaN" },
2801                 { Float.NaN, "%#- (9.8e", "NaN      " },
2802                 { Float.NaN, "%#+0(8.4e", "     NaN" },
2803                 { Float.NaN, "%-+(1.6e", "NaN" },
2804                 { Float.NaN, "% 0(12e", "         NaN" },
2805 
2806 
2807                 { Float.NEGATIVE_INFINITY, "%e", "-Infinity" },
2808                 { Float.NEGATIVE_INFINITY, "%#.0e", "-Infinity" },
2809                 { Float.NEGATIVE_INFINITY, "%#- (9.8e", "(Infinity)" },
2810                 { Float.NEGATIVE_INFINITY, "%#+0(8.4e", "(Infinity)" },
2811                 { Float.NEGATIVE_INFINITY, "%-+(1.6e", "(Infinity)" },
2812                 { Float.NEGATIVE_INFINITY, "% 0(12e", "  (Infinity)" },
2813 
2814                 { Float.NEGATIVE_INFINITY, "%e", "-Infinity" },
2815                 { Float.NEGATIVE_INFINITY, "%#.0e", "-Infinity" },
2816                 { Float.NEGATIVE_INFINITY, "%#- (9.8e", "(Infinity)" },
2817                 { Float.NEGATIVE_INFINITY, "%#+0(8.4e", "(Infinity)" },
2818                 { Float.NEGATIVE_INFINITY, "%-+(1.6e", "(Infinity)" },
2819                 { Float.NEGATIVE_INFINITY, "% 0(12e", "  (Infinity)" },
2820 
2821                 { 0d, "%e", "0.000000e+00" },
2822                 { 0d, "%#.0e", "0.e+00" },
2823                 { 0d, "%#- (9.8e", " 0.00000000e+00" },
2824                 { 0d, "%#+0(8.4e", "+0.0000e+00" },
2825                 { 0d, "%-+(1.6e", "+0.000000e+00" },
2826                 { 0d, "% 0(12e", " 0.000000e+00" },
2827 
2828                 { 1d, "%e", "1.000000e+00" },
2829                 { 1d, "%#.0e", "1.e+00" },
2830                 { 1d, "%#- (9.8e", " 1.00000000e+00" },
2831                 { 1d, "%#+0(8.4e", "+1.0000e+00" },
2832                 { 1d, "%-+(1.6e", "+1.000000e+00" },
2833                 { 1d, "% 0(12e", " 1.000000e+00" },
2834 
2835                 { -1d, "%e", "-1.000000e+00" },
2836                 { -1d, "%#.0e", "-1.e+00" },
2837                 { -1d, "%#- (9.8e", "(1.00000000e+00)" },
2838                 { -1d, "%#+0(8.4e", "(1.0000e+00)" },
2839                 { -1d, "%-+(1.6e", "(1.000000e+00)" },
2840                 { -1d, "% 0(12e", "(1.000000e+00)" },
2841 
2842 
2843                 { .00000001d, "%e", "1.000000e-08" },
2844                 { .00000001d, "%#.0e", "1.e-08" },
2845                 { .00000001d, "%#- (9.8e", " 1.00000000e-08" },
2846                 { .00000001d, "%#+0(8.4e", "+1.0000e-08" },
2847                 { .00000001d, "%-+(1.6e", "+1.000000e-08" },
2848                 { .00000001d, "% 0(12e", " 1.000000e-08" },
2849 
2850                 { 9122.10d, "%e", "9.122100e+03" },
2851                 { 9122.10d, "%#.0e", "9.e+03" },
2852                 { 9122.10d, "%#- (9.8e", " 9.12210000e+03" },
2853                 { 9122.10d, "%#+0(8.4e", "+9.1221e+03" },
2854                 { 9122.10d, "%-+(1.6e", "+9.122100e+03" },
2855                 { 9122.10d, "% 0(12e", " 9.122100e+03" },
2856 
2857                 { 0.1d, "%e", "1.000000e-01" },
2858                 { 0.1d, "%#.0e", "1.e-01" },
2859                 { 0.1d, "%#- (9.8e", " 1.00000000e-01" },
2860                 { 0.1d, "%#+0(8.4e", "+1.0000e-01" },
2861                 { 0.1d, "%-+(1.6e", "+1.000000e-01" },
2862                 { 0.1d, "% 0(12e", " 1.000000e-01" },
2863 
2864                 { -2.d, "%e", "-2.000000e+00" },
2865                 { -2.d, "%#.0e", "-2.e+00" },
2866                 { -2.d, "%#- (9.8e", "(2.00000000e+00)" },
2867                 { -2.d, "%#+0(8.4e", "(2.0000e+00)" },
2868                 { -2.d, "%-+(1.6e", "(2.000000e+00)" },
2869                 { -2.d, "% 0(12e", "(2.000000e+00)" },
2870 
2871                 { -.39d, "%e", "-3.900000e-01" },
2872                 { -.39d, "%#.0e", "-4.e-01" },
2873                 { -.39d, "%#- (9.8e", "(3.90000000e-01)" },
2874                 { -.39d, "%#+0(8.4e", "(3.9000e-01)" },
2875                 { -.39d, "%-+(1.6e", "(3.900000e-01)" },
2876                 { -.39d, "% 0(12e", "(3.900000e-01)" },
2877 
2878                 { -1234567890.012345678d, "%e", "-1.234568e+09" },
2879                 { -1234567890.012345678d, "%#.0e", "-1.e+09" },
2880                 { -1234567890.012345678d, "%#- (9.8e", "(1.23456789e+09)" },
2881                 { -1234567890.012345678d, "%#+0(8.4e", "(1.2346e+09)" },
2882                 { -1234567890.012345678d, "%-+(1.6e", "(1.234568e+09)" },
2883                 { -1234567890.012345678d, "% 0(12e", "(1.234568e+09)" },
2884 
2885                 { Double.MAX_VALUE, "%e", "1.797693e+308" },
2886                 { Double.MAX_VALUE, "%#.0e", "2.e+308" },
2887                 { Double.MAX_VALUE, "%#- (9.8e", " 1.79769313e+308" },
2888                 { Double.MAX_VALUE, "%#+0(8.4e", "+1.7977e+308" },
2889                 { Double.MAX_VALUE, "%-+(1.6e", "+1.797693e+308" },
2890                 { Double.MAX_VALUE, "% 0(12e", " 1.797693e+308" },
2891 
2892                 { Double.MIN_VALUE, "%e", "4.900000e-324" },
2893                 { Double.MIN_VALUE, "%#.0e", "5.e-324" },
2894                 { Double.MIN_VALUE, "%#- (9.8e", " 4.90000000e-324" },
2895                 { Double.MIN_VALUE, "%#+0(8.4e", "+4.9000e-324" },
2896                 { Double.MIN_VALUE, "%-+(1.6e", "+4.900000e-324" },
2897                 { Double.MIN_VALUE, "% 0(12e", " 4.900000e-324" },
2898 
2899                 { Double.NaN, "%e", "NaN" },
2900                 { Double.NaN, "%#.0e", "NaN" },
2901                 { Double.NaN, "%#- (9.8e", "NaN      " },
2902                 { Double.NaN, "%#+0(8.4e", "     NaN" },
2903                 { Double.NaN, "%-+(1.6e", "NaN" },
2904                 { Double.NaN, "% 0(12e", "         NaN" },
2905 
2906                 { Double.NEGATIVE_INFINITY, "%e", "-Infinity" },
2907                 { Double.NEGATIVE_INFINITY, "%#.0e", "-Infinity" },
2908                 { Double.NEGATIVE_INFINITY, "%#- (9.8e", "(Infinity)" },
2909                 { Double.NEGATIVE_INFINITY, "%#+0(8.4e", "(Infinity)" },
2910                 { Double.NEGATIVE_INFINITY, "%-+(1.6e", "(Infinity)" },
2911                 { Double.NEGATIVE_INFINITY, "% 0(12e", "  (Infinity)" },
2912 
2913                 { Double.POSITIVE_INFINITY, "%e", "Infinity" },
2914                 { Double.POSITIVE_INFINITY, "%#.0e", "Infinity" },
2915                 { Double.POSITIVE_INFINITY, "%#- (9.8e", " Infinity" },
2916                 { Double.POSITIVE_INFINITY, "%#+0(8.4e", "+Infinity" },
2917                 { Double.POSITIVE_INFINITY, "%-+(1.6e", "+Infinity" },
2918                 { Double.POSITIVE_INFINITY, "% 0(12e", "    Infinity" },
2919         };
2920         final int input = 0;
2921         final int pattern = 1;
2922         final int output = 2;
2923         for (int i = 0; i < tripleE.length; i++) {
2924             f = new Formatter(Locale.US);
2925             f.format((String) tripleE[i][pattern], tripleE[i][input]);
2926             assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern["
2927                     + i + "]:" + tripleE[i][pattern],
2928                     tripleE[i][output], f.toString());
2929 
2930             // test for conversion type 'E'
2931             f = new Formatter(Locale.US);
2932             f.format(((String) tripleE[i][pattern]).toUpperCase(), tripleE[i][input]);
2933             assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern["
2934                     + i + "]:" + tripleE[i][pattern], ((String) tripleE[i][output])
2935                     .toUpperCase(Locale.UK), f.toString());
2936         }
2937 
2938         f = new Formatter(Locale.GERMAN);
2939         f.format("%e", 1001f);
2940         /*
2941          * fail on RI, spec says 'e' requires the output to be formatted in
2942          * general scientific notation and the localization algorithm is
2943          * applied. But RI format this case to 1.001000e+03, which does not
2944          * conform to the German Locale
2945          */
2946         assertEquals("1,001000e+03", f.toString());
2947     }
2948 
2949     /**
2950      * java.util.Formatter#format(String, Object...) for Float/Double
2951      * conversion type 'g' and 'G'
2952      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionG()2953     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionG() {
2954         Formatter f = null;
2955         final Object[][] tripleG = {
2956                 { 1001f, "%g", "1001.00" },
2957                 { 1001f, "%- (,9.8g", " 1,001.0000" },
2958                 { 1001f, "%+0(,8.4g", "+001,001" },
2959                 { 1001f, "%-+(,1.6g", "+1,001.00" },
2960                 { 1001f, "% 0(,12.0g", " 0000001e+03" },
2961 
2962                 { 1.f, "%g", "1.00000" },
2963                 { 1.f, "%- (,9.8g", " 1.0000000" },
2964                 { 1.f, "%+0(,8.4g", "+001.000" },
2965                 { 1.f, "%-+(,1.6g", "+1.00000" },
2966                 { 1.f, "% 0(,12.0g", " 00000000001" },
2967 
2968                 { -98f, "%g", "-98.0000" },
2969                 { -98f, "%- (,9.8g", "(98.000000)" },
2970                 { -98f, "%+0(,8.4g", "(098.00)" },
2971                 { -98f, "%-+(,1.6g", "(98.0000)" },
2972                 { -98f, "% 0(,12.0g", "(000001e+02)" },
2973 
2974                 { 0.000001f, "%g", "1.00000e-06" },
2975                 { 0.000001f, "%- (,9.8g", " 1.0000000e-06" },
2976                 { 0.000001f, "%+0(,8.4g", "+1.000e-06" },
2977                 { 0.000001f, "%-+(,1.6g", "+1.00000e-06" },
2978                 { 0.000001f, "% 0(,12.0g", " 0000001e-06" },
2979 
2980                 { 345.1234567f, "%g", "345.123" },
2981                 { 345.1234567f, "%- (,9.8g", " 345.12344" },
2982                 { 345.1234567f, "%+0(,8.4g", "+00345.1" },
2983                 { 345.1234567f, "%-+(,1.6g", "+345.123" },
2984                 { 345.1234567f, "% 0(,12.0g", " 0000003e+02" },
2985 
2986                 { -.00000012345f, "%g", "-1.23450e-07" },
2987                 { -.00000012345f, "%- (,9.8g", "(1.2344999e-07)" },
2988                 { -.00000012345f, "%+0(,8.4g", "(1.234e-07)" },
2989                 { -.00000012345f, "%-+(,1.6g", "(1.23450e-07)" },
2990                 { -.00000012345f, "% 0(,12.0g", "(000001e-07)" },
2991 
2992                 { -987.1234567f, "%g", "-987.123" },
2993                 { -987.1234567f, "%- (,9.8g", "(987.12347)" },
2994                 { -987.1234567f, "%+0(,8.4g", "(0987.1)" },
2995                 { -987.1234567f, "%-+(,1.6g", "(987.123)" },
2996                 { -987.1234567f, "% 0(,12.0g", "(000001e+03)" },
2997 
2998                 { Float.MAX_VALUE, "%g", "3.40282e+38" },
2999                 { Float.MAX_VALUE, "%- (,9.8g", " 3.4028235e+38" },
3000                 { Float.MAX_VALUE, "%+0(,8.4g", "+3.403e+38" },
3001                 { Float.MAX_VALUE, "%-+(,1.6g", "+3.40282e+38" },
3002                 { Float.MAX_VALUE, "% 0(,12.0g", " 0000003e+38" },
3003 
3004                 { Float.MIN_VALUE, "%g", "1.40130e-45" },
3005                 { Float.MIN_VALUE, "%- (,9.8g", " 1.4012985e-45" },
3006                 { Float.MIN_VALUE, "%+0(,8.4g", "+1.401e-45" },
3007                 { Float.MIN_VALUE, "%-+(,1.6g", "+1.40130e-45" },
3008                 { Float.MIN_VALUE, "% 0(,12.0g", " 0000001e-45" },
3009 
3010                 { Float.NaN, "%g", "NaN" },
3011                 { Float.NaN, "%- (,9.8g", "NaN      " },
3012                 { Float.NaN, "%+0(,8.4g", "     NaN" },
3013                 { Float.NaN, "%-+(,1.6g", "NaN" },
3014                 { Float.NaN, "% 0(,12.0g", "         NaN" },
3015 
3016                 { Float.NEGATIVE_INFINITY, "%g", "-Infinity" },
3017                 { Float.NEGATIVE_INFINITY, "%- (,9.8g", "(Infinity)" },
3018                 { Float.NEGATIVE_INFINITY, "%+0(,8.4g", "(Infinity)" },
3019                 { Float.NEGATIVE_INFINITY, "%-+(,1.6g", "(Infinity)" },
3020                 { Float.NEGATIVE_INFINITY, "% 0(,12.0g", "  (Infinity)" },
3021 
3022                 { Float.POSITIVE_INFINITY, "%g", "Infinity" },
3023                 { Float.POSITIVE_INFINITY, "%- (,9.8g", " Infinity" },
3024                 { Float.POSITIVE_INFINITY, "%+0(,8.4g", "+Infinity" },
3025                 { Float.POSITIVE_INFINITY, "%-+(,1.6g", "+Infinity" },
3026                 { Float.POSITIVE_INFINITY, "% 0(,12.0g", "    Infinity" },
3027 
3028                 { 1d, "%g", "1.00000" },
3029                 { 1d, "%- (,9.8g", " 1.0000000" },
3030                 { 1d, "%+0(,8.4g", "+001.000" },
3031                 { 1d, "%-+(,1.6g", "+1.00000" },
3032                 { 1d, "% 0(,12.0g", " 00000000001" },
3033 
3034                 { -1d, "%g", "-1.00000" },
3035                 { -1d, "%- (,9.8g", "(1.0000000)" },
3036                 { -1d, "%+0(,8.4g", "(01.000)" },
3037                 { -1d, "%-+(,1.6g", "(1.00000)" },
3038                 { -1d, "% 0(,12.0g", "(0000000001)" },
3039 
3040                 { .00000001d, "%g", "1.00000e-08" },
3041                 { .00000001d, "%- (,9.8g", " 1.0000000e-08" },
3042                 { .00000001d, "%+0(,8.4g", "+1.000e-08" },
3043                 { .00000001d, "%-+(,1.6g", "+1.00000e-08" },
3044                 { .00000001d, "% 0(,12.0g", " 0000001e-08" },
3045 
3046                 { 1912.10d, "%g", "1912.10" },
3047                 { 1912.10d, "%- (,9.8g", " 1,912.1000" },
3048                 { 1912.10d, "%+0(,8.4g", "+001,912" },
3049                 { 1912.10d, "%-+(,1.6g", "+1,912.10" },
3050                 { 1912.10d, "% 0(,12.0g", " 0000002e+03" },
3051 
3052                 { 0.1d, "%g", "0.100000" },
3053                 { 0.1d, "%- (,9.8g", " 0.10000000" },
3054                 { 0.1d, "%+0(,8.4g", "+00.1000" },
3055                 { 0.1d, "%-+(,1.6g", "+0.100000" },
3056                 { 0.1d, "% 0(,12.0g", " 000000000.1" },
3057 
3058                 { -2.d, "%g", "-2.00000" },
3059                 { -2.d, "%- (,9.8g", "(2.0000000)" },
3060                 { -2.d, "%+0(,8.4g", "(02.000)" },
3061                 { -2.d, "%-+(,1.6g", "(2.00000)" },
3062                 { -2.d, "% 0(,12.0g", "(0000000002)" },
3063 
3064                 { -.00039d, "%g", "-0.000390000" },
3065                 { -.00039d, "%- (,9.8g", "(0.00039000000)" },
3066                 { -.00039d, "%+0(,8.4g", "(0.0003900)" },
3067                 { -.00039d, "%-+(,1.6g", "(0.000390000)" },
3068                 { -.00039d, "% 0(,12.0g", "(00000.0004)" },
3069 
3070                 { -1234567890.012345678d, "%g", "-1.23457e+09" },
3071                 { -1234567890.012345678d, "%- (,9.8g", "(1.2345679e+09)" },
3072                 { -1234567890.012345678d, "%+0(,8.4g", "(1.235e+09)" },
3073                 { -1234567890.012345678d, "%-+(,1.6g", "(1.23457e+09)" },
3074                 { -1234567890.012345678d, "% 0(,12.0g", "(000001e+09)" },
3075 
3076                 { Double.MAX_VALUE, "%g", "1.79769e+308" },
3077                 { Double.MAX_VALUE, "%- (,9.8g", " 1.7976931e+308" },
3078                 { Double.MAX_VALUE, "%+0(,8.4g", "+1.798e+308" },
3079                 { Double.MAX_VALUE, "%-+(,1.6g", "+1.79769e+308" },
3080                 { Double.MAX_VALUE, "% 0(,12.0g", " 000002e+308" },
3081 
3082                 { Double.MIN_VALUE, "%g", "4.90000e-324" },
3083                 { Double.MIN_VALUE, "%- (,9.8g", " 4.9000000e-324" },
3084                 { Double.MIN_VALUE, "%+0(,8.4g", "+4.900e-324" },
3085                 { Double.MIN_VALUE, "%-+(,1.6g", "+4.90000e-324" },
3086                 { Double.MIN_VALUE, "% 0(,12.0g", " 000005e-324" },
3087 
3088                 { Double.NaN, "%g", "NaN" },
3089                 { Double.NaN, "%- (,9.8g", "NaN      " },
3090                 { Double.NaN, "%+0(,8.4g", "     NaN" },
3091                 { Double.NaN, "%-+(,1.6g", "NaN" },
3092                 { Double.NaN, "% 0(,12.0g", "         NaN" },
3093 
3094                 { Double.NEGATIVE_INFINITY, "%g", "-Infinity" },
3095                 { Double.NEGATIVE_INFINITY, "%- (,9.8g", "(Infinity)" },
3096                 { Double.NEGATIVE_INFINITY, "%+0(,8.4g", "(Infinity)" },
3097                 { Double.NEGATIVE_INFINITY, "%-+(,1.6g", "(Infinity)" },
3098                 { Double.NEGATIVE_INFINITY, "% 0(,12.0g", "  (Infinity)" },
3099 
3100                 { Double.POSITIVE_INFINITY, "%g", "Infinity" },
3101                 { Double.POSITIVE_INFINITY, "%- (,9.8g", " Infinity" },
3102                 { Double.POSITIVE_INFINITY, "%+0(,8.4g", "+Infinity" },
3103                 { Double.POSITIVE_INFINITY, "%-+(,1.6g", "+Infinity" },
3104                 { Double.POSITIVE_INFINITY, "% 0(,12.0g", "    Infinity" },
3105 
3106         };
3107         final int input = 0;
3108         final int pattern = 1;
3109         final int output = 2;
3110         for (int i = 0; i < tripleG.length; i++) {
3111 
3112             f = new Formatter(Locale.US);
3113             f.format((String) tripleG[i][pattern], tripleG[i][input]);
3114             assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern["
3115                     + i + "]:" + tripleG[i][pattern],
3116                     tripleG[i][output], f.toString());
3117 
3118             // test for conversion type 'G'
3119             f = new Formatter(Locale.US);
3120             f.format(((String) tripleG[i][pattern]).toUpperCase(), tripleG[i][input]);
3121             assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern["
3122                     + i + "]:" + tripleG[i][pattern], ((String) tripleG[i][output])
3123                     .toUpperCase(Locale.UK), f.toString());
3124         }
3125 
3126         f = new Formatter(Locale.US);
3127         f.format("%.5g", 0f);
3128         assertEquals("0.0000", f.toString());
3129 
3130         f = new Formatter(Locale.US);
3131         f.format("%.0g", 0f);
3132         /*
3133          * fail on RI, spec says if the precision is 0, then it is taken to be
3134          * 1. but RI throws ArrayIndexOutOfBoundsException.
3135          */
3136         assertEquals("0", f.toString());
3137 
3138         f = new Formatter(Locale.GERMAN);
3139         f.format("%g", 1001f);
3140         /*
3141          * fail on RI, spec says 'g' requires the output to be formatted in
3142          * general scientific notation and the localization algorithm is
3143          * applied. But RI format this case to 1001.00, which does not conform
3144          * to the German Locale
3145          */
3146         assertEquals("1001,00", f.toString());
3147     }
3148 
3149     /**
3150      * java.util.Formatter#format(String, Object...) for Float/Double
3151      * conversion type 'g' and 'G' overflow
3152      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionG_Overflow()3153     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionG_Overflow() {
3154         Formatter f = new Formatter();
3155         f.format("%g", 999999.5);
3156         assertEquals("1.00000e+06", f.toString());
3157 
3158         f = new Formatter();
3159         f.format("%g", 99999.5);
3160         assertEquals("99999.5", f.toString());
3161 
3162         f = new Formatter();
3163         f.format("%.4g", 99.95);
3164         assertEquals("99.95", f.toString());
3165 
3166         f = new Formatter();
3167         f.format("%g", 99.95);
3168         assertEquals("99.9500", f.toString());
3169 
3170         f = new Formatter();
3171         f.format("%g", 0.9);
3172         assertEquals("0.900000", f.toString());
3173 
3174         f = new Formatter();
3175         f.format("%.0g", 0.000095);
3176         assertEquals("0.0001", f.toString());
3177 
3178         f = new Formatter();
3179         f.format("%g", 0.0999999);
3180         assertEquals("0.0999999", f.toString());
3181 
3182         f = new Formatter();
3183         f.format("%g", 0.00009);
3184         assertEquals("9.00000e-05", f.toString());
3185     }
3186 
3187     /**
3188      * java.util.Formatter#format(String, Object...) for Float/Double
3189      * conversion type 'f'
3190      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionF()3191     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionF() {
3192         Formatter f = null;
3193 
3194         final Object[][] tripleF = {
3195                 { 0f, "%f", "0,000000" },
3196                 { 0f, "%#.3f", "0,000" },
3197                 { 0f, "%,5f", "0,000000" },
3198                 { 0f, "%- (12.0f", " 0          " },
3199                 { 0f, "%#+0(1.6f", "+0,000000" },
3200                 { 0f, "%-+(8.4f", "+0,0000 " },
3201                 { 0f, "% 0#(9.8f", " 0,00000000" },
3202 
3203                 { 1234f, "%f", "1234,000000" },
3204                 { 1234f, "%#.3f", "1234,000" },
3205                 { 1234f, "%,5f", "1.234,000000" },
3206                 { 1234f, "%- (12.0f", " 1234       " },
3207                 { 1234f, "%#+0(1.6f", "+1234,000000" },
3208                 { 1234f, "%-+(8.4f", "+1234,0000" },
3209                 { 1234f, "% 0#(9.8f", " 1234,00000000" },
3210 
3211                 { 1.f, "%f", "1,000000" },
3212                 { 1.f, "%#.3f", "1,000" },
3213                 { 1.f, "%,5f", "1,000000" },
3214                 { 1.f, "%- (12.0f", " 1          " },
3215                 { 1.f, "%#+0(1.6f", "+1,000000" },
3216                 { 1.f, "%-+(8.4f", "+1,0000 " },
3217                 { 1.f, "% 0#(9.8f", " 1,00000000" },
3218 
3219                 { -98f, "%f", "-98,000000" },
3220                 { -98f, "%#.3f", "-98,000" },
3221                 { -98f, "%,5f", "-98,000000" },
3222                 { -98f, "%- (12.0f", "(98)        " },
3223                 { -98f, "%#+0(1.6f", "(98,000000)" },
3224                 { -98f, "%-+(8.4f", "(98,0000)" },
3225                 { -98f, "% 0#(9.8f", "(98,00000000)" },
3226 
3227                 { 0.000001f, "%f", "0,000001" },
3228                 { 0.000001f, "%#.3f", "0,000" },
3229                 { 0.000001f, "%,5f", "0,000001" },
3230                 { 0.000001f, "%- (12.0f", " 0          " },
3231                 { 0.000001f, "%#+0(1.6f", "+0,000001" },
3232                 { 0.000001f, "%-+(8.4f", "+0,0000 " },
3233                 { 0.000001f, "% 0#(9.8f", " 0,00000100" },
3234 
3235                 { 345.1234567f, "%f", "345,123444" },
3236                 { 345.1234567f, "%#.3f", "345,123" },
3237                 { 345.1234567f, "%,5f", "345,123444" },
3238                 { 345.1234567f, "%- (12.0f", " 345        " },
3239                 { 345.1234567f, "%#+0(1.6f", "+345,123444" },
3240                 { 345.1234567f, "%-+(8.4f", "+345,1234" },
3241                 { 345.1234567f, "% 0#(9.8f", " 345,12344360" },
3242 
3243                 { -.00000012345f, "%f", "-0,000000" },
3244                 { -.00000012345f, "%#.3f", "-0,000" },
3245                 { -.00000012345f, "%,5f", "-0,000000" },
3246                 { -.00000012345f, "%- (12.0f", "(0)         " },
3247                 { -.00000012345f, "%#+0(1.6f", "(0,000000)" },
3248                 { -.00000012345f, "%-+(8.4f", "(0,0000)" },
3249                 { -.00000012345f, "% 0#(9.8f", "(0,00000012)" },
3250 
3251                 { -987654321.1234567f, "%f", "-987654336,000000" },
3252                 { -987654321.1234567f, "%#.3f", "-987654336,000" },
3253                 { -987654321.1234567f, "%,5f", "-987.654.336,000000" },
3254                 { -987654321.1234567f, "%- (12.0f", "(987654336) " },
3255                 { -987654321.1234567f, "%#+0(1.6f", "(987654336,000000)" },
3256                 { -987654321.1234567f, "%-+(8.4f", "(987654336,0000)" },
3257                 { -987654321.1234567f, "% 0#(9.8f", "(987654336,00000000)" },
3258 
3259                 { Float.MAX_VALUE, "%f", "340282346638528860000000000000000000000,000000" },
3260                 { Float.MAX_VALUE, "%#.3f", "340282346638528860000000000000000000000,000" },
3261                 { Float.MAX_VALUE, "%,5f", "340.282.346.638.528.860.000.000.000.000.000.000.000,000000" },
3262                 { Float.MAX_VALUE, "%- (12.0f", " 340282346638528860000000000000000000000" },
3263                 { Float.MAX_VALUE, "%#+0(1.6f", "+340282346638528860000000000000000000000,000000" },
3264                 { Float.MAX_VALUE, "%-+(8.4f", "+340282346638528860000000000000000000000,0000" },
3265                 { Float.MAX_VALUE, "% 0#(9.8f", " 340282346638528860000000000000000000000,00000000" },
3266 
3267                 { Float.MIN_VALUE, "%f", "0,000000" },
3268                 { Float.MIN_VALUE, "%#.3f", "0,000" },
3269                 { Float.MIN_VALUE, "%,5f", "0,000000" },
3270                 { Float.MIN_VALUE, "%- (12.0f", " 0          " },
3271                 { Float.MIN_VALUE, "%#+0(1.6f", "+0,000000" },
3272                 { Float.MIN_VALUE, "%-+(8.4f", "+0,0000 " },
3273                 { Float.MIN_VALUE, "% 0#(9.8f", " 0,00000000" },
3274 
3275                 { Float.NaN, "%f", "NaN" },
3276                 { Float.NaN, "%#.3f", "NaN" },
3277                 { Float.NaN, "%,5f", "  NaN" },
3278                 { Float.NaN, "%- (12.0f", "NaN         " },
3279                 { Float.NaN, "%#+0(1.6f", "NaN" },
3280                 { Float.NaN, "%-+(8.4f", "NaN     " },
3281                 { Float.NaN, "% 0#(9.8f", "      NaN" },
3282 
3283                 { Float.NEGATIVE_INFINITY, "%f", "-Infinity" },
3284                 { Float.NEGATIVE_INFINITY, "%#.3f", "-Infinity" },
3285                 { Float.NEGATIVE_INFINITY, "%,5f", "-Infinity" },
3286                 { Float.NEGATIVE_INFINITY, "%- (12.0f", "(Infinity)  " },
3287                 { Float.NEGATIVE_INFINITY, "%#+0(1.6f", "(Infinity)" },
3288                 { Float.NEGATIVE_INFINITY, "%-+(8.4f", "(Infinity)" },
3289                 { Float.NEGATIVE_INFINITY, "% 0#(9.8f", "(Infinity)" },
3290 
3291                 { Float.POSITIVE_INFINITY, "%f", "Infinity" },
3292                 { Float.POSITIVE_INFINITY, "%#.3f", "Infinity" },
3293                 { Float.POSITIVE_INFINITY, "%,5f", "Infinity" },
3294                 { Float.POSITIVE_INFINITY, "%- (12.0f", " Infinity   " },
3295                 { Float.POSITIVE_INFINITY, "%#+0(1.6f", "+Infinity" },
3296                 { Float.POSITIVE_INFINITY, "%-+(8.4f", "+Infinity" },
3297                 { Float.POSITIVE_INFINITY, "% 0#(9.8f", " Infinity" },
3298 
3299 
3300                 { 0d, "%f", "0,000000" },
3301                 { 0d, "%#.3f", "0,000" },
3302                 { 0d, "%,5f", "0,000000" },
3303                 { 0d, "%- (12.0f", " 0          " },
3304                 { 0d, "%#+0(1.6f", "+0,000000" },
3305                 { 0d, "%-+(8.4f", "+0,0000 " },
3306                 { 0d, "% 0#(9.8f", " 0,00000000" },
3307 
3308                 { 1d, "%f", "1,000000" },
3309                 { 1d, "%#.3f", "1,000" },
3310                 { 1d, "%,5f", "1,000000" },
3311                 { 1d, "%- (12.0f", " 1          " },
3312                 { 1d, "%#+0(1.6f", "+1,000000" },
3313                 { 1d, "%-+(8.4f", "+1,0000 " },
3314                 { 1d, "% 0#(9.8f", " 1,00000000" },
3315 
3316                 { -1d, "%f", "-1,000000" },
3317                 { -1d, "%#.3f", "-1,000" },
3318                 { -1d, "%,5f", "-1,000000" },
3319                 { -1d, "%- (12.0f", "(1)         " },
3320                 { -1d, "%#+0(1.6f", "(1,000000)" },
3321                 { -1d, "%-+(8.4f", "(1,0000)" },
3322                 { -1d, "% 0#(9.8f", "(1,00000000)" },
3323 
3324                 { .00000001d, "%f", "0,000000" },
3325                 { .00000001d, "%#.3f", "0,000" },
3326                 { .00000001d, "%,5f", "0,000000" },
3327                 { .00000001d, "%- (12.0f", " 0          " },
3328                 { .00000001d, "%#+0(1.6f", "+0,000000" },
3329                 { .00000001d, "%-+(8.4f", "+0,0000 " },
3330                 { .00000001d, "% 0#(9.8f", " 0,00000001" },
3331 
3332                 { 1000.10d, "%f", "1000,100000" },
3333                 { 1000.10d, "%#.3f", "1000,100" },
3334                 { 1000.10d, "%,5f", "1.000,100000" },
3335                 { 1000.10d, "%- (12.0f", " 1000       " },
3336                 { 1000.10d, "%#+0(1.6f", "+1000,100000" },
3337                 { 1000.10d, "%-+(8.4f", "+1000,1000" },
3338                 { 1000.10d, "% 0#(9.8f", " 1000,10000000" },
3339 
3340                 { 0.1d, "%f", "0,100000" },
3341                 { 0.1d, "%#.3f", "0,100" },
3342                 { 0.1d, "%,5f", "0,100000" },
3343                 { 0.1d, "%- (12.0f", " 0          " },
3344                 { 0.1d, "%#+0(1.6f", "+0,100000" },
3345                 { 0.1d, "%-+(8.4f", "+0,1000 " },
3346                 { 0.1d, "% 0#(9.8f", " 0,10000000" },
3347 
3348                 { -2.d, "%f", "-2,000000" },
3349                 { -2.d, "%#.3f", "-2,000" },
3350                 { -2.d, "%,5f", "-2,000000" },
3351                 { -2.d, "%- (12.0f", "(2)         " },
3352                 { -2.d, "%#+0(1.6f", "(2,000000)" },
3353                 { -2.d, "%-+(8.4f", "(2,0000)" },
3354                 { -2.d, "% 0#(9.8f", "(2,00000000)" },
3355 
3356                 { -.00009d, "%f", "-0,000090" },
3357                 { -.00009d, "%#.3f", "-0,000" },
3358                 { -.00009d, "%,5f", "-0,000090" },
3359                 { -.00009d, "%- (12.0f", "(0)         " },
3360                 { -.00009d, "%#+0(1.6f", "(0,000090)" },
3361                 { -.00009d, "%-+(8.4f", "(0,0001)" },
3362                 { -.00009d, "% 0#(9.8f", "(0,00009000)" },
3363 
3364                 { -1234567890.012345678d, "%f", "-1234567890,012346" },
3365                 { -1234567890.012345678d, "%#.3f", "-1234567890,012" },
3366                 { -1234567890.012345678d, "%,5f", "-1.234.567.890,012346" },
3367                 { -1234567890.012345678d, "%- (12.0f", "(1234567890)" },
3368                 { -1234567890.012345678d, "%#+0(1.6f", "(1234567890,012346)" },
3369                 { -1234567890.012345678d, "%-+(8.4f", "(1234567890,0123)" },
3370                 { -1234567890.012345678d, "% 0#(9.8f", "(1234567890,01234580)" },
3371 
3372                 { Double.MAX_VALUE, "%f", "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,000000" },
3373                 { Double.MAX_VALUE, "%#.3f", "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,000" },
3374                 { Double.MAX_VALUE, "%,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,000000" },
3375                 { Double.MAX_VALUE, "%- (12.0f", " 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" },
3376                 { Double.MAX_VALUE, "%#+0(1.6f", "+179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,000000" },
3377                 { Double.MAX_VALUE, "%-+(8.4f", "+179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,0000" },
3378                 { Double.MAX_VALUE, "% 0#(9.8f", " 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,00000000" },
3379 
3380                 { Double.MIN_VALUE, "%f", "0,000000" },
3381                 { Double.MIN_VALUE, "%#.3f", "0,000" },
3382                 { Double.MIN_VALUE, "%,5f", "0,000000" },
3383                 { Double.MIN_VALUE, "%- (12.0f", " 0          " },
3384                 { Double.MIN_VALUE, "%#+0(1.6f", "+0,000000" },
3385                 { Double.MIN_VALUE, "%-+(8.4f", "+0,0000 " },
3386                 { Double.MIN_VALUE, "% 0#(9.8f", " 0,00000000" },
3387 
3388                 { Double.NaN, "%f", "NaN" },
3389                 { Double.NaN, "%#.3f", "NaN" },
3390                 { Double.NaN, "%,5f", "  NaN" },
3391                 { Double.NaN, "%- (12.0f", "NaN         " },
3392                 { Double.NaN, "%#+0(1.6f", "NaN" },
3393                 { Double.NaN, "%-+(8.4f", "NaN     " },
3394                 { Double.NaN, "% 0#(9.8f", "      NaN" },
3395 
3396                 { Double.POSITIVE_INFINITY, "%f", "Infinity" },
3397                 { Double.POSITIVE_INFINITY, "%#.3f", "Infinity" },
3398                 { Double.POSITIVE_INFINITY, "%,5f", "Infinity" },
3399                 { Double.POSITIVE_INFINITY, "%- (12.0f", " Infinity   " },
3400                 { Double.POSITIVE_INFINITY, "%#+0(1.6f", "+Infinity" },
3401                 { Double.POSITIVE_INFINITY, "%-+(8.4f", "+Infinity" },
3402                 { Double.POSITIVE_INFINITY, "% 0#(9.8f", " Infinity" },
3403 
3404                 { Double.NEGATIVE_INFINITY, "%f", "-Infinity" },
3405                 { Double.NEGATIVE_INFINITY, "%#.3f", "-Infinity" },
3406                 { Double.NEGATIVE_INFINITY, "%,5f", "-Infinity" },
3407                 { Double.NEGATIVE_INFINITY, "%- (12.0f", "(Infinity)  " },
3408                 { Double.NEGATIVE_INFINITY, "%#+0(1.6f", "(Infinity)" },
3409                 { Double.NEGATIVE_INFINITY, "%-+(8.4f", "(Infinity)" },
3410                 { Double.NEGATIVE_INFINITY, "% 0#(9.8f", "(Infinity)" },
3411         };
3412         final int input = 0;
3413         final int pattern = 1;
3414         final int output = 2;
3415         for (int i = 0; i < tripleF.length; i++) {
3416             f = new Formatter(Locale.GERMAN);
3417             f.format((String) tripleF[i][pattern], tripleF[i][input]);
3418             assertEquals("triple[" + i + "]:" + tripleF[i][input] + ",pattern["
3419                     + i + "]:" + tripleF[i][pattern],
3420                     tripleF[i][output], f.toString());
3421         }
3422     }
3423 
3424     /**
3425      * java.util.Formatter#format(String, Object...) for Float/Double
3426      * conversion type 'a' and 'A'
3427      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionA()3428     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatConversionA() {
3429         Formatter f = null;
3430         final Object[][] tripleA = {
3431                 { -0f, "%a", "-0x0.0p0" },
3432                 { -0f, "%#.3a", "-0x0.000p0" },
3433                 { -0f, "%5a", "-0x0.0p0" },
3434                 { -0f, "%- 12.0a", "-0x0.0p0    " },
3435                 { -0f, "%#+01.6a", "-0x0.000000p0" },
3436                 { -0f, "%-+8.4a", "-0x0.0000p0" },
3437 
3438                 { 0f, "%a", "0x0.0p0" },
3439                 { 0f, "%#.3a", "0x0.000p0" },
3440                 { 0f, "%5a", "0x0.0p0" },
3441                 { 0f, "%- 12.0a", " 0x0.0p0    " },
3442                 { 0f, "%#+01.6a", "+0x0.000000p0" },
3443                 { 0f, "%-+8.4a", "+0x0.0000p0" },
3444 
3445                 { 1234f, "%a", "0x1.348p10" },
3446                 { 1234f, "%#.3a", "0x1.348p10" },
3447                 { 1234f, "%5a", "0x1.348p10" },
3448                 { 1234f, "%- 12.0a", " 0x1.3p10   " },
3449                 { 1234f, "%#+01.6a", "+0x1.348000p10" },
3450                 { 1234f, "%-+8.4a", "+0x1.3480p10" },
3451 
3452                 { 1.f, "%a", "0x1.0p0" },
3453                 { 1.f, "%#.3a", "0x1.000p0" },
3454                 { 1.f, "%5a", "0x1.0p0" },
3455                 { 1.f, "%- 12.0a", " 0x1.0p0    " },
3456                 { 1.f, "%#+01.6a", "+0x1.000000p0" },
3457                 { 1.f, "%-+8.4a", "+0x1.0000p0" },
3458 
3459                 { -98f, "%a", "-0x1.88p6" },
3460                 { -98f, "%#.3a", "-0x1.880p6" },
3461                 { -98f, "%5a", "-0x1.88p6" },
3462                 { -98f, "%- 12.0a", "-0x1.8p6    " },
3463                 { -98f, "%#+01.6a", "-0x1.880000p6" },
3464                 { -98f, "%-+8.4a", "-0x1.8800p6" },
3465 
3466                 { 345.1234567f, "%a", "0x1.591f9ap8" },
3467                 { 345.1234567f, "%5a", "0x1.591f9ap8" },
3468                 { 345.1234567f, "%#+01.6a", "+0x1.591f9ap8" },
3469 
3470                 { -987654321.1234567f, "%a", "-0x1.d6f346p29" },
3471                 { -987654321.1234567f, "%#.3a", "-0x1.d6fp29" },
3472                 { -987654321.1234567f, "%5a", "-0x1.d6f346p29" },
3473                 { -987654321.1234567f, "%- 12.0a", "-0x1.dp29   " },
3474                 { -987654321.1234567f, "%#+01.6a", "-0x1.d6f346p29" },
3475                 { -987654321.1234567f, "%-+8.4a", "-0x1.d6f3p29" },
3476 
3477                 { Float.MAX_VALUE, "%a", "0x1.fffffep127" },
3478                 { Float.MAX_VALUE, "%5a", "0x1.fffffep127" },
3479                 { Float.MAX_VALUE, "%#+01.6a", "+0x1.fffffep127" },
3480 
3481                 { Float.NaN, "%a", "NaN" },
3482                 { Float.NaN, "%#.3a", "NaN" },
3483                 { Float.NaN, "%5a", "  NaN" },
3484                 { Float.NaN, "%- 12.0a", "NaN         " },
3485                 { Float.NaN, "%#+01.6a", "NaN" },
3486                 { Float.NaN, "%-+8.4a", "NaN     " },
3487 
3488                 { Float.NEGATIVE_INFINITY, "%a", "-Infinity" },
3489                 { Float.NEGATIVE_INFINITY, "%#.3a", "-Infinity" },
3490                 { Float.NEGATIVE_INFINITY, "%5a", "-Infinity" },
3491                 { Float.NEGATIVE_INFINITY, "%- 12.0a", "-Infinity   " },
3492                 { Float.NEGATIVE_INFINITY, "%#+01.6a", "-Infinity" },
3493                 { Float.NEGATIVE_INFINITY, "%-+8.4a", "-Infinity" },
3494 
3495                 { Float.POSITIVE_INFINITY, "%a", "Infinity" },
3496                 { Float.POSITIVE_INFINITY, "%#.3a", "Infinity" },
3497                 { Float.POSITIVE_INFINITY, "%5a", "Infinity" },
3498                 { Float.POSITIVE_INFINITY, "%- 12.0a", " Infinity   " },
3499                 { Float.POSITIVE_INFINITY, "%#+01.6a", "+Infinity" },
3500                 { Float.POSITIVE_INFINITY, "%-+8.4a", "+Infinity" },
3501 
3502                 { -0d, "%a", "-0x0.0p0" },
3503                 { -0d, "%#.3a", "-0x0.000p0" },
3504                 { -0d, "%5a", "-0x0.0p0" },
3505                 { -0d, "%- 12.0a", "-0x0.0p0    " },
3506                 { -0d, "%#+01.6a", "-0x0.000000p0" },
3507                 { -0d, "%-+8.4a", "-0x0.0000p0" },
3508 
3509                 { 0d, "%a", "0x0.0p0" },
3510                 { 0d, "%#.3a", "0x0.000p0" },
3511                 { 0d, "%5a", "0x0.0p0" },
3512                 { 0d, "%- 12.0a", " 0x0.0p0    " },
3513                 { 0d, "%#+01.6a", "+0x0.000000p0" },
3514                 { 0d, "%-+8.4a", "+0x0.0000p0" },
3515 
3516                 { 1d, "%a", "0x1.0p0" },
3517                 { 1d, "%#.3a", "0x1.000p0" },
3518                 { 1d, "%5a", "0x1.0p0" },
3519                 { 1d, "%- 12.0a", " 0x1.0p0    " },
3520                 { 1d, "%#+01.6a", "+0x1.000000p0" },
3521                 { 1d, "%-+8.4a", "+0x1.0000p0" },
3522 
3523                 { -1d, "%a", "-0x1.0p0" },
3524                 { -1d, "%#.3a", "-0x1.000p0" },
3525                 { -1d, "%5a", "-0x1.0p0" },
3526                 { -1d, "%- 12.0a", "-0x1.0p0    " },
3527                 { -1d, "%#+01.6a", "-0x1.000000p0" },
3528                 { -1d, "%-+8.4a", "-0x1.0000p0" },
3529 
3530                 { .00000001d, "%a", "0x1.5798ee2308c3ap-27" },
3531                 { .00000001d, "%5a", "0x1.5798ee2308c3ap-27" },
3532                 { .00000001d, "%- 12.0a", " 0x1.5p-27  " },
3533                 { .00000001d, "%#+01.6a", "+0x1.5798eep-27" },
3534 
3535                 { 1000.10d, "%a", "0x1.f40cccccccccdp9" },
3536                 { 1000.10d, "%5a", "0x1.f40cccccccccdp9" },
3537                 { 1000.10d, "%- 12.0a", " 0x1.fp9    " },
3538 
3539                 { 0.1d, "%a", "0x1.999999999999ap-4" },
3540                 { 0.1d, "%5a", "0x1.999999999999ap-4" },
3541 
3542                 { -2.d, "%a", "-0x1.0p1" },
3543                 { -2.d, "%#.3a", "-0x1.000p1" },
3544                 { -2.d, "%5a", "-0x1.0p1" },
3545                 { -2.d, "%- 12.0a", "-0x1.0p1    " },
3546                 { -2.d, "%#+01.6a", "-0x1.000000p1" },
3547                 { -2.d, "%-+8.4a", "-0x1.0000p1" },
3548 
3549                 { -.00009d, "%a", "-0x1.797cc39ffd60fp-14" },
3550                 { -.00009d, "%5a", "-0x1.797cc39ffd60fp-14" },
3551 
3552                 { -1234567890.012345678d, "%a", "-0x1.26580b480ca46p30" },
3553                 { -1234567890.012345678d, "%5a", "-0x1.26580b480ca46p30" },
3554                 { -1234567890.012345678d, "%- 12.0a", "-0x1.2p30   " },
3555                 { -1234567890.012345678d, "%#+01.6a", "-0x1.26580bp30" },
3556                 { -1234567890.012345678d, "%-+8.4a", "-0x1.2658p30" },
3557 
3558                 { Double.MAX_VALUE, "%a", "0x1.fffffffffffffp1023" },
3559                 { Double.MAX_VALUE, "%5a", "0x1.fffffffffffffp1023" },
3560 
3561                 { Double.MIN_VALUE, "%a", "0x0.0000000000001p-1022" },
3562                 { Double.MIN_VALUE, "%5a", "0x0.0000000000001p-1022" },
3563 
3564                 { Double.NaN, "%a", "NaN" },
3565                 { Double.NaN, "%#.3a", "NaN" },
3566                 { Double.NaN, "%5a", "  NaN" },
3567                 { Double.NaN, "%- 12.0a", "NaN         " },
3568                 { Double.NaN, "%#+01.6a", "NaN" },
3569                 { Double.NaN, "%-+8.4a", "NaN     " },
3570 
3571                 { Double.NEGATIVE_INFINITY, "%a", "-Infinity" },
3572                 { Double.NEGATIVE_INFINITY, "%#.3a", "-Infinity" },
3573                 { Double.NEGATIVE_INFINITY, "%5a", "-Infinity" },
3574                 { Double.NEGATIVE_INFINITY, "%- 12.0a", "-Infinity   " },
3575                 { Double.NEGATIVE_INFINITY, "%#+01.6a", "-Infinity" },
3576                 { Double.NEGATIVE_INFINITY, "%-+8.4a", "-Infinity" },
3577 
3578                 { Double.POSITIVE_INFINITY, "%a", "Infinity" },
3579                 { Double.POSITIVE_INFINITY, "%#.3a", "Infinity" },
3580                 { Double.POSITIVE_INFINITY, "%5a", "Infinity" },
3581                 { Double.POSITIVE_INFINITY, "%- 12.0a", " Infinity   " },
3582                 { Double.POSITIVE_INFINITY, "%#+01.6a", "+Infinity" },
3583                 { Double.POSITIVE_INFINITY, "%-+8.4a", "+Infinity" },
3584 
3585         };
3586         final int input = 0;
3587         final int pattern = 1;
3588         final int output = 2;
3589         for (int i = 0; i < tripleA.length; i++) {
3590             f = new Formatter(Locale.UK);
3591             f.format((String) tripleA[i][pattern], tripleA[i][input]);
3592             assertEquals("triple[" + i + "]:" + tripleA[i][input] + ",pattern["
3593                     + i + "]:" + tripleA[i][pattern],
3594                     tripleA[i][output], f.toString());
3595 
3596             // test for conversion type 'A'
3597             f = new Formatter(Locale.UK);
3598             f.format(((String) tripleA[i][pattern]).toUpperCase(), tripleA[i][input]);
3599             assertEquals("triple[" + i + "]:" + tripleA[i][input] + ",pattern["
3600                     + i + "]:" + tripleA[i][pattern], ((String) tripleA[i][output])
3601                     .toUpperCase(Locale.UK), f.toString());
3602         }
3603     }
3604 
3605     /**
3606      * java.util.Formatter#format(String, Object...) for BigDecimal
3607      * conversion type 'e' and 'E'
3608      */
test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionE()3609     public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionE() {
3610         Formatter f = null;
3611         final Object[][] tripleE = {
3612                 { BigDecimal.ZERO, "%e", "0.000000e+00" },
3613                 { BigDecimal.ZERO, "%#.0e", "0.e+00" },
3614                 { BigDecimal.ZERO, "%# 9.8e", " 0.00000000e+00" },
3615                 { BigDecimal.ZERO, "%#+0(8.4e", "+0.0000e+00" },
3616                 { BigDecimal.ZERO, "%-+17.6e", "+0.000000e+00    " },
3617                 { BigDecimal.ZERO, "% 0(20e", " 00000000.000000e+00" },
3618 
3619                 { BigDecimal.ONE, "%e", "1.000000e+00" },
3620                 { BigDecimal.ONE, "%#.0e", "1.e+00" },
3621                 { BigDecimal.ONE, "%# 9.8e", " 1.00000000e+00" },
3622                 { BigDecimal.ONE, "%#+0(8.4e", "+1.0000e+00" },
3623                 { BigDecimal.ONE, "%-+17.6e", "+1.000000e+00    " },
3624                 { BigDecimal.ONE, "% 0(20e", " 00000001.000000e+00" },
3625 
3626                 { BigDecimal.TEN, "%e", "1.000000e+01" },
3627                 { BigDecimal.TEN, "%#.0e", "1.e+01" },
3628                 { BigDecimal.TEN, "%# 9.8e", " 1.00000000e+01" },
3629                 { BigDecimal.TEN, "%#+0(8.4e", "+1.0000e+01" },
3630                 { BigDecimal.TEN, "%-+17.6e", "+1.000000e+01    " },
3631                 { BigDecimal.TEN, "% 0(20e", " 00000001.000000e+01" },
3632 
3633                 { new BigDecimal(-1), "%e", "-1.000000e+00" },
3634                 { new BigDecimal(-1), "%#.0e", "-1.e+00" },
3635                 { new BigDecimal(-1), "%# 9.8e", "-1.00000000e+00" },
3636                 { new BigDecimal(-1), "%#+0(8.4e", "(1.0000e+00)" },
3637                 { new BigDecimal(-1), "%-+17.6e", "-1.000000e+00    " },
3638                 { new BigDecimal(-1), "% 0(20e", "(0000001.000000e+00)" },
3639 
3640                 { new BigDecimal("5.000E999"), "%e", "5.000000e+999" },
3641                 { new BigDecimal("5.000E999"), "%#.0e", "5.e+999" },
3642                 { new BigDecimal("5.000E999"), "%# 9.8e", " 5.00000000e+999" },
3643                 { new BigDecimal("5.000E999"), "%#+0(8.4e", "+5.0000e+999" },
3644                 { new BigDecimal("5.000E999"), "%-+17.6e", "+5.000000e+999   " },
3645                 { new BigDecimal("5.000E999"), "% 0(20e", " 0000005.000000e+999" },
3646 
3647                 { new BigDecimal("-5.000E999"), "%e", "-5.000000e+999" },
3648                 { new BigDecimal("-5.000E999"), "%#.0e", "-5.e+999" },
3649                 { new BigDecimal("-5.000E999"), "%# 9.8e", "-5.00000000e+999" },
3650                 { new BigDecimal("-5.000E999"), "%#+0(8.4e", "(5.0000e+999)" },
3651                 { new BigDecimal("-5.000E999"), "%-+17.6e", "-5.000000e+999   " },
3652                 { new BigDecimal("-5.000E999"), "% 0(20e", "(000005.000000e+999)" },
3653         };
3654         final int input = 0;
3655         final int pattern = 1;
3656         final int output = 2;
3657         for (int i = 0; i < tripleE.length; i++) {
3658             f = new Formatter(Locale.US);
3659             f.format((String) tripleE[i][pattern], tripleE[i][input]);
3660             assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern["
3661                     + i + "]:" + tripleE[i][pattern],
3662                     tripleE[i][output], f.toString());
3663 
3664             // test for conversion type 'E'
3665             f = new Formatter(Locale.US);
3666             f.format(((String) tripleE[i][pattern]).toUpperCase(), tripleE[i][input]);
3667             assertEquals("triple[" + i + "]:" + tripleE[i][input] + ",pattern["
3668                     + i + "]:" + tripleE[i][pattern], ((String) tripleE[i][output])
3669                     .toUpperCase(Locale.US), f.toString());
3670         }
3671     }
3672 
3673     /**
3674      * java.util.Formatter#format(String, Object...) for BigDecimal
3675      * conversion type 'g' and 'G'
3676      */
test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionG()3677     public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionG() {
3678         Formatter f = null;
3679         final Object[][] tripleG = {
3680                 { BigDecimal.ZERO, "%g", "0.00000" },
3681                 { BigDecimal.ZERO, "%.5g", "0.0000" },
3682                 { BigDecimal.ZERO, "%- (,9.8g", " 0.0000000" },
3683                 { BigDecimal.ZERO, "%+0(,8.4g", "+000.000" },
3684                 { BigDecimal.ZERO, "%-+10.6g", "+0.00000  " },
3685                 { BigDecimal.ZERO, "% 0(,12.0g", " 00000000000" },
3686                 { BigDecimal.ONE, "%g", "1.00000" },
3687                 { BigDecimal.ONE, "%.5g", "1.0000" },
3688                 { BigDecimal.ONE, "%- (,9.8g", " 1.0000000" },
3689                 { BigDecimal.ONE, "%+0(,8.4g", "+001.000" },
3690                 { BigDecimal.ONE, "%-+10.6g", "+1.00000  " },
3691                 { BigDecimal.ONE, "% 0(,12.0g", " 00000000001" },
3692 
3693                 { new BigDecimal(-1), "%g", "-1.00000" },
3694                 { new BigDecimal(-1), "%.5g", "-1.0000" },
3695                 { new BigDecimal(-1), "%- (,9.8g", "(1.0000000)" },
3696                 { new BigDecimal(-1), "%+0(,8.4g", "(01.000)" },
3697                 { new BigDecimal(-1), "%-+10.6g", "-1.00000  " },
3698                 { new BigDecimal(-1), "% 0(,12.0g", "(0000000001)" },
3699 
3700                 { new BigDecimal(-0.000001), "%g", "-1.00000e-06" },
3701                 { new BigDecimal(-0.000001), "%.5g", "-1.0000e-06" },
3702                 { new BigDecimal(-0.000001), "%- (,9.8g", "(1.0000000e-06)" },
3703                 { new BigDecimal(-0.000001), "%+0(,8.4g", "(1.000e-06)" },
3704                 { new BigDecimal(-0.000001), "%-+10.6g", "-1.00000e-06" },
3705                 { new BigDecimal(-0.000001), "% 0(,12.0g", "(000001e-06)" },
3706 
3707                 { new BigDecimal(0.0002), "%g", "0.000200000" },
3708                 { new BigDecimal(0.0002), "%.5g", "0.00020000" },
3709                 { new BigDecimal(0.0002), "%- (,9.8g", " 0.00020000000" },
3710                 { new BigDecimal(0.0002), "%+0(,8.4g", "+0.0002000" },
3711                 { new BigDecimal(0.0002), "%-+10.6g", "+0.000200000" },
3712                 { new BigDecimal(0.0002), "% 0(,12.0g", " 000000.0002" },
3713 
3714                 { new BigDecimal(-0.003), "%g", "-0.00300000" },
3715                 { new BigDecimal(-0.003), "%.5g", "-0.0030000" },
3716                 { new BigDecimal(-0.003), "%- (,9.8g", "(0.0030000000)" },
3717                 { new BigDecimal(-0.003), "%+0(,8.4g", "(0.003000)" },
3718                 { new BigDecimal(-0.003), "%-+10.6g", "-0.00300000" },
3719                 { new BigDecimal(-0.003), "% 0(,12.0g", "(000000.003)" },
3720 
3721                 { new BigDecimal("5.000E999"), "%g", "5.00000e+999" },
3722                 { new BigDecimal("5.000E999"), "%.5g", "5.0000e+999" },
3723                 { new BigDecimal("5.000E999"), "%- (,9.8g", " 5.0000000e+999" },
3724                 { new BigDecimal("5.000E999"), "%+0(,8.4g", "+5.000e+999" },
3725                 { new BigDecimal("5.000E999"), "%-+10.6g", "+5.00000e+999" },
3726                 { new BigDecimal("5.000E999"), "% 0(,12.0g", " 000005e+999" },
3727 
3728                 { new BigDecimal("-5.000E999"), "%g", "-5.00000e+999" },
3729                 { new BigDecimal("-5.000E999"), "%.5g", "-5.0000e+999" },
3730                 { new BigDecimal("-5.000E999"), "%- (,9.8g", "(5.0000000e+999)" },
3731                 { new BigDecimal("-5.000E999"), "%+0(,8.4g", "(5.000e+999)" },
3732                 { new BigDecimal("-5.000E999"), "%-+10.6g", "-5.00000e+999" },
3733                 { new BigDecimal("-5.000E999"), "% 0(,12.0g", "(00005e+999)" },
3734         };
3735         final int input = 0;
3736         final int pattern = 1;
3737         final int output = 2;
3738         for (int i = 0; i < tripleG.length; i++) {
3739             f = new Formatter(Locale.US);
3740             f.format((String) tripleG[i][pattern], tripleG[i][input]);
3741             assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern["
3742                     + i + "]:" + tripleG[i][pattern],
3743                     tripleG[i][output], f.toString());
3744 
3745             // test for conversion type 'G'
3746             f = new Formatter(Locale.US);
3747             f.format(((String) tripleG[i][pattern]).toUpperCase(), tripleG[i][input]);
3748             assertEquals("triple[" + i + "]:" + tripleG[i][input] + ",pattern["
3749                     + i + "]:" + tripleG[i][pattern], ((String) tripleG[i][output])
3750                     .toUpperCase(Locale.US), f.toString());
3751         }
3752 
3753         f = new Formatter(Locale.GERMAN);
3754         f.format("%- (,9.6g", new BigDecimal("4E6"));
3755         /*
3756          * fail on RI, spec says 'g' requires the output to be formatted in
3757          * general scientific notation and the localization algorithm is
3758          * applied. But RI format this case to 4.00000e+06, which does not
3759          * conform to the German Locale
3760          */
3761         assertEquals(" 4,00000e+06", f.toString());
3762     }
3763 
3764     /**
3765      * java.util.Formatter#format(String, Object...) for BigDecimal
3766      * conversion type 'f'
3767      */
test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionF()3768     public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalConversionF() {
3769 
3770         Formatter f = null;
3771         final int input = 0;
3772         final int pattern = 1;
3773         final int output = 2;
3774         final Object[][] tripleF = {
3775                 { BigDecimal.ZERO, "%f", "0.000000" },
3776                 { BigDecimal.ZERO, "%#.3f", "0.000" },
3777                 { BigDecimal.ZERO, "%#,5f", "0.000000" },
3778                 { BigDecimal.ZERO, "%- #(12.0f", " 0.         " },
3779                 { BigDecimal.ZERO, "%#+0(1.6f", "+0.000000" },
3780                 { BigDecimal.ZERO, "%-+(8.4f", "+0.0000 " },
3781                 { BigDecimal.ZERO, "% 0#(9.8f", " 0.00000000" },
3782                 { BigDecimal.ONE, "%f", "1.000000" },
3783                 { BigDecimal.ONE, "%#.3f", "1.000" },
3784                 { BigDecimal.ONE, "%#,5f", "1.000000" },
3785                 { BigDecimal.ONE, "%- #(12.0f", " 1.         " },
3786                 { BigDecimal.ONE, "%#+0(1.6f", "+1.000000" },
3787                 { BigDecimal.ONE, "%-+(8.4f", "+1.0000 " },
3788                 { BigDecimal.ONE, "% 0#(9.8f", " 1.00000000" },
3789                 { BigDecimal.TEN, "%f", "10.000000" },
3790                 { BigDecimal.TEN, "%#.3f", "10.000" },
3791                 { BigDecimal.TEN, "%#,5f", "10.000000" },
3792                 { BigDecimal.TEN, "%- #(12.0f", " 10.        " },
3793                 { BigDecimal.TEN, "%#+0(1.6f", "+10.000000" },
3794                 { BigDecimal.TEN, "%-+(8.4f", "+10.0000" },
3795                 { BigDecimal.TEN, "% 0#(9.8f", " 10.00000000" },
3796                 { new BigDecimal(-1), "%f", "-1.000000" },
3797                 { new BigDecimal(-1), "%#.3f", "-1.000" },
3798                 { new BigDecimal(-1), "%#,5f", "-1.000000" },
3799                 { new BigDecimal(-1), "%- #(12.0f", "(1.)        " },
3800                 { new BigDecimal(-1), "%#+0(1.6f", "(1.000000)" },
3801                 { new BigDecimal(-1), "%-+(8.4f", "(1.0000)" },
3802                 { new BigDecimal(-1), "% 0#(9.8f", "(1.00000000)" },
3803                 { new BigDecimal("9999999999999999999999999999999999999999999"), "%f", "9999999999999999999999999999999999999999999.000000" },
3804                 { new BigDecimal("9999999999999999999999999999999999999999999"), "%#.3f", "9999999999999999999999999999999999999999999.000" },
3805                 { new BigDecimal("9999999999999999999999999999999999999999999"), "%#,5f", "9,999,999,999,999,999,999,999,999,999,999,999,999,999,999.000000" },
3806                 { new BigDecimal("9999999999999999999999999999999999999999999"), "%- #(12.0f", " 9999999999999999999999999999999999999999999." },
3807                 { new BigDecimal("9999999999999999999999999999999999999999999"), "%#+0(1.6f", "+9999999999999999999999999999999999999999999.000000" },
3808                 { new BigDecimal("9999999999999999999999999999999999999999999"), "%-+(8.4f", "+9999999999999999999999999999999999999999999.0000" },
3809                 { new BigDecimal("9999999999999999999999999999999999999999999"), "% 0#(9.8f", " 9999999999999999999999999999999999999999999.00000000" },
3810                 { new BigDecimal("-9999999999999999999999999999999999999999999"), "%f", "-9999999999999999999999999999999999999999999.000000" },
3811                 { new BigDecimal("-9999999999999999999999999999999999999999999"), "%#.3f", "-9999999999999999999999999999999999999999999.000" },
3812                 { new BigDecimal("-9999999999999999999999999999999999999999999"), "%#,5f", "-9,999,999,999,999,999,999,999,999,999,999,999,999,999,999.000000" },
3813                 { new BigDecimal("-9999999999999999999999999999999999999999999"), "%- #(12.0f", "(9999999999999999999999999999999999999999999.)" },
3814                 { new BigDecimal("-9999999999999999999999999999999999999999999"), "%#+0(1.6f", "(9999999999999999999999999999999999999999999.000000)" },
3815                 { new BigDecimal("-9999999999999999999999999999999999999999999"), "%-+(8.4f", "(9999999999999999999999999999999999999999999.0000)" },
3816                 { new BigDecimal("-9999999999999999999999999999999999999999999"), "% 0#(9.8f", "(9999999999999999999999999999999999999999999.00000000)" },
3817         };
3818         for (int i = 0; i < tripleF.length; i++) {
3819             f = new Formatter(Locale.US);
3820             f.format((String) tripleF[i][pattern], tripleF[i][input]);
3821             assertEquals("triple[" + i + "]:" + tripleF[i][input] + ",pattern["
3822                     + i + "]:" + tripleF[i][pattern], tripleF[i][output], f.toString());
3823         }
3824 
3825         f = new Formatter(Locale.US);
3826         f.format("%f", new BigDecimal("5.0E9"));
3827         // error on RI
3828         // RI throw ArrayIndexOutOfBoundsException
3829         assertEquals("5000000000.000000", f.toString());
3830     }
3831 
3832     /**
3833      * java.util.Formatter#format(String, Object...) for exceptions in
3834      * Float/Double/BigDecimal conversion type 'e', 'E', 'g', 'G', 'f', 'a', 'A'
3835      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalConversionException()3836     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalConversionException() {
3837         Formatter f = null;
3838 
3839         final char[] conversions = { 'e', 'E', 'g', 'G', 'f', 'a', 'A' };
3840         final Object[] illArgs = { false, (byte) 1, (short) 2, 3, (long) 4,
3841                 new BigInteger("5"), Character.valueOf('c'), new Object(),
3842                 new Date() };
3843         for (int i = 0; i < illArgs.length; i++) {
3844             for (int j = 0; j < conversions.length; j++) {
3845                 try {
3846                     f = new Formatter(Locale.UK);
3847                     f.format("%" + conversions[j], illArgs[i]);
3848                     fail("should throw IllegalFormatConversionException");
3849                 } catch (IllegalFormatConversionException e) {
3850                     // expected
3851                 }
3852             }
3853         }
3854 
3855         try {
3856             f = new Formatter(Locale.UK);
3857             f.format("%a", new BigDecimal(1));
3858             fail("should throw IllegalFormatConversionException");
3859         } catch (IllegalFormatConversionException e) {
3860             // expected
3861         }
3862 
3863         try {
3864             f = new Formatter(Locale.UK);
3865             f.format("%A", new BigDecimal(1));
3866             fail("should throw IllegalFormatConversionException");
3867         } catch (IllegalFormatConversionException e) {
3868             // expected
3869         }
3870 
3871         final String[] flagsConversionMismatches = { "%,e", "%,E", "%#g",
3872                 "%#G", "%,a", "%,A", "%(a", "%(A" };
3873         for (int i = 0; i < flagsConversionMismatches.length; i++) {
3874             try {
3875                 f = new Formatter(Locale.CHINA);
3876                 f.format(flagsConversionMismatches[i], new BigDecimal(1));
3877                 fail("should throw FormatFlagsConversionMismatchException");
3878             } catch (FormatFlagsConversionMismatchException e) {
3879                 // expected
3880             }
3881             try {
3882                 f = new Formatter(Locale.JAPAN);
3883                 f.format(flagsConversionMismatches[i], (BigDecimal) null);
3884                 fail("should throw FormatFlagsConversionMismatchException");
3885             } catch (FormatFlagsConversionMismatchException e) {
3886                 // expected
3887             }
3888         }
3889 
3890         final String[] missingFormatWidths = { "%-0e", "%0e", "%-e", "%-0E",
3891                 "%0E", "%-E", "%-0g", "%0g", "%-g", "%-0G", "%0G", "%-G",
3892                 "%-0f", "%0f", "%-f", "%-0a", "%0a", "%-a", "%-0A", "%0A",
3893                 "%-A" };
3894         for (int i = 0; i < missingFormatWidths.length; i++) {
3895             try {
3896                 f = new Formatter(Locale.KOREA);
3897                 f.format(missingFormatWidths[i], 1f);
3898                 fail("should throw MissingFormatWidthException");
3899             } catch (MissingFormatWidthException e) {
3900                 // expected
3901             }
3902 
3903             try {
3904                 f = new Formatter(Locale.KOREA);
3905                 f.format(missingFormatWidths[i], (Float) null);
3906                 fail("should throw MissingFormatWidthException");
3907             } catch (MissingFormatWidthException e) {
3908                 // expected
3909             }
3910         }
3911 
3912         final String[] illFlags = { "%+ e", "%+ E", "%+ g", "%+ G", "%+ f",
3913                 "%+ a", "%+ A", "%-03e", "%-03E", "%-03g", "%-03G", "%-03f",
3914                 "%-03a", "%-03A" };
3915         for (int i = 0; i < illFlags.length; i++) {
3916             try {
3917                 f = new Formatter(Locale.CANADA);
3918                 f.format(illFlags[i], 1.23d);
3919                 fail("should throw IllegalFormatFlagsException");
3920             } catch (IllegalFormatFlagsException e) {
3921                 // expected
3922             }
3923 
3924             try {
3925                 f = new Formatter(Locale.CANADA);
3926                 f.format(illFlags[i], (Double) null);
3927                 fail("should throw IllegalFormatFlagsException");
3928             } catch (IllegalFormatFlagsException e) {
3929                 // expected
3930             }
3931         }
3932 
3933         f = new Formatter(Locale.US);
3934         try {
3935             f.format("%F", 1);
3936             fail("should throw UnknownFormatConversionException");
3937         } catch (UnknownFormatConversionException e) {
3938             // expected
3939         }
3940     }
3941 
3942     /**
3943      * java.util.Formatter#format(String, Object...) for
3944      * Float/Double/BigDecimal exception throwing order
3945      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalExceptionOrder()3946     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalExceptionOrder() {
3947         Formatter f = null;
3948 
3949         /*
3950          * Summary: UnknownFormatConversionException >
3951          * MissingFormatWidthException > IllegalFormatFlagsException >
3952          * FormatFlagsConversionMismatchException >
3953          * IllegalFormatConversionException
3954          *
3955          */
3956         try {
3957             // compare FormatFlagsConversionMismatchException and
3958             // IllegalFormatConversionException
3959             f = new Formatter(Locale.US);
3960             f.format("%,e", (byte) 1);
3961             fail("should throw FormatFlagsConversionMismatchException");
3962         } catch (FormatFlagsConversionMismatchException e) {
3963             // expected
3964         }
3965 
3966         try {
3967             // compare IllegalFormatFlagsException and
3968             // FormatFlagsConversionMismatchException
3969             f = new Formatter(Locale.US);
3970             f.format("%+ ,e", 1f);
3971             fail("should throw IllegalFormatFlagsException");
3972         } catch (IllegalFormatFlagsException e) {
3973             // expected
3974         }
3975 
3976         try {
3977             // compare MissingFormatWidthException and
3978             // IllegalFormatFlagsException
3979             f = new Formatter(Locale.US);
3980             f.format("%+ -e", 1f);
3981             fail("should throw MissingFormatWidthException");
3982         } catch (MissingFormatWidthException e) {
3983             // expected
3984         }
3985 
3986         try {
3987             // compare UnknownFormatConversionException and
3988             // MissingFormatWidthException
3989             f = new Formatter(Locale.US);
3990             f.format("%-F", 1f);
3991             fail("should throw UnknownFormatConversionException");
3992         } catch (UnknownFormatConversionException e) {
3993             // expected
3994         }
3995     }
3996 
3997     /**
3998      * java.util.Formatter#format(String, Object...) for BigDecimal
3999      * exception throwing order
4000      */
test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalExceptionOrder()4001     public void test_formatLjava_lang_String$Ljava_lang_Object_BigDecimalExceptionOrder() {
4002         Formatter f = null;
4003         BigDecimal bd = new BigDecimal("1.0");
4004 
4005         /*
4006          * Summary: UnknownFormatConversionException >
4007          * MissingFormatWidthException > IllegalFormatFlagsException >
4008          * FormatFlagsConversionMismatchException >
4009          * IllegalFormatConversionException
4010          *
4011          */
4012         try {
4013             // compare FormatFlagsConversionMismatchException and
4014             // IllegalFormatConversionException
4015             f = new Formatter(Locale.US);
4016             f.format("%,e", (byte) 1);
4017             fail("should throw FormatFlagsConversionMismatchException");
4018         } catch (FormatFlagsConversionMismatchException e) {
4019             // expected
4020         }
4021 
4022         try {
4023             // compare IllegalFormatFlagsException and
4024             // FormatFlagsConversionMismatchException
4025             f = new Formatter(Locale.US);
4026             f.format("%+ ,e", bd);
4027             fail("should throw IllegalFormatFlagsException");
4028         } catch (IllegalFormatFlagsException e) {
4029             // expected
4030         }
4031 
4032         try {
4033             // compare MissingFormatWidthException and
4034             // IllegalFormatFlagsException
4035             f = new Formatter(Locale.US);
4036             f.format("%+ -e", bd);
4037             fail("should throw MissingFormatWidthException");
4038         } catch (MissingFormatWidthException e) {
4039             // expected
4040         }
4041 
4042         // compare UnknownFormatConversionException and
4043         // MissingFormatWidthException
4044         try {
4045             f = new Formatter(Locale.US);
4046             f.format("%-F", bd);
4047             fail("should throw UnknownFormatConversionException");
4048         } catch (UnknownFormatConversionException e) {
4049             // expected
4050         }
4051     }
4052 
4053     /**
4054      * java.util.Formatter#format(String, Object...) for null argment for
4055      * Float/Double/BigDecimal conversion
4056      */
test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalNullConversion()4057     public void test_formatLjava_lang_String$Ljava_lang_Object_FloatDoubleBigDecimalNullConversion() {
4058         Formatter f = null;
4059 
4060         // test (Float)null
4061         f = new Formatter(Locale.FRANCE);
4062         f.format("%#- (9.0e", (Float) null);
4063         assertEquals("         ", f.toString());
4064 
4065         f = new Formatter(Locale.GERMAN);
4066         f.format("%-+(1.6E", (Float) null);
4067         assertEquals("NULL", f.toString());
4068 
4069         f = new Formatter(Locale.UK);
4070         f.format("%+0(,8.4g", (Float) null);
4071         assertEquals("    null", f.toString());
4072 
4073         f = new Formatter(Locale.FRANCE);
4074         f.format("%- (9.8G", (Float) null);
4075         assertEquals("NULL     ", f.toString());
4076 
4077         f = new Formatter(Locale.FRANCE);
4078         f.format("%- (12.1f", (Float) null);
4079         assertEquals("n           ", f.toString());
4080 
4081         f = new Formatter(Locale.FRANCE);
4082         f.format("% .4a", (Float) null);
4083         assertEquals("null", f.toString());
4084 
4085         f = new Formatter(Locale.FRANCE);
4086         f.format("%06A", (Float) null);
4087         assertEquals("  NULL", f.toString());
4088 
4089         // test (Double)null
4090         f = new Formatter(Locale.GERMAN);
4091         f.format("%- (9e", (Double) null);
4092         assertEquals("null     ", f.toString());
4093 
4094         f = new Formatter(Locale.GERMAN);
4095         f.format("%#-+(1.6E", (Double) null);
4096         assertEquals("NULL", f.toString());
4097 
4098         f = new Formatter(Locale.GERMAN);
4099         f.format("%+0(6.4g", (Double) null);
4100         assertEquals("  null", f.toString());
4101 
4102         f = new Formatter(Locale.GERMAN);
4103         f.format("%- (,5.8G", (Double) null);
4104         assertEquals("NULL ", f.toString());
4105 
4106         f = new Formatter(Locale.GERMAN);
4107         f.format("% (.4f", (Double) null);
4108         assertEquals("null", f.toString());
4109 
4110         f = new Formatter(Locale.GERMAN);
4111         f.format("%#.6a", (Double) null);
4112         assertEquals("null", f.toString());
4113 
4114         f = new Formatter(Locale.GERMAN);
4115         f.format("% 2.5A", (Double) null);
4116         assertEquals("NULL", f.toString());
4117 
4118         // test (BigDecimal)null
4119         f = new Formatter(Locale.UK);
4120         f.format("%#- (6.2e", (BigDecimal) null);
4121         assertEquals("nu    ", f.toString());
4122 
4123         f = new Formatter(Locale.UK);
4124         f.format("%-+(1.6E", (BigDecimal) null);
4125         assertEquals("NULL", f.toString());
4126 
4127         f = new Formatter(Locale.UK);
4128         f.format("%+-(,5.3g", (BigDecimal) null);
4129         assertEquals("nul  ", f.toString());
4130 
4131         f = new Formatter(Locale.UK);
4132         f.format("%0 3G", (BigDecimal) null);
4133         assertEquals("NULL", f.toString());
4134 
4135         f = new Formatter(Locale.UK);
4136         f.format("%0 (9.0G", (BigDecimal) null);
4137         assertEquals("         ", f.toString());
4138 
4139         f = new Formatter(Locale.UK);
4140         f.format("% (.5f", (BigDecimal) null);
4141         assertEquals("null", f.toString());
4142 
4143         f = new Formatter(Locale.UK);
4144         f.format("%06a", (BigDecimal) null);
4145         assertEquals("  null", f.toString());
4146 
4147         f = new Formatter(Locale.UK);
4148         f.format("% .5A", (BigDecimal) null);
4149         assertEquals("NULL", f.toString());
4150     }
4151 
4152     /**
4153      * java.util.Formatter.BigDecimalLayoutForm#values()
4154      */
test_values()4155     public void test_values() {
4156         BigDecimalLayoutForm[] vals = BigDecimalLayoutForm.values();
4157         assertEquals("Invalid length of enum values", 2, vals.length);
4158         assertEquals("Wrong scientific value in enum", BigDecimalLayoutForm.SCIENTIFIC, vals[0]);
4159         assertEquals("Wrong dec float value in enum", BigDecimalLayoutForm.DECIMAL_FLOAT, vals[1]);
4160     }
4161 
4162     /**
4163      * java.util.Formatter.BigDecimalLayoutForm#valueOf(String)
4164      */
test_valueOfLjava_lang_String()4165     public void test_valueOfLjava_lang_String() {
4166         BigDecimalLayoutForm sci = BigDecimalLayoutForm.valueOf("SCIENTIFIC");
4167         assertEquals("Wrong scientific value in enum", BigDecimalLayoutForm.SCIENTIFIC, sci);
4168 
4169         BigDecimalLayoutForm decFloat = BigDecimalLayoutForm.valueOf("DECIMAL_FLOAT");
4170         assertEquals("Wrong dec float value from valueOf ", BigDecimalLayoutForm.DECIMAL_FLOAT, decFloat);
4171     }
4172 
4173     /*
4174      * Regression test for Harmony-5845
4175      * test the short name for timezone whether uses DaylightTime or not
4176      */
test_DaylightTime()4177     public void test_DaylightTime() {
4178         Locale.setDefault(Locale.US);
4179         Calendar c1 = new GregorianCalendar(2007, 0, 1);
4180         Calendar c2 = new GregorianCalendar(2007, 7, 1);
4181 
4182         for (String tz : TimeZone.getAvailableIDs()) {
4183             if (tz.equals("America/Los_Angeles")) {
4184                 c1.setTimeZone(TimeZone.getTimeZone(tz));
4185                 c2.setTimeZone(TimeZone.getTimeZone(tz));
4186                 assertTrue(String.format("%1$tZ%2$tZ", c1, c2).equals("PSTPDT"));
4187             }
4188             if (tz.equals("America/Panama")) {
4189                 c1.setTimeZone(TimeZone.getTimeZone(tz));
4190                 c2.setTimeZone(TimeZone.getTimeZone(tz));
4191                 assertTrue(String.format("%1$tZ%2$tZ", c1, c2).equals("ESTEST"));
4192             }
4193         }
4194     }
4195 
4196     /*
4197      * Regression test for Harmony-5845
4198      * test scientific notation to follow RI's behavior
4199      */
test_ScientificNotation()4200     public void test_ScientificNotation() {
4201         Formatter f = new Formatter();
4202         MathContext mc = new MathContext(30);
4203         BigDecimal value = new BigDecimal(0.1, mc);
4204         f.format("%.30G", value);
4205 
4206         String result = f.toString();
4207         String expected = "0.100000000000000005551115123126";
4208         assertEquals(expected, result);
4209     }
4210 
4211 
4212     /**
4213      * Setup resource files for testing
4214      */
setUp()4215     protected void setUp() throws IOException {
4216         root = System.getProperty("user.name").equalsIgnoreCase("root");
4217         notExist = File.createTempFile("notexist", null);
4218         notExist.delete();
4219 
4220         fileWithContent = File.createTempFile("filewithcontent", null);
4221         BufferedOutputStream bw = new BufferedOutputStream(
4222                 new FileOutputStream(fileWithContent));
4223         bw.write(1);// write something into the file
4224         bw.close();
4225 
4226         readOnly = File.createTempFile("readonly", null);
4227         readOnly.setReadOnly();
4228 
4229         secret = File.createTempFile("secret", null);
4230 
4231         defaultLocale = Locale.getDefault();
4232 
4233         defaultTimeZone = TimeZone.getDefault();
4234         TimeZone cst = TimeZone.getTimeZone("Asia/Shanghai");
4235         TimeZone.setDefault(cst);
4236     }
4237 
4238     /**
4239      * Delete the resource files if they exist
4240      */
tearDown()4241     protected void tearDown() {
4242         if (notExist.exists()) {
4243             notExist.delete();
4244         }
4245 
4246         if (fileWithContent.exists()) {
4247             fileWithContent.delete();
4248         }
4249         if (readOnly.exists()) {
4250             readOnly.delete();
4251         }
4252         if (secret.exists()) {
4253             secret.delete();
4254         }
4255 
4256         Locale.setDefault(defaultLocale);
4257         TimeZone.setDefault(defaultTimeZone);
4258     }
4259 }
4260