/* * Copyright 2008 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, * CA 95054 USA or visit www.sun.com if you need additional information or * have any questions. */ /** * @test * @bug 4823811 * @summary Confirm that text which includes numbers with a trailing minus sign is parsed correctly. * @run main/othervm -Duser.timezone=GMT+09:00 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-", new Long(-123), "ar_EG"); testNumberFormatParsing(nfEG, "123--", new Long(-123), "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-", new Long(123), "en_US"); testNumberFormatParsing(nfUS, "-123", new Long(-123), "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); } } } }