jars/icu4j-4_4_2-src/main/tests/core/src/com/ibm/icu/dev/test/format/NumberFormatRegressionTest.java

   1 /*\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2001-2009, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 \r
   8 /** \r
   9  * Port From:   ICU4C v1.8.1 : format : NumberFormatRegressionTest\r
  10  * Source File: $ICU4CRoot/source/test/intltest/numrgts.cpp\r
  11  **/\r
  12 \r
  13 package com.ibm.icu.dev.test.format;\r
  14 \r
  15 import java.io.ByteArrayInputStream;\r
  16 import java.io.IOException;\r
  17 import java.io.ObjectInputStream;\r
  18 import java.text.ParseException;\r
  19 import java.util.Date;\r
  20 import java.util.Locale;\r
  21 \r
  22 import com.ibm.icu.text.DateFormat;\r
  23 import com.ibm.icu.text.DecimalFormat;\r
  24 import com.ibm.icu.text.DecimalFormatSymbols;\r
  25 import com.ibm.icu.text.NumberFormat;\r
  26 import com.ibm.icu.util.Calendar;\r
  27 import com.ibm.icu.util.ULocale;\r
  28 \r
  29 /** \r
  30  * Performs regression test for MessageFormat\r
  31  **/\r
  32 public class NumberFormatRegressionTest extends com.ibm.icu.dev.test.TestFmwk {\r
  33     \r
  34     public static void main(String[] args) throws Exception{\r
  35         new NumberFormatRegressionTest().run(args);\r
  36     }\r
  37     \r
  38     /**\r
  39      * alphaWorks upgrade\r
  40      */\r
  41     public void Test4161100() {\r
  42         NumberFormat nf = NumberFormat.getInstance(Locale.US);\r
  43         nf.setMinimumFractionDigits(1);\r
  44         nf.setMaximumFractionDigits(1);\r
  45         double a = -0.09;\r
  46         String s = nf.format(a);\r
  47         logln(a + " x " +\r
  48               ((DecimalFormat) nf).toPattern() + " = " + s);\r
  49         if (!s.equals("-0.1")) {\r
  50             errln("FAIL");\r
  51         }\r
  52     }\r
  53     \r
  54     /**\r
  55      * DateFormat should call setIntegerParseOnly(TRUE) on adopted\r
  56      * NumberFormat objects.\r
  57      */\r
  58     public void TestJ691() {\r
  59         \r
  60         Locale loc = new Locale("fr", "CH");\r
  61     \r
  62         // set up the input date string & expected output\r
  63         String udt = "11.10.2000";\r
  64         String exp = "11.10.00";\r
  65     \r
  66         // create a Calendar for this locale\r
  67         Calendar cal = Calendar.getInstance(loc);\r
  68     \r
  69         // create a NumberFormat for this locale\r
  70         NumberFormat nf = NumberFormat.getInstance(loc);\r
  71     \r
  72         // *** Here's the key: We don't want to have to do THIS:\r
  73         //nf.setParseIntegerOnly(true);\r
  74     \r
  75         // create the DateFormat\r
  76         DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, loc);\r
  77     \r
  78         df.setCalendar(cal);\r
  79         df.setNumberFormat(nf);\r
  80     \r
  81         // set parsing to lenient & parse\r
  82         Date ulocdat = new Date();\r
  83         df.setLenient(true);\r
  84         try {\r
  85             ulocdat = df.parse(udt);\r
  86         } catch (java.text.ParseException pe) {\r
  87             errln(pe.getMessage());\r
  88         }\r
  89         // format back to a string\r
  90         String outString = df.format(ulocdat);\r
  91     \r
  92         if (!outString.equals(exp)) {\r
  93             errln("FAIL: " + udt + " => " + outString);\r
  94         }\r
  95     }\r
  96     \r
  97     /**\r
  98      * Test getIntegerInstance();\r
  99      */\r
 100     public void Test4408066() {\r
 101         \r
 102         NumberFormat nf1 = NumberFormat.getIntegerInstance();\r
 103         NumberFormat nf2 = NumberFormat.getIntegerInstance(Locale.CHINA);\r
 104     \r
 105         //test isParseIntegerOnly\r
 106         if (!nf1.isParseIntegerOnly() || !nf2.isParseIntegerOnly()) {\r
 107             errln("Failed : Integer Number Format Instance should set setParseIntegerOnly(true)");\r
 108         }\r
 109     \r
 110         //Test format\r
 111         {\r
 112             double[] data = {\r
 113                 -3.75, -2.5, -1.5, \r
 114                 -1.25, 0,    1.0, \r
 115                 1.25,  1.5,  2.5, \r
 116                 3.75,  10.0, 255.5\r
 117                 };\r
 118             String[] expected = {\r
 119                 "-4", "-2", "-2",\r
 120                 "-1", "0",  "1",\r
 121                 "1",  "2",  "2",\r
 122                 "4",  "10", "256"\r
 123                 };\r
 124     \r
 125             for (int i = 0; i < data.length; ++i) {\r
 126                 String result = nf1.format(data[i]);\r
 127                 if (!result.equals(expected[i])) {\r
 128                     errln("Failed => Source: " + Double.toString(data[i]) \r
 129                         + ";Formatted : " + result\r
 130                         + ";but expectted: " + expected[i]);\r
 131                 }\r
 132             }\r
 133         }\r
 134         //Test parse, Parsing should stop at "."\r
 135         {\r
 136             String data[] = {\r
 137                 "-3.75", "-2.5", "-1.5", \r
 138                 "-1.25", "0",    "1.0", \r
 139                 "1.25",  "1.5",  "2.5", \r
 140                 "3.75",  "10.0", "255.5"\r
 141                 };\r
 142             long[] expected = {\r
 143                 -3, -2, -1,\r
 144                 -1, 0,  1,\r
 145                 1,  1,  2,\r
 146                 3,  10, 255\r
 147                 };\r
 148             \r
 149             for (int i = 0; i < data.length; ++i) {\r
 150                 Number n = null;\r
 151                 try {\r
 152                     n = nf1.parse(data[i]);\r
 153                 } catch (ParseException e) {\r
 154                     errln("Failed: " + e.getMessage());\r
 155                 }\r
 156                 if (!(n instanceof Long) || (n instanceof Integer)) {\r
 157                     errln("Failed: Integer Number Format should parse string to Long/Integer");\r
 158                 }\r
 159                 if (n.longValue() != expected[i]) {\r
 160                     errln("Failed=> Source: " + data[i] \r
 161                         + ";result : " + n.toString()\r
 162                         + ";expected :" + Long.toString(expected[i]));\r
 163                 }\r
 164             }\r
 165         }\r
 166     }\r
 167     \r
 168     //Test New serialized DecimalFormat(2.0) read old serialized forms of DecimalFormat(1.3.1.1)\r
 169     public void TestSerialization() throws IOException{\r
 170         byte[][] contents = NumberFormatSerialTestData.getContent();\r
 171         double data = 1234.56;\r
 172         String[] expected = {\r
 173             "1,234.56", "$1,234.56", "123,456%", "1.23456E3"};\r
 174         for (int i = 0; i < 4; ++i) {\r
 175             ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(contents[i]));\r
 176             try {\r
 177                 NumberFormat format = (NumberFormat) ois.readObject();\r
 178                 String result = format.format(data);\r
 179                 if (result.equals(expected[i])) {\r
 180                     logln("OK: Deserialized bogus NumberFormat(new version read old version)");\r
 181                 } else {\r
 182                     errln("FAIL: the test data formats are not euqal");\r
 183                 }\r
 184             } catch (Exception e) {\r
 185                 warnln("FAIL: " + e.getMessage());\r
 186             }\r
 187         }\r
 188     }\r
 189 \r
 190     /*\r
 191      * Test case for JB#5509, strict parsing issue\r
 192      */\r
 193     public void TestJB5509() {\r
 194         String[] data = {\r
 195                 "1,2",\r
 196                 "1.2",\r
 197                 "1,2.5",\r
 198                 "1,23.5",\r
 199                 "1,234.5",\r
 200                 "1,234",\r
 201                 "1,234,567",\r
 202                 "1,234,567.8",\r
 203                 "1,234,5",\r
 204                 "1,234,5.6",\r
 205                 "1,234,56.7"\r
 206         };\r
 207         boolean[] expected = { // false for expected parse failure\r
 208                 false,\r
 209                 true,\r
 210                 false,\r
 211                 false,\r
 212                 true,\r
 213                 true,\r
 214                 true,\r
 215                 true,\r
 216                 false,\r
 217                 false,\r
 218                 false,\r
 219                 false\r
 220         };\r
 221 \r
 222         DecimalFormat df = new DecimalFormat("#,##0.###", new DecimalFormatSymbols(new ULocale("en_US")));\r
 223         df.setParseStrict(true);\r
 224         for (int i = 0; i < data.length; i++) {\r
 225             try {\r
 226                 df.parse(data[i]);\r
 227                 if (!expected[i]) {\r
 228                     errln("Failed: ParseException must be thrown for string " + data[i]);\r
 229                 }\r
 230             } catch (ParseException pe) {\r
 231                 if (expected[i]) {\r
 232                     errln("Failed: ParseException must not be thrown for string " + data[i]);\r
 233                 }\r
 234             }\r
 235         }\r
 236     }\r
 237 \r
 238     /*\r
 239      * Test case for ticket#5698 - parsing extremely large/small values\r
 240      */\r
 241     public void TestT5698() {\r
 242         final String[] data = {\r
 243                 "12345679E66666666666666666",\r
 244                 "-12345679E66666666666666666",\r
 245                 ".1E2147483648", // exponent > max int\r
 246                 ".1E2147483647", // exponent == max int\r
 247                 ".1E-2147483648", // exponent == min int\r
 248                 ".1E-2147483649", // exponent < min int\r
 249                 "1.23E350", // value > max double\r
 250                 "1.23E300", // value < max double\r
 251                 "-1.23E350", // value < min double\r
 252                 "-1.23E300", // value > min double\r
 253                 "4.9E-324", // value = smallest non-zero double\r
 254                 "1.0E-325", // 0 < value < smallest non-zero positive double0\r
 255                 "-1.0E-325", // 0 > value > largest non-zero negative double\r
 256         };\r
 257         final double[] expected = {\r
 258                 Double.POSITIVE_INFINITY,\r
 259                 Double.NEGATIVE_INFINITY,\r
 260                 Double.POSITIVE_INFINITY,\r
 261                 Double.POSITIVE_INFINITY,\r
 262                 0.0,\r
 263                 0.0,\r
 264                 Double.POSITIVE_INFINITY,\r
 265                 1.23e300d,\r
 266                 Double.NEGATIVE_INFINITY,\r
 267                 -1.23e300d,\r
 268                 4.9e-324d,\r
 269                 0.0,\r
 270                 -0.0,\r
 271         };\r
 272 \r
 273         NumberFormat nfmt = NumberFormat.getInstance();\r
 274 \r
 275         for (int i = 0; i < data.length; i++) {\r
 276             try {\r
 277                 Number n = nfmt.parse(data[i]);\r
 278                 if (expected[i] != n.doubleValue()) {\r
 279                     errln("Failed: Parsed result for " + data[i] + ": " \r
 280                             + n.doubleValue() + " / expected: " + expected[i]);\r
 281                 }\r
 282             } catch (ParseException pe) {\r
 283                 errln("Failed: ParseException is thrown for " + data[i]);\r
 284             }\r
 285         }\r
 286     }\r
 287     \r
 288     void checkNBSPPatternRtNum(String testcase, NumberFormat nf, double myNumber) {\r
 289         String myString = nf.format(myNumber);\r
 290         \r
 291             double aNumber;\r
 292             try {\r
 293                 aNumber = nf.parse(myString).doubleValue();\r
 294             } catch (ParseException e) {\r
 295                 // TODO Auto-generated catch block\r
 296                 errln("FAIL: " + testcase +" - failed to parse. " + e.toString());\r
 297                 return;\r
 298             }\r
 299             if(Math.abs(aNumber-myNumber)>.001) {\r
 300             errln("FAIL: "+testcase+": formatted "+myNumber+", parsed into "+aNumber+"\n");\r
 301         } else {\r
 302             logln("PASS: "+testcase+": formatted "+myNumber+", parsed into "+aNumber+"\n");\r
 303         }\r
 304     }\r
 305 \r
 306     void checkNBSPPatternRT(String testcase, NumberFormat nf) {\r
 307         checkNBSPPatternRtNum(testcase, nf, 12345.);\r
 308         checkNBSPPatternRtNum(testcase, nf, -12345.);\r
 309     }\r
 310 \r
 311     public void TestNBSPInPattern() {\r
 312     NumberFormat nf = null;\r
 313     String testcase;\r
 314     \r
 315     \r
 316     testcase="ar_AE UNUM_CURRENCY";\r
 317     nf = NumberFormat.getCurrencyInstance(new ULocale("ar_AE"));\r
 318     checkNBSPPatternRT(testcase, nf);\r
 319     // if we don't have CLDR 1.6 data, bring out the problem anyways \r
 320     \r
 321     String SPECIAL_PATTERN = "\u00A4\u00A4'\u062f.\u0625.\u200f\u00a0'###0.00";\r
 322     testcase = "ar_AE special pattern: " + SPECIAL_PATTERN;\r
 323     nf = new DecimalFormat();\r
 324     ((DecimalFormat)nf).applyPattern(SPECIAL_PATTERN);\r
 325     checkNBSPPatternRT(testcase, nf);\r
 326     \r
 327     }\r
 328     \r
 329 }\r