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

   1 /*\r
   2  *******************************************************************************\r
   3  * Copyright (C) 2007-2010, International Business Machines Corporation and    *\r
   4  * others. All Rights Reserved.                                                *\r
   5  *******************************************************************************\r
   6  */\r
   7 package com.ibm.icu.dev.test.format;\r
   8 \r
   9 import java.text.ParseException;\r
  10 import java.util.ArrayList;\r
  11 import java.util.Arrays;\r
  12 import java.util.HashSet;\r
  13 import java.util.List;\r
  14 import java.util.Set;\r
  15 \r
  16 import com.ibm.icu.dev.test.TestFmwk;\r
  17 import com.ibm.icu.impl.Utility;\r
  18 import com.ibm.icu.text.PluralRules;\r
  19 import com.ibm.icu.util.ULocale;\r
  20 \r
  21 /**\r
  22  * @author dougfelt (Doug Felt)\r
  23  */\r
  24 public class PluralRulesTest extends TestFmwk {\r
  25     public static void main(String[] args) throws Exception {\r
  26         new PluralRulesTest().run(args);\r
  27     }\r
  28 \r
  29     private static final String[] parseTestData = {\r
  30         "a: n is 1", "a:1",\r
  31         "a: n mod 10 is 2", "a:2,12,22",\r
  32         "a: n is not 1", "a:0,2,3,4,5",\r
  33         "a: n mod 3 is not 1", "a:0,2,3,5,6,8,9",\r
  34         "a: n in 2..5", "a:2,3,4,5",\r
  35         "a: n within 2..5", "a:2,3,4,5",\r
  36         "a: n not in 2..5", "a:0,1,6,7,8",\r
  37         "a: n not within 2..5", "a:0,1,6,7,8",\r
  38         "a: n mod 10 in 2..5", "a:2,3,4,5,12,13,14,15,22,23,24,25",\r
  39         "a: n mod 10 within 2..5", "a:2,3,4,5,12,13,14,15,22,23,24,25",\r
  40         "a: n mod 10 is 2 and n is not 12", "a:2,22,32,42",\r
  41         "a: n mod 10 in 2..3 or n mod 10 is 5", "a:2,3,5,12,13,15,22,23,25",\r
  42         "a: n mod 10 within 2..3 or n mod 10 is 5", "a:2,3,5,12,13,15,22,23,25",\r
  43         "a: n is 1 or n is 4 or n is 23", "a:1,4,23",\r
  44         "a: n mod 2 is 1 and n is not 3 and n in 1..11", "a:1,5,7,9,11",\r
  45         "a: n mod 2 is 1 and n is not 3 and n within 1..11", "a:1,5,7,9,11",\r
  46         "a: n mod 2 is 1 or n mod 5 is 1 and n is not 6", "a:1,3,5,7,9,11,13,15,16",\r
  47         "a: n in 2..5; b: n in 5..8; c: n mod 2 is 1", "a:2,3,4,5;b:6,7,8;c:1,9,11",\r
  48         "a: n within 2..5; b: n within 5..8; c: n mod 2 is 1", "a:2,3,4,5;b:6,7,8;c:1,9,11",\r
  49     };\r
  50 \r
  51     private String[] getTargetStrings(String targets) {\r
  52         List list = new ArrayList(50);\r
  53         String[] valSets = Utility.split(targets, ';');\r
  54         for (int i = 0; i < valSets.length; ++i) {\r
  55             String[] temp = Utility.split(valSets[i], ':');\r
  56             String key = temp[0].trim();\r
  57             String[] vals = Utility.split(temp[1], ',');\r
  58             for (int j = 0; j < vals.length; ++j) {\r
  59                 String valString = vals[j].trim();\r
  60                 int val = Integer.parseInt(valString);\r
  61                 while (list.size() <= val) {\r
  62                     list.add(null);\r
  63                 }\r
  64                 if (list.get(val) != null) {\r
  65                     fail("key: " + list.get(val) + " already set for: " + val);\r
  66                 }\r
  67                 list.set(val, key);\r
  68             }\r
  69         }\r
  70 \r
  71         String[] result = (String[]) list.toArray(new String[list.size()]);\r
  72         for (int i = 0; i < result.length; ++i) {\r
  73             if (result[i] == null) {\r
  74                 result[i] = "other";\r
  75             }\r
  76         }\r
  77         return result;\r
  78     }\r
  79 \r
  80     private void checkTargets(PluralRules rules, String[] targets) {\r
  81         for (int i = 0; i < targets.length; ++i) {\r
  82             assertEquals("value " + i, targets[i], rules.select(i));\r
  83         }\r
  84     }\r
  85 \r
  86     public void testParseEmpty() throws ParseException {\r
  87         PluralRules rules = PluralRules.parseDescription("a:n");\r
  88         assertEquals("empty", "a", rules.select(0));\r
  89     }\r
  90 \r
  91     public void testParsing() {\r
  92         for (int i = 0; i < parseTestData.length; i += 2) {\r
  93             String pattern = parseTestData[i];\r
  94             String expected = parseTestData[i + 1];\r
  95 \r
  96             logln("pattern[" + i + "] " + pattern);\r
  97             try {\r
  98                 PluralRules rules = PluralRules.createRules(pattern);\r
  99                 String[] targets = getTargetStrings(expected);\r
 100                 checkTargets(rules, targets);\r
 101             } catch (Exception e) {\r
 102                 e.printStackTrace();\r
 103                 throw new RuntimeException(e.getMessage());\r
 104             }\r
 105         }\r
 106     }\r
 107 \r
 108     private static String[][] equalityTestData = {\r
 109         { "a: n in 2..3", \r
 110             "a: n is 2 or n is 3", \r
 111             "a:n is 3 and n in 2..5 or n is 2" },\r
 112         { "a: n is 12; b:n mod 10 in 2..3",\r
 113           "b: n mod 10 in 2..3 and n is not 12; a: n in 12..12",\r
 114           "b: n is 13; a: n in 12..13; b: n mod 10 is 2 or n mod 10 is 3" },\r
 115     };\r
 116 \r
 117     private void compareEquality(Object[] objects) {\r
 118         for (int i = 0; i < objects.length; ++i) {\r
 119             Object lhs = objects[i];\r
 120             for (int j = i; j < objects.length; ++j) {\r
 121                 Object rhs = objects[j];\r
 122                 assertEquals("obj " + i + " and " + j, lhs, rhs);\r
 123             }\r
 124         }\r
 125     }\r
 126 \r
 127     public void testEquality() {\r
 128         for (int i = 0; i < equalityTestData.length; ++i) {\r
 129             String[] patterns = equalityTestData[i];\r
 130             PluralRules[] rules = new PluralRules[patterns.length];\r
 131             for (int j = 0; j < patterns.length; ++j) {\r
 132                 rules[j] = PluralRules.createRules(patterns[j]);\r
 133             }\r
 134             compareEquality(rules);\r
 135         }\r
 136     }\r
 137 \r
 138     public void testBuiltInRules() {\r
 139         // spot check\r
 140         PluralRules rules = PluralRules.forLocale(ULocale.US);\r
 141         assertEquals("us 0", PluralRules.KEYWORD_OTHER, rules.select(0));\r
 142         assertEquals("us 1", PluralRules.KEYWORD_ONE, rules.select(1));\r
 143         assertEquals("us 2", PluralRules.KEYWORD_OTHER, rules.select(2));\r
 144 \r
 145         rules = PluralRules.forLocale(ULocale.JAPAN);\r
 146         assertEquals("ja 0", PluralRules.KEYWORD_OTHER, rules.select(0));\r
 147         assertEquals("ja 1", PluralRules.KEYWORD_OTHER, rules.select(1));\r
 148         assertEquals("ja 2", PluralRules.KEYWORD_OTHER, rules.select(2));\r
 149 \r
 150         rules = PluralRules.forLocale(ULocale.createCanonical("ru"));\r
 151         assertEquals("ru 0", PluralRules.KEYWORD_MANY, rules.select(0));\r
 152         assertEquals("ru 1", PluralRules.KEYWORD_ONE, rules.select(1));\r
 153         assertEquals("ru 2", PluralRules.KEYWORD_FEW, rules.select(2));\r
 154     }\r
 155 \r
 156     public void testFunctionalEquivalent() {\r
 157         // spot check\r
 158         ULocale unknown = ULocale.createCanonical("zz_ZZ");\r
 159         ULocale un_equiv = PluralRules.getFunctionalEquivalent(unknown, null);\r
 160         assertEquals("unknown locales have root", ULocale.ROOT, un_equiv);\r
 161 \r
 162         ULocale jp_equiv = PluralRules.getFunctionalEquivalent(ULocale.JAPAN, null);\r
 163         ULocale cn_equiv = PluralRules.getFunctionalEquivalent(ULocale.CHINA, null);\r
 164         assertEquals("japan and china equivalent locales", jp_equiv, cn_equiv);\r
 165 \r
 166         boolean[] available = new boolean[1];\r
 167         ULocale russia = ULocale.createCanonical("ru_RU");\r
 168         ULocale ru_ru_equiv = PluralRules.getFunctionalEquivalent(russia, available);\r
 169         assertFalse("ru_RU not listed", available[0]);\r
 170 \r
 171         ULocale russian = ULocale.createCanonical("ru");\r
 172         ULocale ru_equiv = PluralRules.getFunctionalEquivalent(russian, available);\r
 173         assertTrue("ru listed", available[0]);\r
 174         assertEquals("ru and ru_RU equivalent locales", ru_ru_equiv, ru_equiv);\r
 175     }\r
 176 \r
 177     public void testAvailableULocales() {\r
 178         ULocale[] locales = PluralRules.getAvailableULocales();\r
 179         Set localeSet = new HashSet();\r
 180         localeSet.addAll(Arrays.asList(locales));\r
 181 \r
 182         assertEquals("locales are unique in list", locales.length, localeSet.size());\r
 183     }\r
 184     \r
 185     /*\r
 186      * Test the method public static PluralRules parseDescription(String description)\r
 187      */\r
 188     public void TestParseDescription() {\r
 189         try {\r
 190             if (PluralRules.DEFAULT != PluralRules.parseDescription("")) {\r
 191                 errln("PluralRules.parseDescription(String) was suppose "\r
 192                         + "to return PluralRules.DEFAULT when String is of " + "length 0.");\r
 193             }\r
 194         } catch (ParseException e) {\r
 195             errln("PluralRules.parseDescription(String) was not suppose " + "to return an exception.");\r
 196         }\r
 197     }\r
 198 \r
 199     /*\r
 200      * Tests the method public static PluralRules createRules(String description)\r
 201      */\r
 202     public void TestCreateRules() {\r
 203         try {\r
 204             if (PluralRules.createRules(null) != null) {\r
 205                 errln("PluralRules.createRules(String) was suppose to "\r
 206                         + "return null for an invalid String descrtiption.");\r
 207             }\r
 208         } catch (Exception e) {\r
 209         }\r
 210     }\r
 211 \r
 212     /*\r
 213      * Tests the method public int hashCode()\r
 214      */\r
 215     public void TestHashCode() {\r
 216         PluralRules pr = PluralRules.DEFAULT;\r
 217         if (106069776 != pr.hashCode()) {\r
 218             errln("PluralRules.hashCode() was suppose to return 106069776 " + "when PluralRules.DEFAULT.");\r
 219         }\r
 220     }\r
 221 \r
 222     /*\r
 223      * Tests the method public boolean equals(PluralRules rhs)\r
 224      */\r
 225     public void TestEquals() {\r
 226         PluralRules pr = PluralRules.DEFAULT;\r
 227 \r
 228         // Tests when if (rhs == null) is true\r
 229         if (pr.equals((PluralRules) null)) {\r
 230             errln("PluralRules.equals(PluralRules) was suppose to return false " + "when passing null.");\r
 231         }\r
 232     }\r
 233 }\r