jars/icu4j-4_4_2-src/main/tests/collate/src/com/ibm/icu/dev/test/collator/CollationServiceTest.java

   1 /*\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2003-2009, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 \r
   8 package com.ibm.icu.dev.test.collator;\r
   9 \r
  10 import java.util.Arrays;\r
  11 import java.util.Collections;\r
  12 import java.util.HashMap;\r
  13 import java.util.HashSet;\r
  14 import java.util.Iterator;\r
  15 import java.util.Locale;\r
  16 import java.util.Map;\r
  17 import java.util.MissingResourceException;\r
  18 import java.util.Set;\r
  19 \r
  20 import com.ibm.icu.dev.test.TestFmwk;\r
  21 import com.ibm.icu.text.Collator;\r
  22 import com.ibm.icu.text.Collator.CollatorFactory;\r
  23 import com.ibm.icu.util.ULocale;\r
  24 \r
  25 public class CollationServiceTest extends TestFmwk {\r
  26     public static void main(String[] args) {\r
  27         new CollationServiceTest().run(args);\r
  28     }\r
  29 \r
  30     public void TestRegister() {\r
  31         // register a singleton\r
  32         Collator frcol = Collator.getInstance(ULocale.FRANCE);\r
  33         Collator uscol = Collator.getInstance(ULocale.US);\r
  34             \r
  35         { // try override en_US collator\r
  36             Object key = Collator.registerInstance(frcol, ULocale.US);\r
  37             Collator ncol = Collator.getInstance(ULocale.US);\r
  38             if (!frcol.equals(ncol)) {\r
  39                 errln("register of french collator for en_US failed");\r
  40             }\r
  41 \r
  42             // coverage\r
  43             Collator test = Collator.getInstance(ULocale.GERMANY); // CollatorFactory.handleCreate\r
  44             if (!test.getLocale(ULocale.VALID_LOCALE).equals(ULocale.GERMANY)) {\r
  45                 errln("Collation from Germany is really " + test.getLocale(ULocale.VALID_LOCALE));\r
  46             }\r
  47 \r
  48             if (!Collator.unregister(key)) {\r
  49                 errln("failed to unregister french collator");\r
  50             }\r
  51             ncol = Collator.getInstance(ULocale.US);\r
  52             if (!uscol.equals(ncol)) {\r
  53                 errln("collator after unregister does not match original");\r
  54             }\r
  55         }\r
  56 \r
  57         ULocale fu_FU = new ULocale("fu_FU_FOO");\r
  58 \r
  59         { // try create collator for new locale\r
  60             Collator fucol = Collator.getInstance(fu_FU);\r
  61             Object key = Collator.registerInstance(frcol, fu_FU);\r
  62             Collator ncol = Collator.getInstance(fu_FU);\r
  63             if (!frcol.equals(ncol)) {\r
  64                 errln("register of fr collator for fu_FU failed");\r
  65             }\r
  66             \r
  67             ULocale[] locales = Collator.getAvailableULocales();\r
  68             boolean found = false;\r
  69             for (int i = 0; i < locales.length; ++i) {\r
  70                 if (locales[i].equals(fu_FU)) {\r
  71                     found = true;\r
  72                     break;\r
  73                 }\r
  74             }\r
  75             if (!found) {\r
  76                 errln("new locale fu_FU not reported as supported locale");\r
  77             }\r
  78             try{\r
  79                 String name = Collator.getDisplayName(fu_FU);\r
  80                 if (!"fu (FU, FOO)".equals(name)) {\r
  81                     errln("found " + name + " for fu_FU");\r
  82                 }\r
  83             }catch(MissingResourceException ex){\r
  84                 warnln("Could not load locale data."); \r
  85             }\r
  86             try{\r
  87                 String name = Collator.getDisplayName(fu_FU, fu_FU);\r
  88                 if (!"fu (FU, FOO)".equals(name)) {\r
  89                     errln("found " + name + " for fu_FU");\r
  90                 }\r
  91             }catch(MissingResourceException ex){\r
  92                 warnln("Could not load locale data."); \r
  93             }\r
  94 \r
  95             if (!Collator.unregister(key)) {\r
  96                 errln("failed to unregister french collator");\r
  97             }\r
  98             ncol = Collator.getInstance(fu_FU);\r
  99             if (!fucol.equals(ncol)) {\r
 100                 errln("collator after unregister does not match original fu_FU");\r
 101             }\r
 102         }\r
 103 \r
 104         {\r
 105             // coverage after return to default \r
 106             ULocale[] locales = Collator.getAvailableULocales();\r
 107     \r
 108             for (int i = 0; i < locales.length; ++i) {\r
 109                 if (locales[i].equals(fu_FU)) {\r
 110                     errln("new locale fu_FU not reported as supported locale");\r
 111                     break;\r
 112                 }\r
 113             }\r
 114 \r
 115             Collator ncol = Collator.getInstance(ULocale.US);\r
 116             if (!ncol.getLocale(ULocale.VALID_LOCALE).equals(ULocale.US)) {\r
 117                 errln("Collation from US is really " + ncol.getLocale(ULocale.VALID_LOCALE));\r
 118             }\r
 119         }\r
 120     }\r
 121 \r
 122     public void TestRegisterFactory() {\r
 123 \r
 124         class CollatorInfo {\r
 125             ULocale locale;\r
 126             Collator collator;\r
 127             Map displayNames; // locale -> string\r
 128 \r
 129             CollatorInfo(ULocale locale, Collator collator, Map displayNames) {\r
 130                 this.locale = locale;\r
 131                 this.collator = collator;\r
 132                 this.displayNames = displayNames;\r
 133             }\r
 134 \r
 135             String getDisplayName(ULocale displayLocale) {\r
 136                 String name = null;\r
 137                 if (displayNames != null) {\r
 138                     name = (String)displayNames.get(displayLocale);\r
 139                 }\r
 140                 if (name == null) {\r
 141                     name = locale.getDisplayName(displayLocale);\r
 142                 }\r
 143                 return name;\r
 144             }\r
 145         }\r
 146 \r
 147         class TestFactory extends CollatorFactory {\r
 148             private Map map;\r
 149             private Set ids;\r
 150             \r
 151             TestFactory(CollatorInfo[] info) {\r
 152                 map = new HashMap();\r
 153                 for (int i = 0; i < info.length; ++i) {\r
 154                     CollatorInfo ci = info[i];\r
 155                     map.put(ci.locale, ci);\r
 156                 }\r
 157             }\r
 158 \r
 159             public Collator createCollator(ULocale loc) {\r
 160                 CollatorInfo ci = (CollatorInfo)map.get(loc);\r
 161                 if (ci != null) {\r
 162                     return ci.collator;\r
 163                 }\r
 164                 return null;\r
 165             }\r
 166 \r
 167             public String getDisplayName(ULocale objectLocale, ULocale displayLocale) {\r
 168                 CollatorInfo ci = (CollatorInfo)map.get(objectLocale);\r
 169                 if (ci != null) {\r
 170                     return ci.getDisplayName(displayLocale);\r
 171                 }\r
 172                 return null;\r
 173             }\r
 174 \r
 175             public Set getSupportedLocaleIDs() {\r
 176                 if (ids == null) {\r
 177                     HashSet set = new HashSet();\r
 178                     Iterator iter = map.keySet().iterator();\r
 179                     while (iter.hasNext()) {\r
 180                         ULocale locale = (ULocale)iter.next();\r
 181                         String id = locale.toString();\r
 182                         set.add(id);\r
 183                     }\r
 184                     ids = Collections.unmodifiableSet(set);\r
 185                 }\r
 186                 return ids;\r
 187             }\r
 188         }\r
 189     \r
 190         class TestFactoryWrapper extends CollatorFactory {\r
 191             CollatorFactory delegate;\r
 192     \r
 193             TestFactoryWrapper(CollatorFactory delegate) {\r
 194                 this.delegate = delegate;\r
 195             }\r
 196     \r
 197             public Collator createCollator(ULocale loc) {\r
 198                 return delegate.createCollator(loc);\r
 199             }\r
 200     \r
 201             // use CollatorFactory getDisplayName(ULocale, ULocale) for coverage\r
 202     \r
 203             public Set getSupportedLocaleIDs() {\r
 204                 return delegate.getSupportedLocaleIDs();\r
 205             }\r
 206         }\r
 207 \r
 208         ULocale fu_FU = new ULocale("fu_FU");\r
 209         ULocale fu_FU_FOO = new ULocale("fu_FU_FOO");\r
 210 \r
 211         Map fuFUNames = new HashMap();\r
 212         fuFUNames.put(fu_FU, "ze leetle bunny Fu-Fu");\r
 213         fuFUNames.put(fu_FU_FOO, "zee leetel bunny Foo-Foo");\r
 214         fuFUNames.put(ULocale.US, "little bunny Foo Foo");\r
 215 \r
 216         Collator frcol = Collator.getInstance(ULocale.FRANCE);\r
 217        /* Collator uscol = */Collator.getInstance(ULocale.US);\r
 218         Collator gecol = Collator.getInstance(ULocale.GERMANY);\r
 219         Collator jpcol = Collator.getInstance(ULocale.JAPAN);\r
 220         Collator fucol = Collator.getInstance(fu_FU);\r
 221         \r
 222         CollatorInfo[] info = {\r
 223             new CollatorInfo(ULocale.US, frcol, null),\r
 224             new CollatorInfo(ULocale.FRANCE, gecol, null),\r
 225             new CollatorInfo(fu_FU, jpcol, fuFUNames),\r
 226         };\r
 227         TestFactory factory = null;\r
 228         try{\r
 229             factory = new TestFactory(info);\r
 230         }catch(MissingResourceException ex){\r
 231             warnln("Could not load locale data."); \r
 232         }\r
 233         // coverage\r
 234         {\r
 235             TestFactoryWrapper wrapper = new TestFactoryWrapper(factory); // in java, gc lets us easily multiply reference!\r
 236             Object key = Collator.registerFactory(wrapper);\r
 237             String name = null;\r
 238             try{\r
 239                 name = Collator.getDisplayName(fu_FU, fu_FU_FOO);\r
 240             }catch(MissingResourceException ex){\r
 241                 warnln("Could not load locale data."); \r
 242             }\r
 243             logln("*** default name: " + name);\r
 244             Collator.unregister(key);\r
 245     \r
 246             ULocale bar_BAR = new ULocale("bar_BAR");\r
 247             Collator col = Collator.getInstance(bar_BAR);\r
 248             if (!col.getLocale(ULocale.VALID_LOCALE).equals(ULocale.getDefault())) {\r
 249                 errln("Collation from bar_BAR is really " + col.getLocale(ULocale.VALID_LOCALE));\r
 250             }\r
 251         }\r
 252 \r
 253         int n1 = checkAvailable("before registerFactory");\r
 254         \r
 255         {\r
 256             Object key = Collator.registerFactory(factory);\r
 257             \r
 258             int n2 = checkAvailable("after registerFactory");\r
 259             \r
 260             Collator ncol = Collator.getInstance(ULocale.US);\r
 261             if (!frcol.equals(ncol)) {\r
 262                 errln("frcoll for en_US failed");\r
 263             }\r
 264 \r
 265             ncol = Collator.getInstance(fu_FU_FOO);\r
 266             if (!jpcol.equals(ncol)) {\r
 267                 errln("jpcol for fu_FU_FOO failed, got: " + ncol);\r
 268             }\r
 269             \r
 270             ULocale[] locales = Collator.getAvailableULocales();\r
 271             boolean found = false;\r
 272             for (int i = 0; i < locales.length; ++i) {\r
 273                 if (locales[i].equals(fu_FU)) {\r
 274                     found = true;\r
 275                     break;\r
 276                 }\r
 277             }\r
 278             if (!found) {\r
 279                 errln("new locale fu_FU not reported as supported locale");\r
 280             }\r
 281             \r
 282             String name = Collator.getDisplayName(fu_FU);\r
 283             if (!"little bunny Foo Foo".equals(name)) {\r
 284                 errln("found " + name + " for fu_FU");\r
 285             }\r
 286 \r
 287             name = Collator.getDisplayName(fu_FU, fu_FU_FOO);\r
 288             if (!"zee leetel bunny Foo-Foo".equals(name)) {\r
 289                 errln("found " + name + " for fu_FU in fu_FU_FOO");\r
 290             }\r
 291 \r
 292             if (!Collator.unregister(key)) {\r
 293                 errln("failed to unregister factory");\r
 294             }\r
 295 \r
 296             int n3 = checkAvailable("after unregister");\r
 297             assertTrue("register increases count", n2>n1);\r
 298             assertTrue("unregister restores count", n3==n1);\r
 299             \r
 300             ncol = Collator.getInstance(fu_FU);\r
 301             if (!fucol.equals(ncol)) {\r
 302                 errln("collator after unregister does not match original fu_FU");\r
 303             }\r
 304         }\r
 305     }\r
 306 \r
 307     /**\r
 308      * Check the integrity of the results of Collator.getAvailableULocales().\r
 309      * Return the number of items returned.\r
 310      */\r
 311     int checkAvailable(String msg) {\r
 312         Locale locs[] = Collator.getAvailableLocales();\r
 313         if (!assertTrue("getAvailableLocales != null", locs!=null)) return -1;\r
 314         checkArray(msg, locs, null);\r
 315         ULocale ulocs[] = Collator.getAvailableULocales();\r
 316         if (!assertTrue("getAvailableULocales != null", ulocs!=null)) return -1;\r
 317         checkArray(msg, ulocs, null);\r
 318         // This is not true because since ULocale objects with script code cannot be \r
 319         // converted to Locale objects\r
 320         //assertTrue("getAvailableLocales().length == getAvailableULocales().length", locs.length == ulocs.length);\r
 321         return locs.length;\r
 322     }\r
 323     \r
 324     private static final String KW[] = {\r
 325         "collation"\r
 326     };\r
 327 \r
 328     private static final String KWVAL[] = {\r
 329         "phonebook",\r
 330         "stroke"\r
 331     };\r
 332 \r
 333     public void TestSeparateTrees() {\r
 334         String kw[] = Collator.getKeywords();\r
 335         if (!assertTrue("getKeywords != null", kw!=null)) return;\r
 336         checkArray("getKeywords", kw, KW);\r
 337         \r
 338         String kwval[] = Collator.getKeywordValues(KW[0]);\r
 339         if (!assertTrue("getKeywordValues != null", kwval!=null)) return;\r
 340         checkArray("getKeywordValues", kwval, KWVAL);\r
 341 \r
 342         boolean isAvailable[] = new boolean[1];\r
 343         ULocale equiv = Collator.getFunctionalEquivalent(KW[0],\r
 344                                                          new ULocale("fr"),\r
 345                                                          isAvailable);\r
 346         if (assertTrue("getFunctionalEquivalent(fr)!=null", equiv!=null)) {\r
 347             assertEquals("getFunctionalEquivalent(fr)", "fr", equiv.toString());\r
 348         }\r
 349         assertTrue("getFunctionalEquivalent(fr).isAvailable==true",\r
 350                    isAvailable[0] == true);\r
 351         \r
 352         equiv = Collator.getFunctionalEquivalent(KW[0],\r
 353                                                  new ULocale("fr_FR"),\r
 354                                                  isAvailable);\r
 355         if (assertTrue("getFunctionalEquivalent(fr_FR)!=null", equiv!=null)) {\r
 356             assertEquals("getFunctionalEquivalent(fr_FR)", "fr", equiv.toString());\r
 357         }\r
 358         assertTrue("getFunctionalEquivalent(fr_FR).isAvailable==true",\r
 359                    isAvailable[0] == true);\r
 360 \r
 361         equiv = Collator.getFunctionalEquivalent(KW[0], new ULocale("zh_Hans"));\r
 362         if (assertTrue("getFunctionalEquivalent(zh_Hans)!=null", equiv!=null)) {\r
 363             assertEquals("getFunctionalEquivalent(zh_Hans)", "zh", equiv.toString());\r
 364         }\r
 365     }\r
 366     \r
 367     public void TestGetFunctionalEquivalent() {\r
 368         String kw[] = Collator.getKeywords();\r
 369         final String DATA[] = { \r
 370                           "de", "de", "t",\r
 371                           "de@collation=direct", "de", "t",\r
 372                           "de@collation=traditional", "de", "t",\r
 373                           "de@collation=gb2312han", "de", "t",\r
 374                           "de@collation=stroke", "de", "t",\r
 375                           "de@collation=pinyin", "de", "t",\r
 376                           "de@collation=phonebook", "de@collation=phonebook", "t",\r
 377                           "de@collation=big5han", "de", "t",\r
 378                           "de_AT", "de", "t",\r
 379                           "de_AT@collation=direct", "de", "t",\r
 380                           "de_AT@collation=traditional", "de", "t",\r
 381                           "de_AT@collation=gb2312han", "de", "t",\r
 382                           "de_AT@collation=stroke", "de", "t",\r
 383                           "de_AT@collation=pinyin", "de", "t",\r
 384                           "de_AT@collation=phonebook", "de@collation=phonebook", "t",\r
 385                           "de_AT@collation=big5han", "de", "t",\r
 386                           "nl", "root", "t",\r
 387                           "nl@collation=direct", "root", "t",\r
 388                           "nl_BE", "root", "t",\r
 389                           "nl_BE@collation=direct", "root", "t",\r
 390                           "nl_BE@collation=traditional", "root", "t",\r
 391                           "nl_BE@collation=gb2312han", "root", "t",\r
 392                           "nl_BE@collation=stroke", "root", "t",\r
 393                           "nl_BE@collation=pinyin", "root", "t",\r
 394                           "nl_BE@collation=big5han", "root", "t",\r
 395                           "nl_BE@collation=phonebook", "root", "t",\r
 396                           "en_US_VALLEYGIRL","en","f"\r
 397                         };\r
 398         final int DATA_COUNT=(DATA.length/3);\r
 399         \r
 400         for(int i=0;i<DATA_COUNT;i++) {\r
 401             boolean isAvailable[] = new boolean[1];\r
 402             ULocale input = new ULocale(DATA[(i*3)+0]);\r
 403             ULocale expect = new ULocale(DATA[(i*3)+1]);\r
 404             boolean expectAvailable = DATA[(i*3)+2].equals("t");\r
 405             ULocale actual = Collator.getFunctionalEquivalent(kw[0],input,isAvailable);\r
 406             if(!actual.equals(expect) || (expectAvailable!=isAvailable[0])) {\r
 407                 errln("#" + i + ": Collator.getFunctionalEquivalent(" + input + ")=" + actual + ", avail " + new Boolean(isAvailable[0]) + ", " +\r
 408                         "expected " + expect + " avail " + new Boolean(expectAvailable));\r
 409             } else {\r
 410                 logln("#" + i + ": Collator.getFunctionalEquivalent(" + input + ")=" + actual + ", avail " + new Boolean(isAvailable[0]));\r
 411             }\r
 412         }\r
 413     }\r
 414 \r
 415 //    public void PrintFunctionalEquivalentList() {\r
 416 //        ULocale[] locales = Collator.getAvailableULocales();\r
 417 //        String[] keywords = Collator.getKeywords();\r
 418 //        logln("Collation");\r
 419 //        logln("Possible keyword=values pairs:");\r
 420 //        for (int i = 0; i < Collator.getKeywords().length; ++i) {\r
 421 //                String[] values = Collator.getKeywordValues(keywords[i]);\r
 422 //                for (int j = 0; j < values.length; ++j) {\r
 423 //                        System.out.println(keywords[i] + "=" + values[j]);\r
 424 //                }\r
 425 //        }\r
 426 //        logln("Differing Collators:");\r
 427 //        boolean[] isAvailable = {true};\r
 428 //        for (int k = 0; k < locales.length; ++k) {\r
 429 //                logln(locales[k].getDisplayName(ULocale.ENGLISH) + " [" +locales[k] + "]");\r
 430 //                for (int i = 0; i < Collator.getKeywords().length; ++i) {\r
 431 //                        ULocale base = Collator.getFunctionalEquivalent(keywords[i],locales[k]);\r
 432 //                        String[] values = Collator.getKeywordValues(keywords[i]);\r
 433 //                        for (int j = 0; j < Collator.getKeywordValues(keywords[i]).length;++j) {                          \r
 434 //                                ULocale other = Collator.getFunctionalEquivalent(keywords[i], \r
 435 //                                        new ULocale(locales[k] + "@" + keywords[i] + "=" + values[j]),\r
 436 //                                        isAvailable);\r
 437 //                                if (isAvailable[0] && !other.equals(base)) {\r
 438 //                                        logln("\t" + keywords[i] + "=" + values[j] + ";\t" + base + ";\t" + other);\r
 439 //                                }\r
 440 //                        }\r
 441 //                }\r
 442 //        }\r
 443 //    }\r
 444     \r
 445     public void TestGetKeywordValues(){\r
 446         final String[][] PREFERRED = {\r
 447             {"und",             "standard"},\r
 448             {"en_US",           "standard"},\r
 449             {"en_029",          "standard"},\r
 450             {"de_DE",           "standard", "phonebook"},\r
 451             {"de_Latn_DE",      "standard", "phonebook"},\r
 452             {"zh",              "pinyin", "big5han", "gb2312han", "standard", "stroke", "unihan"},\r
 453             {"zh_Hans",         "pinyin", "big5han", "gb2312han", "standard", "stroke", "unihan"},\r
 454             {"zh_CN",           "pinyin", "big5han", "gb2312han", "standard", "stroke", "unihan"},\r
 455             {"zh_Hant",         "stroke", "big5han", "gb2312han", "pinyin", "standard", "unihan"},\r
 456             {"zh_TW",           "stroke", "big5han", "gb2312han", "pinyin", "standard", "unihan"},\r
 457             {"zh__PINYIN",      "pinyin", "big5han", "gb2312han", "standard", "stroke", "unihan"},\r
 458             {"es_ES",           "standard", "traditional"},\r
 459             {"es__TRADITIONAL", "traditional", "standard"},\r
 460             {"und@collation=phonebook",     "standard"},\r
 461             {"de_DE@collation=big5han",     "standard", "phonebook"},\r
 462             {"zzz@collation=xxx",           "standard"},\r
 463         };\r
 464 \r
 465         for (int i = 0; i < PREFERRED.length; i++) {\r
 466             ULocale loc = new ULocale(PREFERRED[i][0]);\r
 467             String[] expected = new String[PREFERRED[i].length - 1];\r
 468             System.arraycopy(PREFERRED[i], 1, expected, 0, expected.length);\r
 469 \r
 470             String[] pref = Collator.getKeywordValuesForLocale("collation", loc, true);\r
 471             boolean matchPref = false;\r
 472             if (pref.length == expected.length) {\r
 473                 matchPref = true;\r
 474                 for (int j = 0; j < pref.length; j++) {\r
 475                     if (!pref[j].equals(expected[j])) {\r
 476                         matchPref = false;\r
 477                     }\r
 478                 }\r
 479             }\r
 480             if (!matchPref) {\r
 481                 errln("FAIL: Preferred values for locale " + loc \r
 482                         + " got:" + Arrays.toString(pref) + " expected:" + Arrays.toString(expected));\r
 483             }\r
 484  \r
 485             String[] all = Collator.getKeywordValuesForLocale("collation", loc, true);\r
 486 \r
 487             // Collator.getKeywordValues return the same contents for both commonlyUsed\r
 488             // true and false.\r
 489             boolean matchAll = false;\r
 490             if (pref.length == all.length) {\r
 491                 matchAll = true;\r
 492                 for (int j = 0; j < pref.length; j++) {\r
 493                     boolean foundMatch = false;\r
 494                     for (int k = 0; k < all.length; k++) {\r
 495                         if (pref[j].equals(all[k])) {\r
 496                             foundMatch = true;\r
 497                             break;\r
 498                         }\r
 499                     }\r
 500                     if (!foundMatch) {\r
 501                         matchAll = false;\r
 502                         break;\r
 503                     }\r
 504                 }\r
 505             }\r
 506             if (!matchAll) {\r
 507                 errln("FAIL: All values for locale " + loc\r
 508                         + " got:" + Arrays.toString(all) + " expected:" + Arrays.toString(pref));\r
 509             }\r
 510         }\r
 511     }\r
 512 }\r