| /* |
| * Copyright (c) 2008, 2016, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /** |
| * @test |
| * @bug 4823811 8008577 |
| * @summary Confirm that text which includes numbers with a trailing minus sign is parsed correctly. |
| * @modules jdk.localedata |
| * @run main/othervm -Duser.timezone=GMT+09:00 -Djava.locale.providers=JRE,SPI Bug4823811 |
| */ |
| |
| import java.text.*; |
| import java.util.*; |
| |
| public class Bug4823811 { |
| |
| private static Locale localeEG = new Locale("ar", "EG"); |
| private static Locale localeUS = Locale.US; |
| |
| private static String JuneInArabic = "\u064a\u0648\u0646\u064a\u0648"; |
| private static String JulyInArabic = "\u064a\u0648\u0644\u064a\u0648"; |
| private static String JuneInEnglish = "June"; |
| private static String JulyInEnglish = "July"; |
| |
| private static String BORDER = |
| "============================================================"; |
| |
| /* |
| * I don't use static import here intentionally so that this test program |
| * can be run on JDK 1.4.2. |
| */ |
| private static int ERA = Calendar.ERA; |
| private static int BC = GregorianCalendar.BC; |
| // private static int JAN = Calendar.JANUARY; |
| // private static int FEB = Calendar.FEBRUARY; |
| // private static int MAR = Calendar.MARCH; |
| private static int APR = Calendar.APRIL; |
| private static int MAY = Calendar.MAY; |
| private static int JUN = Calendar.JUNE; |
| private static int JUL = Calendar.JULY; |
| // private static int AUG = Calendar.AUGUST; |
| // private static int SEP = Calendar.SEPTEMBER; |
| // private static int OCT = Calendar.OCTOBER; |
| // private static int NOV = Calendar.NOVEMBER; |
| // private static int DEC = Calendar.DECEMBER; |
| |
| private static String[] patterns = { |
| "yyyy MMMM d H m s", |
| "yyyy MM dd hh mm ss", |
| |
| /* |
| * Because 1-based HOUR_OF_DAY, 1-based HOUR, MONTH, and YEAR fields |
| * are parsed using different code from the code for other numeric |
| * fields, I prepared YEAR-preceding patterns and SECOND-preceding |
| * patterns. |
| */ |
| "yyyy M d h m s", |
| " yyyy M d h m s", |
| "yyyy M d h m s ", |
| |
| "s m h d M yyyy", |
| " s m h d M yyyy", |
| "s m h d M yyyy ", |
| }; |
| |
| private static char originalMinusSign1 = ':'; |
| private static char originalMinusSign2 = '\uff0d'; // fullwidth minus |
| private static String[] delimiters = {"-", "/", ":", "/", "\uff0d", "/"}; |
| private static String[][] specialDelimiters = { |
| // for Arabic formatter and modified English formatter |
| {"--", "-/", "::", ":/", "\uff0d\uff0d", "\uff0d/"}, |
| |
| // for English formatter and modified Arabic formatter |
| {"--", "/-", "::", "/:", "\uff0d\uff0d", "/\uff0d"}, |
| }; |
| |
| /* |
| * Format: |
| * +-------------------------------------------------------------------+ |
| * | Input | Output | |
| * +---------------------+---------------------------------------------| |
| * | datesEG & datesUS | formattedDatesEG & formattedDatesUS | |
| * +-------------------------------------------------------------------+ |
| * |
| * Parse: |
| * +-------------------------------------------------------------------+ |
| * | Input | Output | |
| * |---------------------+---------------------------------------------| |
| * | datesToParse | datesEG & datesUS | |
| * +-------------------------------------------------------------------+ |
| */ |
| private static String[][] datesToParse = { |
| // "JUNE" and "JULY" are replaced with a localized month name later. |
| {"2008 JULY 20 3 12 83", |
| "2008 JULY 20 3 12 83", |
| "2008 JULY 20 3 12 83"}, |
| |
| {"2008 07 20 03 12 83", |
| "2008 07 20 03 12 83", |
| "2008 07 20 03 12 83"}, |
| |
| {"2008 7 20 3 12 83", |
| "2008 7 20 3 12 83", |
| "2008 7 20 3 12 83"}, |
| |
| {" 2008 7 20 3 12 83", |
| " 2008 7 20 3 12 83", |
| " 2008 7 20 3 12 83", |
| "2008 7 20 3 12 83"}, |
| |
| {"2008 7 20 3 12 83 ", |
| "2008 7 20 3 12 83 ", |
| "2008 7 20 3 12 83"}, |
| |
| {"83 12 3 20 7 2008", |
| "83 12 3 20 7 2008", |
| "83 12 3 20 7 2008"}, |
| |
| {" 83 12 3 20 7 2008", |
| " 83 12 3 20 7 2008", |
| " 83 12 3 20 7 2008", |
| "83 12 3 20 7 2008"}, |
| |
| {"83 12 3 20 7 2008 ", |
| "83 12 3 20 7 2008 ", |
| "83 12 3 20 7 2008"}, |
| }; |
| |
| // For formatting |
| private static String[][] formattedDatesEG = { |
| {"2008 JULY 20 3 13 23", |
| "2009 JULY 20 3 13 23", |
| null}, |
| |
| {"2008 07 20 03 13 23", |
| "2009 07 20 03 13 23", |
| "2007 05 20 03 13 23"}, |
| |
| {"2008 7 20 3 13 23", |
| "2009 6 10 3 13 23", |
| "2007 4 10 3 13 23"}, |
| |
| {" 2008 7 20 3 13 23", |
| null, |
| " 2009 7 20 3 13 23", |
| null}, |
| |
| {"2008 7 20 3 13 23 ", |
| "2008 7 20 3 10 37 ", |
| null}, |
| |
| {"23 13 3 20 7 2008", |
| "37 10 9 19 7 2008", |
| "23 49 8 19 7 2008"}, |
| |
| {" 23 13 3 20 7 2008", |
| null, |
| " 37 10 3 20 7 2008", |
| null}, |
| |
| {"23 13 3 20 7 2008 ", |
| "23 13 3 20 7 2009 ", |
| null}, |
| }; |
| |
| private static String[][] formattedDatesUS = { |
| {"2008 JULY 20 3 13 23", |
| null, |
| "2008 JUNE 10 3 13 23"}, |
| |
| {"2008 07 20 03 13 23", |
| "2007 05 20 03 13 23", |
| "2008 06 10 03 13 23"}, |
| |
| {"2008 7 20 3 13 23", |
| "2007 5 19 9 13 23", |
| "2008 6 9 9 13 23"}, |
| |
| {" 2008 7 20 3 13 23", |
| " 2009 7 20 3 13 23", |
| " 2007 5 20 3 13 23", |
| null}, |
| |
| {"2008 7 20 3 13 23 ", |
| "2008 7 20 3 13 23 ", |
| null}, |
| |
| {"23 13 3 20 7 2008", |
| "23 49 2 10 6 2008", |
| "23 13 9 9 6 2008"}, |
| |
| {" 23 13 3 20 7 2008", |
| " 37 10 3 20 7 2008", |
| " 23 49 2 20 7 2008", |
| null}, |
| |
| {"23 13 3 20 7 2008 ", |
| "23 13 3 20 7 2008 ", |
| null}, |
| }; |
| |
| private static GregorianCalendar[][] datesEG = { |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar(-2008, JUL, 20, 3, 12, 83), |
| null}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar(-2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2007, MAY, 20, 3, 12, 83)}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar(-2008, JUL, -20, 3, 12, 83), |
| new GregorianCalendar( 2007, APR, 10, 3, 12, 83)}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| null, |
| new GregorianCalendar(-2008, JUL, 20, 3, 12, 83), |
| null}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2008, JUL, 20, 3, 12, -83), |
| null}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2008, JUL, 20, -3, 12, -83), |
| new GregorianCalendar( 2008, JUL, 20, -3, -12, 83)}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| null, |
| new GregorianCalendar( 2008, JUL, 20, 3, 12, -83), |
| null}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar(-2008, JUL, 20, 3, 12, 83), |
| null}, |
| }; |
| |
| private static GregorianCalendar[][] datesUS = { |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| null, |
| new GregorianCalendar( 2008, JUN, 10, 3, 12, 83)}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2007, MAY, 20, 3, 12, 83), |
| new GregorianCalendar( 2008, JUN, 10, 3, 12, 83)}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2007, MAY, 20, -3, 12, 83), |
| new GregorianCalendar( 2008, JUL, -20, -3, 12, 83)}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar(-2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2007, MAY, 20, 3, 12, 83), |
| null}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| null}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2008, JUL, -20, 3, -12, 83), |
| new GregorianCalendar( 2008, JUL, -20, -3, 12, 83)}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2008, JUL, 20, 3, 12, -83), |
| new GregorianCalendar( 2008, JUL, 20, 3, -12, 83), |
| null}, |
| |
| {new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| new GregorianCalendar( 2008, JUL, 20, 3, 12, 83), |
| null}, |
| }; |
| |
| /* flags */ |
| private static boolean err = false; |
| private static boolean verbose = false; |
| |
| |
| public static void main(String[] args) { |
| if (args.length == 1 && args[0].equals("-v")) { |
| verbose = true; |
| } |
| |
| Locale defaultLocale = Locale.getDefault(); |
| TimeZone defaultTimeZone = TimeZone.getDefault(); |
| |
| TimeZone.setDefault(TimeZone.getTimeZone("Asia/Tokyo")); |
| |
| try { |
| /* |
| * Test SimpleDateFormat.parse() and format() for original |
| * SimpleDateFormat instances |
| */ |
| testDateFormat1(); |
| |
| /* |
| * Test SimpleDateFormat.parse() and format() for modified |
| * SimpleDateFormat instances using an original minus sign, |
| * pattern, and diffenrent month names in DecimalFormat |
| */ |
| testDateFormat2(); |
| |
| /* |
| * Test SimpleDateFormat.parse() and format() for modified |
| * SimpleDateFormat instances using a fullwidth minus sign |
| */ |
| testDateFormat3(); |
| |
| /* |
| * Just to confirm that regressions aren't introduced in |
| * DecimalFormat. This cannot happen, though. Because I didn't |
| * change DecimalFormat at all. |
| */ |
| testNumberFormat(); |
| } |
| catch (Exception e) { |
| err = true; |
| System.err.println("Unexpected exception: " + e); |
| } |
| finally { |
| Locale.setDefault(defaultLocale); |
| TimeZone.setDefault(defaultTimeZone); |
| |
| if (err) { |
| System.err.println(BORDER + " Test failed."); |
| throw new RuntimeException("Date/Number formatting/parsing error."); |
| } else { |
| System.out.println(BORDER + " Test passed."); |
| } |
| } |
| } |
| |
| |
| // |
| // DateFormat test |
| // |
| private static void testDateFormat1() { |
| for (int i = 0; i < patterns.length; i++) { |
| System.out.println(BORDER); |
| for (int j = 0; j <= 1; j++) { |
| // Generate a pattern |
| String pattern = patterns[i].replaceAll(" ", delimiters[j]); |
| System.out.println("Pattern=\"" + pattern + "\""); |
| |
| System.out.println("*** DateFormat.format test in ar_EG"); |
| testDateFormatFormattingInRTL(pattern, i, j, null, localeEG, false); |
| |
| System.out.println("*** DateFormat.parse test in ar_EG"); |
| testDateFormatParsingInRTL(pattern, i, j, null, localeEG, false); |
| |
| System.out.println("*** DateFormat.format test in en_US"); |
| testDateFormatFormattingInLTR(pattern, i, j, null, localeUS, true); |
| |
| System.out.println("*** DateFormat.parse test in en_US"); |
| testDateFormatParsingInLTR(pattern, i, j, null, localeUS, true); |
| } |
| } |
| } |
| |
| private static void testDateFormat2() { |
| /* |
| * modified ar_EG Date&Time formatter : |
| * minus sign: ':' |
| * pattern: "#,##0.###" |
| * month names: In Arabic |
| * |
| * modified en_US Date&Time formatter : |
| * minus sign: ':' |
| * pattern: "#,##0.###;#,##0.###-" |
| * month names: In English |
| */ |
| DecimalFormat dfEG = (DecimalFormat)NumberFormat.getInstance(localeEG); |
| DecimalFormat dfUS = (DecimalFormat)NumberFormat.getInstance(localeUS); |
| |
| DecimalFormatSymbols dfsEG = dfEG.getDecimalFormatSymbols(); |
| DecimalFormatSymbols dfsUS = dfUS.getDecimalFormatSymbols(); |
| dfsEG.setMinusSign(originalMinusSign1); |
| dfsUS.setMinusSign(originalMinusSign1); |
| dfEG.setDecimalFormatSymbols(dfsUS); |
| dfUS.setDecimalFormatSymbols(dfsEG); |
| |
| String patternEG = dfEG.toPattern(); |
| String patternUS = dfUS.toPattern(); |
| |
| dfEG.applyPattern(patternUS); |
| dfUS.applyPattern(patternEG); |
| |
| for (int i = 0; i < patterns.length; i++) { |
| System.out.println(BORDER); |
| for (int j = 2; j <= 3; j++) { |
| // Generate a pattern |
| String pattern = patterns[i].replaceAll(" ", delimiters[j]); |
| System.out.println("Pattern=\"" + pattern + "\""); |
| |
| System.out.println("*** DateFormat.format test in modified en_US"); |
| testDateFormatFormattingInRTL(pattern, i, j, dfUS, localeUS, true); |
| |
| System.out.println("*** DateFormat.parse test in modified en_US"); |
| testDateFormatParsingInRTL(pattern, i, j, dfUS, localeUS, true); |
| |
| System.out.println("*** DateFormat.format test in modified ar_EG"); |
| testDateFormatFormattingInLTR(pattern, i, j, dfEG, localeEG, false); |
| |
| System.out.println("*** DateFormat.parse test in modified ar_EG"); |
| testDateFormatParsingInLTR(pattern, i, j, dfEG, localeEG, false); |
| } |
| } |
| } |
| |
| private static void testDateFormat3() { |
| /* |
| * modified ar_EG Date&Time formatter : |
| * minus sign: '\uff0d' // fullwidth minus |
| * pattern: "#,##0.###;#,##0.###-" |
| * month names: In Arabic |
| * |
| * modified en_US Date&Time formatter : |
| * minus sign: '\uff0d' // fullwidth minus |
| * pattern: "#,##0.###" |
| * month names: In English |
| */ |
| DecimalFormat dfEG = (DecimalFormat)NumberFormat.getInstance(localeEG); |
| DecimalFormat dfUS = (DecimalFormat)NumberFormat.getInstance(localeUS); |
| |
| DecimalFormatSymbols dfsEG = dfEG.getDecimalFormatSymbols(); |
| DecimalFormatSymbols dfsUS = dfUS.getDecimalFormatSymbols(); |
| dfsEG.setMinusSign(originalMinusSign2); |
| dfsUS.setMinusSign(originalMinusSign2); |
| dfEG.setDecimalFormatSymbols(dfsEG); |
| dfUS.setDecimalFormatSymbols(dfsUS); |
| |
| for (int i = 0; i < patterns.length; i++) { |
| System.out.println(BORDER); |
| for (int j = 4; j <= 5; j++) { |
| // Generate a pattern |
| String pattern = patterns[i].replaceAll(" ", delimiters[j]); |
| System.out.println("Pattern=\"" + pattern + "\""); |
| |
| System.out.println("*** DateFormat.format test in modified ar_EG"); |
| testDateFormatFormattingInRTL(pattern, i, j, dfEG, localeEG, false); |
| |
| System.out.println("*** DateFormat.parse test in modified ar_EG"); |
| testDateFormatParsingInRTL(pattern, i, j, dfEG, localeEG, false); |
| |
| System.out.println("*** DateFormat.format test in modified en_US"); |
| testDateFormatFormattingInLTR(pattern, i, j, dfUS, localeUS, true); |
| |
| System.out.println("*** DateFormat.parse test in modified en_US"); |
| testDateFormatParsingInLTR(pattern, i, j, dfUS, localeUS, true); |
| } |
| } |
| } |
| |
| private static void testDateFormatFormattingInRTL(String pattern, |
| int basePattern, |
| int delimiter, |
| NumberFormat nf, |
| Locale locale, |
| boolean useEnglishMonthName) { |
| Locale.setDefault(locale); |
| |
| SimpleDateFormat sdf = new SimpleDateFormat(pattern); |
| if (nf != null) { |
| sdf.setNumberFormat(nf); |
| } |
| for (int i = 0; i < datesToParse[basePattern].length; i++) { |
| if (datesEG[basePattern][i] == null) { |
| continue; |
| } |
| |
| String expected = formattedDatesEG[basePattern][i] |
| .replaceAll("JUNE", (useEnglishMonthName ? |
| JuneInEnglish : JuneInArabic)) |
| .replaceAll("JULY", (useEnglishMonthName ? |
| JulyInEnglish : JulyInArabic)) |
| .replaceAll(" ", delimiters[delimiter]); |
| testDateFormatFormatting(sdf, pattern, datesEG[basePattern][i], |
| expected, locale.toString()); |
| } |
| } |
| |
| private static void testDateFormatFormattingInLTR(String pattern, |
| int basePattern, |
| int delimiter, |
| NumberFormat nf, |
| Locale locale, |
| boolean useEnglishMonthName) { |
| Locale.setDefault(locale); |
| |
| SimpleDateFormat sdf = new SimpleDateFormat(pattern); |
| if (nf != null) { |
| sdf.setNumberFormat(nf); |
| } |
| for (int i = 0; i < datesToParse[basePattern].length; i++) { |
| if (datesUS[basePattern][i] == null) { |
| continue; |
| } |
| |
| String expected = formattedDatesUS[basePattern][i] |
| .replaceAll("JUNE", (useEnglishMonthName ? |
| JuneInEnglish : JuneInArabic)) |
| .replaceAll("JULY", (useEnglishMonthName ? |
| JulyInEnglish : JulyInArabic)) |
| .replaceAll(" ", delimiters[delimiter]); |
| testDateFormatFormatting(sdf, pattern, datesUS[basePattern][i], |
| expected, locale.toString()); |
| } |
| } |
| |
| private static void testDateFormatFormatting(SimpleDateFormat sdf, |
| String pattern, |
| GregorianCalendar givenGC, |
| String expected, |
| String locale) { |
| Date given = givenGC.getTime(); |
| String str = sdf.format(given); |
| if (expected.equals(str)) { |
| if (verbose) { |
| System.out.print(" Passed: SimpleDateFormat("); |
| System.out.print(locale + ", \"" + pattern + "\").format("); |
| System.out.println(given + ")"); |
| |
| System.out.print(" ---> \"" + str + "\" "); |
| System.out.println((givenGC.get(ERA) == BC) ? "(BC)" : "(AD)"); |
| } |
| } else { |
| err = true; |
| |
| System.err.print(" Failed: Unexpected SimpleDateFormat("); |
| System.out.print(locale + ", \"" + pattern + "\").format("); |
| System.out.println(given + ") result."); |
| |
| System.out.println(" Expected: \"" + expected + "\""); |
| |
| System.out.print(" Got: \"" + str + "\" "); |
| System.out.println((givenGC.get(ERA) == BC) ? "(BC)" : "(AD)"); |
| } |
| } |
| |
| private static void testDateFormatParsingInRTL(String pattern, |
| int basePattern, |
| int delimiter, |
| NumberFormat nf, |
| Locale locale, |
| boolean useEnglishMonthName) { |
| Locale.setDefault(locale); |
| |
| SimpleDateFormat sdf = new SimpleDateFormat(pattern); |
| if (nf != null) { |
| sdf.setNumberFormat(nf); |
| } |
| for (int i = 0; i < datesToParse[basePattern].length; i++) { |
| String given = datesToParse[basePattern][i] |
| .replaceAll(" ", specialDelimiters[0][delimiter]) |
| .replaceAll(" ", delimiters[delimiter]); |
| |
| testDateFormatParsing(sdf, pattern, |
| given.replaceAll("JULY", (useEnglishMonthName ? |
| JulyInEnglish : JulyInArabic)), |
| datesEG[basePattern][i], locale.toString()); |
| } |
| } |
| |
| private static void testDateFormatParsingInLTR(String pattern, |
| int basePattern, |
| int delimiter, |
| NumberFormat nf, |
| Locale locale, |
| boolean useEnglishMonthName) { |
| Locale.setDefault(locale); |
| |
| SimpleDateFormat sdf = new SimpleDateFormat(pattern); |
| if (nf != null) { |
| sdf.setNumberFormat(nf); |
| } |
| for (int i = 0; i < datesToParse[basePattern].length; i++) { |
| String given = datesToParse[basePattern][i] |
| .replaceAll(" ", specialDelimiters[1][delimiter]) |
| .replaceAll(" ", delimiters[delimiter]); |
| |
| testDateFormatParsing(sdf, pattern, |
| given.replaceAll("JULY", (useEnglishMonthName ? |
| JulyInEnglish : JulyInArabic)), |
| datesUS[basePattern][i], locale.toString()); |
| } |
| } |
| |
| private static void testDateFormatParsing(SimpleDateFormat sdf, |
| String pattern, |
| String given, |
| GregorianCalendar expectedGC, |
| String locale) { |
| try { |
| Date d = sdf.parse(given); |
| if (expectedGC == null) { |
| err = true; |
| System.err.print(" Failed: SimpleDateFormat(" + locale); |
| System.err.print(", \"" + pattern + "\").parse(\"" + given); |
| System.err.println("\") should have thrown ParseException"); |
| } else if (expectedGC.getTime().equals(d)) { |
| if (verbose) { |
| System.out.print(" Passed: SimpleDateFormat(" + locale); |
| System.out.print(", \"" + pattern + "\").parse(\"" + given); |
| System.out.println("\")"); |
| |
| System.out.print(" ---> " + d + " (" + d.getTime()); |
| System.out.println(")"); |
| } |
| } else { |
| err = true; |
| System.err.print(" Failed: SimpleDateFormat(" + locale); |
| System.err.print(", \"" + pattern + "\").parse(\"" + given); |
| System.err.println("\")"); |
| |
| System.err.print(" Expected: " + expectedGC.getTime()); |
| System.err.println(" (" + d.getTime() + ")"); |
| |
| System.err.print(" Got: " + d + " (" + d.getTime()); |
| System.err.println(")"); |
| |
| System.err.print(" Pattern: \""); |
| System.err.print(((DecimalFormat)sdf.getNumberFormat()).toPattern()); |
| System.err.println("\""); |
| } |
| } |
| catch (ParseException pe) { |
| if (expectedGC == null) { |
| if (verbose) { |
| System.out.print(" Passed: SimpleDateFormat(" + locale); |
| System.out.print(", \"" + pattern + "\").parse(\"" + given); |
| System.out.println("\")"); |
| |
| System.out.println(" threw ParseException as expected"); |
| } |
| } else { |
| err = true; |
| System.err.println(" Failed: Unexpected exception with"); |
| |
| System.err.print(" SimpleDateFormat(" + locale); |
| System.err.print(", \"" + pattern + "\").parse(\""); |
| System.err.println(given + "\"):"); |
| |
| System.err.println(" " + pe); |
| |
| System.err.print(" Pattern: \""); |
| System.err.print(((DecimalFormat)sdf.getNumberFormat()).toPattern()); |
| System.err.println("\""); |
| |
| System.err.print(" Month 0: "); |
| System.err.println(sdf.getDateFormatSymbols().getMonths()[0]); |
| } |
| } |
| } |
| |
| |
| // |
| // NumberFormat test |
| // |
| private static void testNumberFormat() { |
| NumberFormat nfEG = NumberFormat.getInstance(localeEG); |
| NumberFormat nfUS = NumberFormat.getInstance(localeUS); |
| |
| System.out.println("*** DecimalFormat.format test in ar_EG"); |
| testNumberFormatFormatting(nfEG, -123456789, "123,456,789-", "ar_EG"); |
| testNumberFormatFormatting(nfEG, -456, "456-", "ar_EG"); |
| |
| System.out.println("*** DecimalFormat.parse test in ar_EG"); |
| testNumberFormatParsing(nfEG, "123-", -123L, "ar_EG"); |
| testNumberFormatParsing(nfEG, "123--",-123L, "ar_EG"); |
| testNumberFormatParsingCheckException(nfEG, "-123", 0, "ar_EG"); |
| |
| System.out.println("*** DecimalFormat.format test in en_US"); |
| testNumberFormatFormatting(nfUS, -123456789, "-123,456,789", "en_US"); |
| testNumberFormatFormatting(nfUS, -456, "-456", "en_US"); |
| |
| System.out.println("*** DecimalFormat.parse test in en_US"); |
| testNumberFormatParsing(nfUS, "123-", 123L, "en_US"); |
| testNumberFormatParsing(nfUS, "-123",-123L, "en_US"); |
| testNumberFormatParsingCheckException(nfUS, "--123", 0, "en_US"); |
| } |
| |
| private static void testNumberFormatFormatting(NumberFormat nf, |
| int given, |
| String expected, |
| String locale) { |
| String str = nf.format(given); |
| if (expected.equals(str)) { |
| if (verbose) { |
| System.out.print(" Passed: NumberFormat(" + locale); |
| System.out.println(").format(" + given + ")"); |
| |
| System.out.println(" ---> \"" + str + "\""); |
| } |
| } else { |
| err = true; |
| System.err.print(" Failed: Unexpected NumberFormat(" + locale); |
| System.err.println(").format(" + given + ") result."); |
| |
| System.err.println(" Expected: \"" + expected + "\""); |
| |
| System.err.println(" Got: \"" + str + "\""); |
| } |
| } |
| |
| private static void testNumberFormatParsing(NumberFormat nf, |
| String given, |
| Number expected, |
| String locale) { |
| try { |
| Number n = nf.parse(given); |
| if (n.equals(expected)) { |
| if (verbose) { |
| System.out.print(" Passed: NumberFormat(" + locale); |
| System.out.println(").parse(\"" + given + "\")"); |
| |
| System.out.println(" ---> " + n); |
| } |
| } else { |
| err = true; |
| System.err.print(" Failed: Unexpected NumberFormat(" + locale); |
| System.err.println(").parse(\"" + given + "\") result."); |
| |
| System.err.println(" Expected: " + expected); |
| |
| System.err.println(" Got: " + n); |
| } |
| } |
| catch (ParseException pe) { |
| err = true; |
| System.err.print(" Failed: Unexpected exception with NumberFormat("); |
| System.err.println(locale + ").parse(\"" + given + "\") :"); |
| |
| System.err.println(" " + pe); |
| } |
| } |
| |
| private static void testNumberFormatParsingCheckException(NumberFormat nf, |
| String given, |
| int expected, |
| String locale) { |
| try { |
| Number n = nf.parse(given); |
| err = true; |
| |
| System.err.print(" Failed: NumberFormat(" + locale); |
| System.err.println(").parse(\"" + given + "\")"); |
| |
| System.err.println(" should have thrown ParseException"); |
| } |
| catch (ParseException pe) { |
| int errorOffset = pe.getErrorOffset(); |
| if (errorOffset == expected) { |
| if (verbose) { |
| System.out.print(" Passed: NumberFormat(" + locale); |
| System.out.println(").parse(\"" + given + "\")"); |
| |
| System.out.print(" threw ParseException as expected, and its errorOffset was correct: "); |
| System.out.println(errorOffset); |
| } |
| } else { |
| err = true; |
| System.err.print(" Failed: NumberFormat(" + locale); |
| System.err.println(").parse(\"" + given + "\")"); |
| |
| System.err.print(" threw ParseException as expected, but its errorOffset was incorrect: "); |
| System.err.println(errorOffset); |
| } |
| } |
| } |
| |
| } |
