[Unicode]   Common Locale Data Repository : Bug Tracking Home | Site Map | Search
 

Changeset 13087


Ignore:
Timestamp:
12/01/16 07:44:06 (2 years ago)
Author:
mdavis
Message:

cldrbug 9924: went for minimal changes, since the ramifications were too large for the dot-dot release.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/common/supplemental/supplementalData.xml

    r13073 r13087  
    26812681                </territory> 
    26822682                <territory type="CN" gdp="18090000000000" literacyPercent="95.1" population="1367490000">       <!--China--> 
    2683                         <languagePopulation type="yue" writingPercent="4.3" populationPercent="90" references="R1317"/> <!--Cantonese--> 
     2683                        <languagePopulation type="yue" populationPercent="5.2" references="R1317"/>     <!--Cantonese--> 
    26842684                        <languagePopulation type="zh_Hans" populationPercent="90" officialStatus="official"/>   <!--Chinese (Simplified)--> 
    26852685                        <languagePopulation type="wuu" populationPercent="6"/>  <!--Wu Chinese--> 
  • trunk/tools/cldr-unittest/src/org/unicode/cldr/unittest/TestSupplementalInfo.java

    r12739 r13087  
    3535import org.unicode.cldr.util.Iso639Data.Scope; 
    3636import org.unicode.cldr.util.IsoCurrencyParser; 
     37import org.unicode.cldr.util.LanguageTagCanonicalizer; 
    3738import org.unicode.cldr.util.LanguageTagParser; 
    3839import org.unicode.cldr.util.Level; 
     
    8788 
    8889    private static final StandardCodes STANDARD_CODES = testInfo 
    89         .getStandardCodes(); 
     90            .getStandardCodes(); 
    9091 
    9192    private static final SupplementalDataInfo SUPPLEMENTAL = testInfo 
    92         .getSupplementalDataInfo(); 
     93            .getSupplementalDataInfo(); 
    9394 
    9495    public static void main(String[] args) { 
     
    110111                for (Count c : pi.getCounts(s)) { 
    111112                    FixedDecimalSamples sSamples = pi.getPluralRules() 
    112                         .getDecimalSamples(c.toString(), s); 
     113                            .getDecimalSamples(c.toString(), s); 
    113114                    if (sSamples == null) { 
    114115                        errln(locale + " no sample for " + c); 
     
    123124                            if (lastSample.start.compareTo(sample.start) > 0) { 
    124125                                errln(locale + ":" + c + ": out of order with " 
    125                                     + lastSample + " > " + sample); 
     126                                        + lastSample + " > " + sample); 
    126127                            } else if (false) { 
    127128                                logln(locale + ":" + c + ": in order with " 
    128                                     + lastSample + " < " + sample); 
     129                                        + lastSample + " < " + sample); 
    129130                            } 
    130131                        } 
     
    139140        PluralRulesFactory prf = PluralRulesFactory.getInstance(SUPPLEMENTAL); 
    140141        Set<String> localesToTest = new TreeSet<String>( 
    141             SUPPLEMENTAL.getPluralRangesLocales()); 
     142                SUPPLEMENTAL.getPluralRangesLocales()); 
    142143        for (String locale : StandardCodes.make().getLocaleCoverageLocales( 
    143             "google")) { // superset 
     144                "google")) { // superset 
    144145            if (locale.equals("*") || locale.contains("_")) { 
    145146                continue; 
     
    148149        } 
    149150        Set<String> modernLocales = testInfo.getStandardCodes() 
    150             .getLocaleCoverageLocales(Organization.cldr, 
    151                 EnumSet.of(Level.MODERN)); 
     151                .getLocaleCoverageLocales(Organization.cldr, 
     152                        EnumSet.of(Level.MODERN)); 
    152153 
    153154        Output<FixedDecimal> maxSample = new Output<FixedDecimal>(); 
     
    183184            for (Count count : Count.values()) { 
    184185                if (pluralRanges.isExplicitlySet(count) 
    185                     && !counts.contains(count)) { 
     186                        && !counts.contains(count)) { 
    186187                    assertTrue( 
    187                         locale 
    188                         + "\t pluralRanges categories must be valid for locale:\t" 
    189                         + count + " must be in " + counts, 
    190                         !pluralRanges.isExplicitlySet(count)); 
     188                            locale 
     189                            + "\t pluralRanges categories must be valid for locale:\t" 
     190                            + count + " must be in " + counts, 
     191                            !pluralRanges.isExplicitlySet(count)); 
    191192                } 
    192193                for (Count end : Count.values()) { 
     
    207208                    for (Count result : found) { 
    208209                        String samplePattern = samplePatterns.get( 
    209                             PluralRules.PluralType.CARDINAL, result); 
     210                                PluralRules.PluralType.CARDINAL, result); 
    210211                        if (samplePattern != null && !samplePattern.contains("{0}")) { 
    211212                            errln("Plural Ranges cannot have results that don't use {0} in samples: " 
    212                                 + locale 
    213                                 + ", " 
    214                                 + result 
    215                                 + "\t«" 
    216                                 + samplePattern + "»"); 
     213                                    + locale 
     214                                    + ", " 
     215                                    + result 
     216                                    + "\t«" 
     217                                    + samplePattern + "»"); 
    217218                        } 
    218219                    } 
     
    229230                for (Count end : counts) { 
    230231                    boolean needsValue = pluralInfo.rangeExists(start, end, 
    231                         minSample, maxSample); 
     232                            minSample, maxSample); 
    232233                    Count explicitValue = pluralRanges.getExplicit(start, end); 
    233234                    final String rangeLine = getRangeLine(start, end, explicitValue, maxSample, minSample, samplePatterns); 
     
    235236                    if (needsValue && explicitValue == null) { 
    236237                        errOrLog(CoverageIssue.error, locale + "\tNo explicit value for range: " 
    237                             + rangeLine,  
    238                             "Cldrbug:7839", "Missing plural data for modern locales"); 
     238                                + rangeLine,  
     239                                "Cldrbug:7839", "Missing plural data for modern locales"); 
    239240                        failure = true; 
    240241                        failureCases.append("\tError — need explicit result"); 
    241242                    } else if (!needsValue && explicitValue != null) { 
    242243                        errOrLog(CoverageIssue.error, locale + "\tDoesn't need explicit value, but has one: " 
    243                             + PluralRanges.showRange(start, end, explicitValue),  
    244                             "Cldrbug:7839", "Missing plural data for modern locales"); 
     244                                + PluralRanges.showRange(start, end, explicitValue),  
     245                                "Cldrbug:7839", "Missing plural data for modern locales"); 
    245246                        failureCases.append("\tUnnecessary"); 
    246247                        failure = true; 
     
    257258 
    258259    private String getRangeLine(Count start, Count end, Count result,  
    259         Output<FixedDecimal> maxSample, Output<FixedDecimal> minSample,  
    260         SamplePatterns samplePatterns) { 
     260            Output<FixedDecimal> maxSample, Output<FixedDecimal> minSample,  
     261            SamplePatterns samplePatterns) { 
    261262        final String range = minSample + "–" + maxSample; 
    262263        String example = range; 
     
    293294    public void TestPluralSamples() { 
    294295        String[][] test = { { "en", "ordinal", "1", "one" }, 
    295             { "en", "ordinal", "2", "two" }, 
    296             { "en", "ordinal", "3", "few" }, 
    297             { "en", "ordinal", "4", "other" }, 
    298             { "sl", "cardinal", "2", "two" }, }; 
     296                { "en", "ordinal", "2", "two" }, 
     297                { "en", "ordinal", "3", "few" }, 
     298                { "en", "ordinal", "4", "other" }, 
     299                { "sl", "cardinal", "2", "two" }, }; 
    299300        for (String[] row : test) { 
    300301            checkPluralSamples(row); 
     
    311312            for (PluralRules.PluralType type : PluralRules.PluralType.values()) { 
    312313                PluralInfo rules = SUPPLEMENTAL.getPlurals( 
    313                     SupplementalDataInfo.PluralType.fromStandardType(type), 
    314                     locale.toString()); 
     314                        SupplementalDataInfo.PluralType.fromStandardType(type), 
     315                        locale.toString()); 
    315316                if (rules.getCounts().size() == 1) { 
    316317                    continue; // don't require rules for unary cases 
     
    320321                    if (sample == null) { 
    321322                        errOrLog(CoverageIssue.error, locale + "\t" + type + " \tmissing samples for " + count, "cldrbug:7075", 
    322                             "Missing ordinal minimal pairs"); 
     323                                "Missing ordinal minimal pairs"); 
    323324                    } else { 
    324325                        PluralRules pRules = rules.getPluralRules(); 
    325326                        double unique = pRules.getUniqueKeywordValue(count 
    326                             .toString()); 
     327                                .toString()); 
    327328                        if (unique == PluralRules.NO_UNIQUE_VALUE 
    328                             && !sample.contains("{0}")) { 
     329                                && !sample.contains("{0}")) { 
    329330                            errln("Missing {0} in sample: " + locale + ", " 
    330                                 + type + ", " + count + " «" + sample + "»"); 
     331                                    + type + ", " + count + " «" + sample + "»"); 
    331332                        } 
    332333                    } 
     
    338339    public void TestCldrScriptCodes() { 
    339340        Set<String> codes = SUPPLEMENTAL.getCLDRScriptCodes(); 
    340          
     341 
    341342        Set<String> unicodeScripts = ScriptMetadata.getScripts(); 
    342343        assertRelation("getCLDRScriptCodes contains Unicode Scripts", true, codes, CONTAINS_ALL, unicodeScripts); 
     
    360361            } 
    361362        } 
    362          
     363 
    363364        ImmutableSet<String> variants = ImmutableSet.of("Aran", "Cyrs", "Geok", "Latf", "Latg", "Syre", "Syrj", "Syrn"); 
    364365        assertRelation("getCLDRScriptCodes contains variants", false, codes, CONTAINS_SOME, variants); 
     
    367368    public void checkPluralSamples(String... row) { 
    368369        PluralInfo pluralInfo = SUPPLEMENTAL.getPlurals( 
    369             PluralType.valueOf(row[1]), row[0]); 
     370                PluralType.valueOf(row[1]), row[0]); 
    370371        Count count = pluralInfo.getCount(new FixedDecimal(row[2])); 
    371372        assertEquals(CollectionUtilities.join(row, ", "), 
    372             Count.valueOf(row[3]), count); 
     373                Count.valueOf(row[3]), count); 
    373374    } 
    374375 
     
    377378        for (PluralType type : PluralType.values()) { 
    378379            Relation<PluralInfo, String> pluralsToLocale = Relation.of( 
    379                 new HashMap<PluralInfo, Set<String>>(), TreeSet.class); 
     380                    new HashMap<PluralInfo, Set<String>>(), TreeSet.class); 
    380381            for (String locale : new TreeSet<String>( 
    381                 SUPPLEMENTAL.getPluralLocales(type))) { 
     382                    SUPPLEMENTAL.getPluralLocales(type))) { 
    382383                PluralInfo pluralInfo = SUPPLEMENTAL.getPlurals(type, locale); 
    383384                pluralsToLocale.put(pluralInfo, locale); 
     
    385386 
    386387            String[][] equivalents = { { "mo", "ro" }, { "tl", "fil" }, 
    387                 { "he", "iw" }, { "in", "id" }, { "jw", "jv" }, 
    388                 { "ji", "yi" }, { "sh", "sr" }, }; 
     388                    { "he", "iw" }, { "in", "id" }, { "jw", "jv" }, 
     389                    { "ji", "yi" }, { "sh", "sr" }, }; 
    389390            for (Entry<PluralInfo, Set<String>> pluralInfoEntry : pluralsToLocale 
    390                 .keyValuesSet()) { 
     391                    .keyValuesSet()) { 
    391392                PluralInfo pluralInfo2 = pluralInfoEntry.getKey(); 
    392393                Set<String> locales = pluralInfoEntry.getValue(); 
     
    394395                for (String[] row : equivalents) { 
    395396                    assertEquals( 
    396                         type + " must be equivalent: " + Arrays.asList(row), 
    397                         locales.contains(row[0]), locales.contains(row[1])); 
     397                            type + " must be equivalent: " + Arrays.asList(row), 
     398                            locales.contains(row[0]), locales.contains(row[1])); 
    398399                } 
    399400                // check that no rules contain 'within' 
     
    404405                    } 
    405406                    assertFalse( 
    406                         "Rule '" + rule + "' for " + Arrays.asList(locales) 
    407                         + " doesn't contain 'within'", 
    408                         rule.contains("within")); 
     407                            "Rule '" + rule + "' for " + Arrays.asList(locales) 
     408                            + " doesn't contain 'within'", 
     409                            rule.contains("within")); 
    409410                } 
    410411            } 
     
    414415    public void TestDigitPluralCases() { 
    415416        String[][] tests = { 
    416             { "en", "one", "1", "1" }, 
    417             { "en", "one", "2", "" }, 
    418             { "en", "one", "3", "" }, 
    419             { "en", "one", "4", "" }, 
    420             { "en", "other", "1", "0, 2-9, 0.0, 0.1, 0.2, …" }, 
    421             { "en", "other", "2", "10-99, 10.0, 10.1, 10.2, …" }, 
    422             { "en", "other", "3", "100-999, 100.0, 100.1, 100.2, …" }, 
    423             { "en", "other", "4", "1000-9999, 1000.0, 1000.1, 1000.2, …" }, 
    424             { "hr", "one", "1", "1, 0.1, 2.10, 1.1, …" }, 
    425             { "hr", "one", "2", 
    426             "21, 31, 41, 51, 61, 71, …, 10.1, 12.10, 11.1, …" }, 
    427             { "hr", "one", "3", 
    428             "101, 121, 131, 141, 151, 161, …, 100.1, 102.10, 101.1, …" }, 
    429             { "hr", "one", "4", 
    430             "1001, 1021, 1031, 1041, 1051, 1061, …, 1000.1, 1002.10, 1001.1, …" }, 
    431             { "hr", "few", "1", "2-4, 0.2, 0.3, 0.4, …" }, 
    432             { "hr", "few", "2", 
    433             "22-24, 32-34, 42-44, …, 10.2, 10.3, 10.4, …" }, 
    434             { "hr", "few", "3", 
    435             "102-104, 122-124, 132-134, …, 100.2, 100.3, 100.4, …" }, 
    436             { "hr", "few", "4", 
    437             "1002-1004, 1022-1024, 1032-1034, …, 1000.2, 1000.3, 1000.4, …" }, 
    438             { "hr", "other", "1", "0, 5-9, 0.0, 0.5, 0.6, …" }, 
    439             { "hr", "other", "2", 
    440             "10-20, 25-30, 35-40, …, 10.0, 10.5, 10.6, …" }, 
    441             { "hr", "other", "3", 
    442             "100, 105-120, 125-130, 135-140, …, 100.0, 100.5, 100.6, …" }, 
    443             { "hr", "other", "4", 
    444             "1000, 1005-1020, 1025-1030, 1035-1040, …, 1000.0, 1000.5, 1000.6, …" }, }; 
     417                { "en", "one", "1", "1" }, 
     418                { "en", "one", "2", "" }, 
     419                { "en", "one", "3", "" }, 
     420                { "en", "one", "4", "" }, 
     421                { "en", "other", "1", "0, 2-9, 0.0, 0.1, 0.2, …" }, 
     422                { "en", "other", "2", "10-99, 10.0, 10.1, 10.2, …" }, 
     423                { "en", "other", "3", "100-999, 100.0, 100.1, 100.2, …" }, 
     424                { "en", "other", "4", "1000-9999, 1000.0, 1000.1, 1000.2, …" }, 
     425                { "hr", "one", "1", "1, 0.1, 2.10, 1.1, …" }, 
     426                { "hr", "one", "2", 
     427                "21, 31, 41, 51, 61, 71, …, 10.1, 12.10, 11.1, …" }, 
     428                { "hr", "one", "3", 
     429                "101, 121, 131, 141, 151, 161, …, 100.1, 102.10, 101.1, …" }, 
     430                { "hr", "one", "4", 
     431                "1001, 1021, 1031, 1041, 1051, 1061, …, 1000.1, 1002.10, 1001.1, …" }, 
     432                { "hr", "few", "1", "2-4, 0.2, 0.3, 0.4, …" }, 
     433                { "hr", "few", "2", 
     434                "22-24, 32-34, 42-44, …, 10.2, 10.3, 10.4, …" }, 
     435                { "hr", "few", "3", 
     436                "102-104, 122-124, 132-134, …, 100.2, 100.3, 100.4, …" }, 
     437                { "hr", "few", "4", 
     438                "1002-1004, 1022-1024, 1032-1034, …, 1000.2, 1000.3, 1000.4, …" }, 
     439                { "hr", "other", "1", "0, 5-9, 0.0, 0.5, 0.6, …" }, 
     440                { "hr", "other", "2", 
     441                "10-20, 25-30, 35-40, …, 10.0, 10.5, 10.6, …" }, 
     442                { "hr", "other", "3", 
     443                "100, 105-120, 125-130, 135-140, …, 100.0, 100.5, 100.6, …" }, 
     444                { "hr", "other", "4", 
     445                "1000, 1005-1020, 1025-1030, 1035-1040, …, 1000.0, 1000.5, 1000.6, …" }, }; 
    445446        for (String[] row : tests) { 
    446447            PluralInfo plurals = SUPPLEMENTAL.getPlurals(row[0]); 
    447448            SampleList uset = plurals.getSamples9999(Count.valueOf(row[1]), 
    448                 Integer.parseInt(row[2])); 
     449                    Integer.parseInt(row[2])); 
    449450            assertEquals(row[0] + ", " + row[1] + ", " + row[2], row[3], 
    450                 uset.toString()); 
     451                    uset.toString()); 
    451452        } 
    452453    } 
     
    454455    public void TestDigitPluralCompleteness() { 
    455456        String[][] exceptionStrings = { 
    456             // defaults 
    457             { "*", "zero", "0,00,000,0000" }, { "*", "one", "0" }, 
    458             { "*", "two", "0,00,000,0000" }, 
    459             { "*", "few", "0,00,000,0000" }, 
    460             { "*", "many", "0,00,000,0000" }, 
    461             { "*", "other", "0,00,000,0000" }, 
    462             // others 
    463             { "mo", "other", "00,000,0000" }, // 
    464             { "ro", "other", "00,000,0000" }, // 
    465             { "cs", "few", "0" }, // j in 2..4 
    466             { "sk", "few", "0" }, // j in 2..4 
    467             { "da", "one", "0" }, // j is 1 or t is not 0 and n within 0..2 
    468             { "is", "one", "0,00,000,0000" }, // j is 1 or f is 1 
    469             { "sv", "one", "0" }, // j is 1 
    470             { "he", "two", "0" }, // j is 2 
    471             { "ru", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
    472             // is not 11 
    473             { "uk", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
    474             // is not 11 
    475             { "bs", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
    476             // is not 11 or f mod 10 is 
    477             // 1 and f mod 100 is not 11 
    478             { "hr", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
    479             // is not 11 or f mod 10 is 
    480             // 1 and f mod 100 is not 11 
    481             { "sh", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
    482             // is not 11 or f mod 10 is 
    483             // 1 and f mod 100 is not 11 
    484             { "sr", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
    485             // is not 11 or f mod 10 is 
    486             // 1 and f mod 100 is not 11 
    487             { "mk", "one", "0,00,000,0000" }, // j mod 10 is 1 or f mod 10 
    488             // is 1 
    489             { "sl", "one", "0,000,0000" }, // j mod 100 is 1 
    490             { "sl", "two", "0,000,0000" }, // j mod 100 is 2 
    491             { "he", "many", "00,000,0000" }, // j not in 0..10 and j mod 10 
    492             // is 0 
    493             { "tzm", "one", "0,00" }, // n in 0..1 or n in 11..99 
    494             { "gd", "one", "0,00" }, // n in 1,11 
    495             { "gd", "two", "0,00" }, // n in 2,12 
    496             { "shi", "few", "0,00" }, // n in 2..10 
    497             { "gd", "few", "0,00" }, // n in 3..10,13..19 
    498             { "ga", "few", "0" }, // n in 3..6 
    499             { "ga", "many", "0,00" }, // n in 7..10 
    500             { "ar", "zero", "0" }, // n is 0 
    501             { "cy", "zero", "0" }, // n is 0 
    502             { "ksh", "zero", "0" }, // n is 0 
    503             { "lag", "zero", "0" }, // n is 0 
    504             { "pt", "one", "0" }, // i = 1 and v = 0 or i = 0 and t = 1 
    505             { "pt_PT", "one", "0" }, // n = 1 and v = 0 
    506             { "ar", "two", "0" }, // n is 2 
    507             { "cy", "two", "0" }, // n is 2 
    508             { "ga", "two", "0" }, // n is 2 
    509             { "iu", "two", "0" }, // n is 2 
    510             { "kw", "two", "0" }, // n is 2 
    511             { "naq", "two", "0" }, // n is 2 
    512             { "se", "two", "0" }, // n is 2 
    513             { "sma", "two", "0" }, // n is 2 
    514             { "smi", "two", "0" }, // n is 2 
    515             { "smj", "two", "0" }, // n is 2 
    516             { "smn", "two", "0" }, // n is 2 
    517             { "sms", "two", "0" }, // n is 2 
    518             { "cy", "few", "0" }, // n is 3 
    519             { "cy", "many", "0" }, // n is 6 
    520             { "br", "many", "" }, // n is not 0 and n mod 1000000 is 0 
    521             { "gv", "one", "0,00,000,0000" }, // n mod 10 is 1 
    522             { "be", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
    523             // is not 11 
    524             { "lv", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
    525             // is not 11 or v is 2 and f 
    526             // mod 10 is 1 and f mod 100 
    527             // is not 11 or v is not 2 
    528             // and f mod 10 is 1 
    529             { "br", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
    530             // not in 11,71,91 
    531             { "lt", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
    532             // not in 11..19 
    533             { "fil", "one", "0,00,000,0000" }, // v = 0 and i = 1,2,3 or v = 
    534             // 0 and i % 10 != 4,6,9 or 
    535             // v != 0 and f % 10 != 
    536             // 4,6,9 
    537             { "tl", "one", "0,00,000,0000" }, // v = 0 and i = 1,2,3 or v = 
    538             // 0 and i % 10 != 4,6,9 or 
    539             // v != 0 and f % 10 != 
    540             // 4,6,9 
    541             { "dsb", "one", "0,00,000,0000" }, // v = 0 and i % 100 = 1 or f 
    542             // % 100 = 1 
     457                // defaults 
     458                { "*", "zero", "0,00,000,0000" }, { "*", "one", "0" }, 
     459                { "*", "two", "0,00,000,0000" }, 
     460                { "*", "few", "0,00,000,0000" }, 
     461                { "*", "many", "0,00,000,0000" }, 
     462                { "*", "other", "0,00,000,0000" }, 
     463                // others 
     464                { "mo", "other", "00,000,0000" }, // 
     465                { "ro", "other", "00,000,0000" }, // 
     466                { "cs", "few", "0" }, // j in 2..4 
     467                { "sk", "few", "0" }, // j in 2..4 
     468                { "da", "one", "0" }, // j is 1 or t is not 0 and n within 0..2 
     469                { "is", "one", "0,00,000,0000" }, // j is 1 or f is 1 
     470                { "sv", "one", "0" }, // j is 1 
     471                { "he", "two", "0" }, // j is 2 
     472                { "ru", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
     473                // is not 11 
     474                { "uk", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
     475                // is not 11 
     476                { "bs", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
     477                // is not 11 or f mod 10 is 
     478                // 1 and f mod 100 is not 11 
     479                { "hr", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
     480                // is not 11 or f mod 10 is 
     481                // 1 and f mod 100 is not 11 
     482                { "sh", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
     483                // is not 11 or f mod 10 is 
     484                // 1 and f mod 100 is not 11 
     485                { "sr", "one", "0,00,000,0000" }, // j mod 10 is 1 and j mod 100 
     486                // is not 11 or f mod 10 is 
     487                // 1 and f mod 100 is not 11 
     488                { "mk", "one", "0,00,000,0000" }, // j mod 10 is 1 or f mod 10 
     489                // is 1 
     490                { "sl", "one", "0,000,0000" }, // j mod 100 is 1 
     491                { "sl", "two", "0,000,0000" }, // j mod 100 is 2 
     492                { "he", "many", "00,000,0000" }, // j not in 0..10 and j mod 10 
     493                // is 0 
     494                { "tzm", "one", "0,00" }, // n in 0..1 or n in 11..99 
     495                { "gd", "one", "0,00" }, // n in 1,11 
     496                { "gd", "two", "0,00" }, // n in 2,12 
     497                { "shi", "few", "0,00" }, // n in 2..10 
     498                { "gd", "few", "0,00" }, // n in 3..10,13..19 
     499                { "ga", "few", "0" }, // n in 3..6 
     500                { "ga", "many", "0,00" }, // n in 7..10 
     501                { "ar", "zero", "0" }, // n is 0 
     502                { "cy", "zero", "0" }, // n is 0 
     503                { "ksh", "zero", "0" }, // n is 0 
     504                { "lag", "zero", "0" }, // n is 0 
     505                { "pt", "one", "0" }, // i = 1 and v = 0 or i = 0 and t = 1 
     506                { "pt_PT", "one", "0" }, // n = 1 and v = 0 
     507                { "ar", "two", "0" }, // n is 2 
     508                { "cy", "two", "0" }, // n is 2 
     509                { "ga", "two", "0" }, // n is 2 
     510                { "iu", "two", "0" }, // n is 2 
     511                { "kw", "two", "0" }, // n is 2 
     512                { "naq", "two", "0" }, // n is 2 
     513                { "se", "two", "0" }, // n is 2 
     514                { "sma", "two", "0" }, // n is 2 
     515                { "smi", "two", "0" }, // n is 2 
     516                { "smj", "two", "0" }, // n is 2 
     517                { "smn", "two", "0" }, // n is 2 
     518                { "sms", "two", "0" }, // n is 2 
     519                { "cy", "few", "0" }, // n is 3 
     520                { "cy", "many", "0" }, // n is 6 
     521                { "br", "many", "" }, // n is not 0 and n mod 1000000 is 0 
     522                { "gv", "one", "0,00,000,0000" }, // n mod 10 is 1 
     523                { "be", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
     524                // is not 11 
     525                { "lv", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
     526                // is not 11 or v is 2 and f 
     527                // mod 10 is 1 and f mod 100 
     528                // is not 11 or v is not 2 
     529                // and f mod 10 is 1 
     530                { "br", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
     531                // not in 11,71,91 
     532                { "lt", "one", "0,00,000,0000" }, // n mod 10 is 1 and n mod 100 
     533                // not in 11..19 
     534                { "fil", "one", "0,00,000,0000" }, // v = 0 and i = 1,2,3 or v = 
     535                // 0 and i % 10 != 4,6,9 or 
     536                // v != 0 and f % 10 != 
     537                // 4,6,9 
     538                { "tl", "one", "0,00,000,0000" }, // v = 0 and i = 1,2,3 or v = 
     539                // 0 and i % 10 != 4,6,9 or 
     540                // v != 0 and f % 10 != 
     541                // 4,6,9 
     542                { "dsb", "one", "0,00,000,0000" }, // v = 0 and i % 100 = 1 or f 
     543                // % 100 = 1 
    543544        }; 
    544545        // parse out the exceptions 
    545546        Map<PluralInfo, Relation<Count, Integer>> exceptions = new HashMap<PluralInfo, Relation<Count, Integer>>(); 
    546547        Relation<Count, Integer> fallback = Relation.of( 
    547             new EnumMap<Count, Set<Integer>>(Count.class), TreeSet.class); 
     548                new EnumMap<Count, Set<Integer>>(Count.class), TreeSet.class); 
    548549        for (String[] row : exceptionStrings) { 
    549550            Relation<Count, Integer> countToDigits; 
     
    555556                if (countToDigits == null) { 
    556557                    exceptions.put( 
    557                         plurals, 
    558                         countToDigits = Relation.of( 
    559                             new EnumMap<Count, Set<Integer>>( 
    560                                 Count.class), TreeSet.class)); 
     558                            plurals, 
     559                            countToDigits = Relation.of( 
     560                                    new EnumMap<Count, Set<Integer>>( 
     561                                            Count.class), TreeSet.class)); 
    561562                } 
    562563            } 
     
    569570        Set<PluralInfo> seen = new HashSet<PluralInfo>(); 
    570571        Set<String> sorted = new TreeSet<String>( 
    571             SUPPLEMENTAL.getPluralLocales(PluralType.cardinal)); 
     572                SUPPLEMENTAL.getPluralLocales(PluralType.cardinal)); 
    572573        Relation<String, String> ruleToExceptions = Relation.of( 
    573             new TreeMap<String, Set<String>>(), TreeSet.class); 
     574                new TreeMap<String, Set<String>>(), TreeSet.class); 
    574575 
    575576        for (String locale : sorted) { 
     
    596597                    } 
    597598                    if (!assertEquals(locale + ", " + digits + ", " + c, 
    598                         expected, hasSamples)) { 
     599                            expected, hasSamples)) { 
    599600                        needLine = true; 
    600601                    } 
     
    602603                if (needLine) { 
    603604                    String countRules = plurals.getPluralRules().getRules( 
    604                         c.toString()); 
     605                            c.toString()); 
    605606                    ruleToExceptions.put(countRules == null ? "" : countRules, 
    606                         "{\"" + locale + "\", \"" + c + "\", \"" 
    607                             + CollectionUtilities.join(compose, ",") 
    608                             + "\"},"); 
     607                            "{\"" + locale + "\", \"" + c + "\", \"" 
     608                                    + CollectionUtilities.join(compose, ",") 
     609                                    + "\"},"); 
    609610                } 
    610611            } 
     
    622623        Map<String, String> likely = SUPPLEMENTAL.getLikelySubtags(); 
    623624        String[][] tests = { { "it_AQ", "it_Latn_AQ" }, 
    624             { "it_Arab", "it_Arab_IT" }, { "az_Cyrl", "az_Cyrl_AZ" }, }; 
     625                { "it_Arab", "it_Arab_IT" }, { "az_Cyrl", "az_Cyrl_AZ" }, }; 
    625626        for (String[] pair : tests) { 
    626627            String newMax = LikelySubtags.maximize(pair[0], likely); 
     
    636637            if (!likely.containsKey(language)) { 
    637638                logln("WARNING: No likely subtag for CLDR language code (" 
    638                     + language + ")"); 
     639                        + language + ")"); 
    639640            } 
    640641        } 
    641642        for (String script : SUPPLEMENTAL.getCLDRScriptCodes()) { 
    642643            if (!likely.containsKey("und_" + script) 
    643                 && !script.equals("Latn") 
    644                 && !script.equals("Zinh") 
    645                 && !script.equals("Zyyy") 
    646                 && ScriptMetadata.getInfo(script) != null 
    647                 && ScriptMetadata.getInfo(script).idUsage != ScriptMetadata.IdUsage.EXCLUSION 
    648                 && ScriptMetadata.getInfo(script).idUsage != ScriptMetadata.IdUsage.UNKNOWN) { 
     644                    && !script.equals("Latn") 
     645                    && !script.equals("Zinh") 
     646                    && !script.equals("Zyyy") 
     647                    && ScriptMetadata.getInfo(script) != null 
     648                    && ScriptMetadata.getInfo(script).idUsage != ScriptMetadata.IdUsage.EXCLUSION 
     649                    && ScriptMetadata.getInfo(script).idUsage != ScriptMetadata.IdUsage.UNKNOWN) { 
    649650                errln("No likely subtag for CLDR script code (und_" + script 
    650                     + ")"); 
     651                        + ")"); 
    651652            } 
    652653        } 
     
    657658        Set<Set<String>> seen = new HashSet<Set<String>>(); 
    658659        Set<String> toTest = new TreeSet<String>(testInfo.getCldrFactory() 
    659             .getAvailable()); 
     660                .getAvailable()); 
    660661        toTest.addAll(SUPPLEMENTAL.getLikelySubtags().keySet()); 
    661662        toTest.addAll(SUPPLEMENTAL.getLikelySubtags().values()); 
     
    684685                String noScript = ltp.setScript("").toString(); 
    685686                String noRegion = ltp.setScript(script).setRegion("") 
    686                     .toString(); 
     687                        .toString(); 
    687688                switch (s.size()) { 
    688689                case 1: // ok if already maximized and strange script/country, 
     
    699700                    // {az_IR, az_Arab, az_Arab_IR} 
    700701                    if (noScript.equals(ss.get(0)) 
    701                         && noRegion.equals(ss.get(1))) { 
     702                            && noRegion.equals(ss.get(1))) { 
    702703                        continue main; 
    703704                    } 
     
    706707                    // en_Latn_US} 
    707708                    if (language.equals(ss.get(0)) 
    708                         && noScript.equals(ss.get(1)) 
    709                         && noRegion.equals(ss.get(2))) { 
     709                            && noScript.equals(ss.get(1)) 
     710                            && noRegion.equals(ss.get(2))) { 
    710711                        continue main; 
    711712                    } 
     
    714715            } 
    715716            errln("Strange size or composition:\t" + s + " \t" 
    716                 + showLocaleParts(s)); 
     717                    + showLocaleParts(s)); 
    717718            seen.add(s); 
    718719        } 
     
    743744    public void TestDefaultScriptCompleteness() { 
    744745        Relation<String, String> scriptToBase = Relation.of( 
    745             new LinkedHashMap<String, Set<String>>(), TreeSet.class); 
     746                new LinkedHashMap<String, Set<String>>(), TreeSet.class); 
    746747        main: for (String locale : testInfo.getCldrFactory() 
    747             .getAvailableLanguages()) { 
     748                .getAvailableLanguages()) { 
    748749            if (!locale.contains("_") && !"root".equals(locale)) { 
    749750                String defaultScript = SUPPLEMENTAL.getDefaultScript(locale); 
     
    752753                } 
    753754                CLDRFile cldrFile = testInfo.getCLDRFile(locale, 
    754                     false); 
     755                        false); 
    755756                UnicodeSet set = cldrFile.getExemplarSet("", 
    756                     WinningChoice.NORMAL); 
     757                        WinningChoice.NORMAL); 
    757758                for (String s : set) { 
    758759                    int script = UScript.getScript(s.codePointAt(0)); 
    759760                    if (script != UScript.UNKNOWN && script != UScript.COMMON 
    760                         && script != UScript.INHERITED) { 
     761                            && script != UScript.INHERITED) { 
    761762                        scriptToBase.put(UScript.getShortName(script), locale); 
    762763                        continue main; 
     
    769770            for (Entry<String, Set<String>> entry : scriptToBase.keyValuesSet()) { 
    770771                errln("Default Scripts missing:\t" + entry.getKey() + "\t" 
    771                     + entry.getValue()); 
     772                        + entry.getValue()); 
    772773            } 
    773774        } 
     
    776777    public void TestTimeData() { 
    777778        Map<String, PreferredAndAllowedHour> timeData = SUPPLEMENTAL 
    778             .getTimeData(); 
     779                .getTimeData(); 
    779780        Set<String> regionsSoFar = new HashSet<String>(); 
    780781        Set<String> current24only = new HashSet<String>(); 
     
    791792            final HourStyle firstAllowed = preferredAndAllowedHour.allowed.iterator().next(); 
    792793            if (preferredAndAllowedHour.preferred == HourStyle.H && firstAllowed == HourStyle.h 
    793                 || preferredAndAllowedHour.preferred == HourStyle.H && firstAllowed == HourStyle.hb 
    794                 || preferredAndAllowedHour.preferred == HourStyle.h && firstAllowed == HourStyle.H) { 
     794                    || preferredAndAllowedHour.preferred == HourStyle.H && firstAllowed == HourStyle.hb 
     795                    || preferredAndAllowedHour.preferred == HourStyle.h && firstAllowed == HourStyle.H) { 
    795796                errln(region + ": allowed " + preferredAndAllowedHour.allowed 
    796                     + " starts with preferred " + preferredAndAllowedHour.preferred); 
     797                        + " starts with preferred " + preferredAndAllowedHour.preferred); 
    797798            } else if (isVerbose()) { 
    798799                logln(region + ": allowed " + preferredAndAllowedHour.allowed 
    799                     + " starts with preferred " + preferredAndAllowedHour.preferred); 
     800                        + " starts with preferred " + preferredAndAllowedHour.preferred); 
    800801            } 
    801802            // for (HourStyle c : preferredAndAllowedHour.allowed) { 
     
    807808            // } 
    808809            if (!preferredAndAllowedHour.allowed.contains(HourStyle.h) 
    809                 && !preferredAndAllowedHour.allowed.contains(HourStyle.hb)) { 
     810                    && !preferredAndAllowedHour.allowed.contains(HourStyle.hb)) { 
    810811                current24only.add(region); 
    811812            } 
     
    815816        } 
    816817        Set<String> missing = new TreeSet<String>( 
    817             STANDARD_CODES.getGoodAvailableCodes(CodeType.territory)); 
     818                STANDARD_CODES.getGoodAvailableCodes(CodeType.territory)); 
    818819        missing.removeAll(regionsSoFar); 
    819820        for (Iterator<String> it = missing.iterator(); it.hasNext();) { 
     
    835836        // 24 hour time ONLY: 
    836837        Set<String> only24lang = new TreeSet<String>( 
    837             Arrays.asList(("sq, br, bu, ca, hr, cs, da, de, nl, et, eu, fi, " 
    838                 + "fr, gl, he, is, id, it, nb, pt, ro, ru, sr, sk, sl, sv, tr, hy") 
    839                 .split(",\\s*"))); 
     838                Arrays.asList(("sq, br, bu, ca, hr, cs, da, de, nl, et, eu, fi, " 
     839                        + "fr, gl, he, is, id, it, nb, pt, ro, ru, sr, sk, sl, sv, tr, hy") 
     840                        .split(",\\s*"))); 
    840841        // With the new preferences, this is changed  
    841842        Set<String> only24region = new TreeSet<String>(); 
     
    845846        // add them two one of two lists, based on the above list of languages 
    846847        for (String language : SUPPLEMENTAL 
    847             .getLanguagesForTerritoriesPopulationData()) { 
     848                .getLanguagesForTerritoriesPopulationData()) { 
    848849            boolean a24lang = only24lang.contains(language); 
    849850            for (String region : SUPPLEMENTAL 
    850                 .getTerritoriesForPopulationData(language)) { 
     851                    .getTerritoriesForPopulationData(language)) { 
    851852                PopulationData pop = SUPPLEMENTAL 
    852                     .getLanguageAndTerritoryPopulationData(language, region); 
     853                        .getLanguageAndTerritoryPopulationData(language, region); 
    853854                if (pop.getOfficialStatus().compareTo( 
    854                     OfficialStatus.de_facto_official) < 0) { 
     855                        OfficialStatus.de_facto_official) < 0) { 
    855856                    continue; 
    856857                } 
     
    873874 
    874875            errln("24-hour-only doesn't include needed items:\n" 
    875                 + " add " 
    876                 + CldrUtility.join(missing24only, " ") 
    877                 + "\n\t\t" 
    878                 + CldrUtility.join(missing24only, "\n\t\t", 
    879                     new NameCodeTransform(testInfo.getEnglish(), 
    880                         CLDRFile.TERRITORY_NAME))); 
     876                    + " add " 
     877                    + CldrUtility.join(missing24only, " ") 
     878                    + "\n\t\t" 
     879                    + CldrUtility.join(missing24only, "\n\t\t", 
     880                            new NameCodeTransform(testInfo.getEnglish(), 
     881                                    CLDRFile.TERRITORY_NAME))); 
    881882        } 
    882883    } 
     
    900901        testInfo.getStandardCodes(); 
    901902        Map<String, Map<String, Map<String, String>>> bcp47Data = StandardCodes 
    902             .getLStreg(); 
     903                .getLStreg(); 
    903904        Map<String, Map<String, R2<List<String>, String>>> aliases = SUPPLEMENTAL 
    904             .getLocaleAliasInfo(); 
     905                .getLocaleAliasInfo(); 
    905906 
    906907        for (Entry<String, Map<String, R2<List<String>, String>>> typeMap : aliases 
    907             .entrySet()) { 
     908                .entrySet()) { 
    908909            String type = typeMap.getKey(); 
    909910            Map<String, R2<List<String>, String>> codeReplacement = typeMap 
    910                 .getValue(); 
     911                    .getValue(); 
    911912 
    912913            Map<String, Map<String, String>> bcp47DataTypeData = bcp47Data 
    913                 .get(type.equals("territory") ? "region" : type); 
     914                    .get(type.equals("territory") ? "region" : type); 
    914915            if (bcp47DataTypeData == null) { 
    915916                logln("skipping BCP47 test for " + type); 
    916917            } else { 
    917918                for (Entry<String, Map<String, String>> codeData : bcp47DataTypeData 
    918                     .entrySet()) { 
     919                        .entrySet()) { 
    919920                    String code = codeData.getKey(); 
    920921                    if (codeReplacement.containsKey(code) 
    921                         || codeReplacement.containsKey(code 
    922                             .toUpperCase(Locale.ENGLISH))) { 
     922                            || codeReplacement.containsKey(code 
     923                                    .toUpperCase(Locale.ENGLISH))) { 
    923924                        continue; 
    924925                        // TODO, check the value 
     
    926927                    Map<String, String> data = codeData.getValue(); 
    927928                    if (data.containsKey("Deprecated") 
    928                         && SUPPLEMENTAL.getCLDRLanguageCodes().contains( 
    929                             code)) { 
     929                            && SUPPLEMENTAL.getCLDRLanguageCodes().contains( 
     930                                    code)) { 
    930931                        errln("supplementalMetadata.xml: alias is missing <languageAlias type=\"" 
    931                             + code + "\" ... /> " + "\t" + data); 
     932                                + code + "\" ... /> " + "\t" + data); 
    932933                    } 
    933934                } 
     
    937938            Set<String> nullReplacements = new TreeSet<String>(); 
    938939            for (Entry<String, R2<List<String>, String>> codeRep : codeReplacement 
    939                 .entrySet()) { 
     940                    .entrySet()) { 
    940941                String code = codeRep.getKey(); 
    941942                List<String> replacements = codeRep.getValue().get0(); 
     
    947948                for (String replacement : replacements) { 
    948949                    R2<List<String>, String> newReplacement = codeReplacement 
    949                         .get(replacement); 
     950                            .get(replacement); 
    950951                    if (newReplacement != null) { 
    951952                        List<String> list = newReplacement.get0(); 
     
    958959                } 
    959960                List<String> fixedList = new ArrayList<String>( 
    960                     fixedReplacements); 
     961                        fixedReplacements); 
    961962                if (!replacements.equals(fixedList)) { 
    962963                    R3<String, List<String>, List<String>> row = Row.of(code, 
    963                         replacements, fixedList); 
     964                            replacements, fixedList); 
    964965                    System.out.println(row.toString()); 
    965966                    failures.add(row); 
     
    974975 
    975976                    errln(code + "\t=>\t" + oldReplacement + "\tshould be:\n\t" 
    976                         + "<" + type + "Alias type=\"" + code 
    977                         + "\" replacement=\"" 
    978                         + CollectionUtilities.join(newReplacement, " ") 
    979                         + "\" reason=\"XXX\"/> <!-- YYY -->\n"); 
     977                            + "<" + type + "Alias type=\"" + code 
     978                            + "\" replacement=\"" 
     979                            + CollectionUtilities.join(newReplacement, " ") 
     980                            + "\" reason=\"XXX\"/> <!-- YYY -->\n"); 
    980981                } 
    981982            } 
     
    987988 
    988989    static final List<String> oldRegions = Arrays 
    989         .asList("NT, YD, QU, SU, DD, FX, ZR, AN, BU, TP, CS, YU" 
    990             .split(", ")); 
     990            .asList("NT, YD, QU, SU, DD, FX, ZR, AN, BU, TP, CS, YU" 
     991                    .split(", ")); 
    991992 
    992993    public void TestTerritoryContainment() { 
    993994        Relation<String, String> map = SUPPLEMENTAL 
    994             .getTerritoryToContained(ContainmentStyle.all); 
     995                .getTerritoryToContained(ContainmentStyle.all); 
    995996        Relation<String, String> mapCore = SUPPLEMENTAL.getContainmentCore(); 
    996997        Set<String> mapItems = new LinkedHashSet<String>(); 
     
    10011002        } 
    10021003        Map<String, Map<String, String>> bcp47RegionData = StandardCodes 
    1003             .getLStreg().get("region"); 
     1004                .getLStreg().get("region"); 
    10041005 
    10051006        // verify that all regions are covered 
    10061007        Set<String> bcp47Regions = new LinkedHashSet<String>( 
    1007             bcp47RegionData.keySet()); 
     1008                bcp47RegionData.keySet()); 
    10081009        bcp47Regions.remove("ZZ"); // We don't care about ZZ since it is the 
    10091010        // unknown region... 
     
    10231024            mapItems.removeAll(oldRegions); 
    10241025            errlnDiff("containment items not in bcp47 regions: ", mapItems, 
    1025                 bcp47Regions); 
     1026                    bcp47Regions); 
    10261027            errlnDiff("bcp47 regions not in containment items: ", bcp47Regions, 
    1027                 mapItems); 
     1028                    mapItems); 
    10281029        } 
    10291030 
     
    10321033 
    10331034        Map<String, Integer> from001 = getRecursiveContainment("001", map, 
    1034             new LinkedHashMap<String, Integer>(), 1); 
     1035                new LinkedHashMap<String, Integer>(), 1); 
    10351036        from001.put("001", 0); 
    10361037        Set<String> keySet = from001.keySet(); 
    10371038        for (String region : keySet) { 
    10381039            logln(Utility.repeat("\t", from001.get(region)) + "\t" + region 
    1039                 + "\t" + getRegionName(region)); 
     1040                    + "\t" + getRegionName(region)); 
    10401041        } 
    10411042 
     
    10491050        if (!mapItems.equals(keySet)) { 
    10501051            errlnDiff( 
    1051                 "containment core items that can't be reached from 001: ", 
    1052                 mapItems, keySet); 
     1052                    "containment core items that can't be reached from 001: ", 
     1053                    mapItems, keySet); 
    10531054        } 
    10541055    } 
    10551056 
    10561057    private void errlnDiff(String title, Set<String> mapItems, 
    1057         Set<String> keySet) { 
     1058            Set<String> keySet) { 
    10581059        Set<String> diff = new LinkedHashSet<String>(mapItems); 
    10591060        diff.removeAll(keySet); 
     
    10681069 
    10691070    private Map<String, Integer> getRecursiveContainment(String region, 
    1070         Relation<String, String> map, Map<String, Integer> result, int depth) { 
     1071            Relation<String, String> map, Map<String, Integer> result, int depth) { 
    10711072        Set<String> contained = map.getAll(region); 
    10721073        if (contained == null) { 
     
    10761077            if (result.containsKey(item)) { 
    10771078                logln("Duplicate containment " + item + "\t" 
    1078                     + getRegionName(item)); 
     1079                        + getRegionName(item)); 
    10791080                continue; 
    10801081            } 
     
    10871088    public void TestMacrolanguages() { 
    10881089        Set<String> languageCodes = STANDARD_CODES 
    1089             .getAvailableCodes("language"); 
     1090                .getAvailableCodes("language"); 
    10901091        Map<String, Map<String, R2<List<String>, String>>> typeToTagToReplacement = SUPPLEMENTAL 
    1091             .getLocaleAliasInfo(); 
     1092                .getLocaleAliasInfo(); 
    10921093        Map<String, R2<List<String>, String>> tagToReplacement = typeToTagToReplacement 
    1093             .get("language"); 
     1094                .get("language"); 
    10941095 
    10951096        Relation<String, String> replacementToReplaced = Relation.of( 
    1096             new TreeMap<String, Set<String>>(), TreeSet.class); 
     1097                new TreeMap<String, Set<String>>(), TreeSet.class); 
    10971098        for (String language : tagToReplacement.keySet()) { 
    10981099            List<String> replacements = tagToReplacement.get(language).get0(); 
     
    11041105 
    11051106        Map<String, Map<String, Map<String, String>>> lstreg = StandardCodes 
    1106             .getLStreg(); 
     1107                .getLStreg(); 
    11071108        Map<String, Map<String, String>> lstregLanguageInfo = lstreg 
    1108             .get("language"); 
     1109                .get("language"); 
    11091110 
    11101111        Relation<Scope, String> scopeToCodes = Relation.of( 
    1111             new TreeMap<Scope, Set<String>>(), TreeSet.class); 
     1112                new TreeMap<Scope, Set<String>>(), TreeSet.class); 
    11121113        // the invariant is that every macrolanguage has exactly 1 encompassed 
    11131114        // language that maps to it 
    11141115 
    11151116        main: for (String language : Builder.with(new TreeSet<String>()) 
    1116             .addAll(languageCodes).addAll(Iso639Data.getAvailable()).get()) { 
     1117                .addAll(languageCodes).addAll(Iso639Data.getAvailable()).get()) { 
    11171118            if (language.equals("no") || language.equals("sh")) 
    11181119                continue; // special cases 
     
    11231124                } 
    11241125                Set<String> replacements = replacementToReplaced 
    1125                     .getAll(language); 
     1126                        .getAll(language); 
    11261127                if (replacements == null || replacements.size() == 0) { 
    11271128                    scopeToCodes.put(languageScope, language); 
     
    11311132                    for (String replacement : replacements) { 
    11321133                        Scope replacementScope = getScope(replacement, 
    1133                             lstregLanguageInfo); 
     1134                                lstregLanguageInfo); 
    11341135                        if (replacementScope == Scope.Individual) { 
    11351136                            continue main; 
     
    11501151                    } else { 
    11511152                        Map<String, String> languageInfo = lstregLanguageInfo 
    1152                             .get(language); 
     1153                                .get(language); 
    11531154                        if (languageInfo != null) { 
    11541155                            name = languageInfo.get("Description"); 
     
    11571158                } 
    11581159                errln(scope + "\t" + language + "\t" + name + "\t" 
    1159                     + Iso639Data.getType(language)); 
     1160                        + Iso639Data.getType(language)); 
    11601161            } 
    11611162        } 
     
    11631164 
    11641165    private Scope getScope(String language, 
    1165         Map<String, Map<String, String>> lstregLanguageInfo) { 
     1166            Map<String, Map<String, String>> lstregLanguageInfo) { 
    11661167        Scope languageScope = Iso639Data.getScope(language); 
    11671168        Map<String, String> languageInfo = lstregLanguageInfo.get(language); 
     
    11831184    } 
    11841185 
     1186    static final boolean LOCALES_FIXED = false; 
     1187     
    11851188    public void TestPopulation() { 
    11861189        Set<String> languages = SUPPLEMENTAL 
    1187             .getLanguagesForTerritoriesPopulationData(); 
     1190                .getLanguagesForTerritoriesPopulationData(); 
    11881191        Relation<String, String> baseToLanguages = Relation.of( 
    1189             new TreeMap<String, Set<String>>(), TreeSet.class); 
     1192                new TreeMap<String, Set<String>>(), TreeSet.class); 
    11901193        LanguageTagParser ltp = new LanguageTagParser(); 
     1194        LanguageTagCanonicalizer ltc = new LanguageTagCanonicalizer(false); 
     1195 
    11911196        for (String language : languages) { 
     1197            if (LOCALES_FIXED) { 
     1198                String canonicalForm = ltc.transform(language); 
     1199                if (!assertEquals("Canonical form", canonicalForm, language)) { 
     1200                    int debug = 0; 
     1201                } 
     1202            } 
     1203 
    11921204            String base = ltp.set(language).getLanguage(); 
    11931205            String script = ltp.getScript(); 
     
    11991211            Set<String> primaryScripts = Collections.emptySet(); 
    12001212            Map<Type, BasicLanguageData> basicData = SUPPLEMENTAL 
    1201                 .getBasicLanguageDataMap(base); 
     1213                    .getBasicLanguageDataMap(base); 
    12021214            if (basicData != null) { 
    12031215                BasicLanguageData s = basicData 
    1204                     .get(BasicLanguageData.Type.primary); 
     1216                        .get(BasicLanguageData.Type.primary); 
    12051217                if (s != null) { 
    12061218                    primaryScripts = s.getScripts(); 
     
    12121224            if (!script.isEmpty() && !primaryScripts.contains(script)) { 
    12131225                errln(base + ": Script found in territory data (" + script 
    1214                     + ") is not in primary scripts :\t" + primaryScripts); 
     1226                        + ") is not in primary scripts :\t" + primaryScripts); 
    12151227            } 
    12161228 
     
    12241236        } 
    12251237 
    1226         // the invariants are that if we have a base, we must not have a script. 
    1227         // and if we don't have a base, we must have two items 
    1228         for (String base : baseToLanguages.keySet()) { 
    1229             Set<String> languagesForBase = baseToLanguages.getAll(base); 
    1230             if (languagesForBase.contains(base)) { 
    1231                 if (languagesForBase.size() > 1) { 
    1232                     errln("Cannot have base alone with other scripts:\t" 
    1233                         + languagesForBase); 
    1234                 } 
    1235             } else { 
    1236                 if (languagesForBase.size() == 1) { 
    1237                     errln("Cannot have only one script for language:\t" 
    1238                         + languagesForBase); 
     1238        if (!LOCALES_FIXED) { 
     1239            // the invariants are that if we have a base, we must not have a script. 
     1240            // and if we don't have a base, we must have two items 
     1241            for (String base : baseToLanguages.keySet()) { 
     1242                Set<String> languagesForBase = baseToLanguages.getAll(base); 
     1243                if (languagesForBase.contains(base)) { 
     1244                    if (languagesForBase.size() > 1) { 
     1245                        errln("Cannot have base alone with other scripts:\t" 
     1246                                + languagesForBase); 
     1247                    } 
     1248                } else { 
     1249                    if (languagesForBase.size() == 1) { 
     1250                        errln("Cannot have only one script for language:\t" 
     1251                                + languagesForBase); 
     1252                    } 
    12391253                } 
    12401254            } 
     
    12451259        if (SUPPLEMENTAL.getSkippedElements().size() > 0) { 
    12461260            logln("SupplementalDataInfo API doesn't support: " 
    1247                 + SUPPLEMENTAL.getSkippedElements().toString()); 
     1261                    + SUPPLEMENTAL.getSkippedElements().toString()); 
    12481262        } 
    12491263    } 
     
    12511265    // these are settings for exceptional cases we want to allow 
    12521266    private static final Set<String> EXCEPTION_CURRENCIES_WITH_NEW = new TreeSet<String>( 
    1253         Arrays.asList("ILS", "NZD", "PGK", "TWD")); 
     1267            Arrays.asList("ILS", "NZD", "PGK", "TWD")); 
    12541268 
    12551269    // ok since there is no problem with confusion 
    12561270    private static final Set<String> OK_TO_NOT_HAVE_OLD = new TreeSet<String>( 
    1257         Arrays.asList("ADP", "ATS", "BEF", "CYP", "DEM", "ESP", "FIM", 
    1258             "FRF", "GRD", "IEP", "ITL", "LUF", "MTL", "MTP", "NLG", 
    1259             "PTE", "YUM", "ARA", "BAD", "BGL", "BOP", "BRC", "BRN", 
    1260             "BRR", "BUK", "CSK", "ECS", "GEK", "GNS", "GQE", "HRD", 
    1261             "ILP", "LTT", "LVR", "MGF", "MLF", "MZE", "NIC", "PEI", 
    1262             "PES", "SIT", "SRG", "SUR", "TJR", "TPE", "UAK", "YUD", 
    1263             "YUN", "ZRZ", "GWE")); 
     1271            Arrays.asList("ADP", "ATS", "BEF", "CYP", "DEM", "ESP", "FIM", 
     1272                    "FRF", "GRD", "IEP", "ITL", "LUF", "MTL", "MTP", "NLG", 
     1273                    "PTE", "YUM", "ARA", "BAD", "BGL", "BOP", "BRC", "BRN", 
     1274                    "BRR", "BUK", "CSK", "ECS", "GEK", "GNS", "GQE", "HRD", 
     1275                    "ILP", "LTT", "LVR", "MGF", "MLF", "MZE", "NIC", "PEI", 
     1276                    "PES", "SIT", "SRG", "SUR", "TJR", "TPE", "UAK", "YUD", 
     1277                    "YUN", "ZRZ", "GWE")); 
    12641278 
    12651279    private static final Date LIMIT_FOR_NEW_CURRENCY = new Date( 
    1266         new Date().getYear() - 5, 1, 1); 
     1280            new Date().getYear() - 5, 1, 1); 
    12671281    private static final Date NOW = new Date(); 
    12681282    private Matcher oldMatcher = Pattern.compile( 
    1269         "\\bold\\b|\\([0-9]{4}-[0-9]{4}\\)", Pattern.CASE_INSENSITIVE) 
    1270         .matcher(""); 
     1283            "\\bold\\b|\\([0-9]{4}-[0-9]{4}\\)", Pattern.CASE_INSENSITIVE) 
     1284            .matcher(""); 
    12711285    private Matcher newMatcher = Pattern.compile("\\bnew\\b", 
    1272         Pattern.CASE_INSENSITIVE).matcher(""); 
     1286            Pattern.CASE_INSENSITIVE).matcher(""); 
    12731287 
    12741288    /** 
     
    12811295        IsoCurrencyParser isoCodes = IsoCurrencyParser.getInstance(); 
    12821296        Set<String> currencyCodes = STANDARD_CODES 
    1283             .getGoodAvailableCodes("currency"); 
     1297                .getGoodAvailableCodes("currency"); 
    12841298        Relation<String, Pair<String, CurrencyDateInfo>> nonModernCurrencyCodes = Relation 
    1285             .of(new TreeMap<String, Set<Pair<String, CurrencyDateInfo>>>(), 
    1286                 TreeSet.class); 
     1299                .of(new TreeMap<String, Set<Pair<String, CurrencyDateInfo>>>(), 
     1300                        TreeSet.class); 
    12871301        Relation<String, Pair<String, CurrencyDateInfo>> modernCurrencyCodes = Relation 
    1288             .of(new TreeMap<String, Set<Pair<String, CurrencyDateInfo>>>(), 
    1289                 TreeSet.class); 
     1302                .of(new TreeMap<String, Set<Pair<String, CurrencyDateInfo>>>(), 
     1303                        TreeSet.class); 
    12901304        Set<String> territoriesWithoutModernCurrencies = new TreeSet<String>( 
    1291             STANDARD_CODES.getGoodAvailableCodes("territory")); 
     1305                STANDARD_CODES.getGoodAvailableCodes("territory")); 
    12921306        Map<String, Date> currencyFirstValid = new TreeMap<String, Date>(); 
    12931307        Map<String, Date> currencyLastValid = new TreeMap<String, Date>(); 
     
    12951309 
    12961310        for (String territory : STANDARD_CODES 
    1297             .getGoodAvailableCodes("territory")) { 
     1311                .getGoodAvailableCodes("territory")) { 
    12981312            /* "EU" behaves like a country for purposes of this test */ 
    12991313            if ((SUPPLEMENTAL.getContained(territory) != null) 
    1300                 && !territory.equals("EU")) { 
     1314                    && !territory.equals("EU")) { 
    13011315                territoriesWithoutModernCurrencies.remove(territory); 
    13021316                continue; 
    13031317            } 
    13041318            Set<CurrencyDateInfo> currencyInfo = SUPPLEMENTAL 
    1305                 .getCurrencyDateInfo(territory); 
     1319                    .getCurrencyDateInfo(territory); 
    13061320            if (currencyInfo == null) { 
    13071321                continue; // error, but will pick up below. 
     
    13131327                if (dateInfo.getErrors().length() != 0) { 
    13141328                    logln("parsing " + territory + "\t" + dateInfo.toString() 
    1315                         + "\t" + dateInfo.getErrors()); 
     1329                            + "\t" + dateInfo.getErrors()); 
    13161330                } 
    13171331                Date firstValue = currencyFirstValid.get(currency); 
     
    13271341                    // OK... 
    13281342                    modernCurrencyCodes.put(currency, 
    1329                         new Pair<String, CurrencyDateInfo>(territory, 
    1330                             dateInfo)); 
     1343                            new Pair<String, CurrencyDateInfo>(territory, 
     1344                                    dateInfo)); 
    13311345                    territoriesWithoutModernCurrencies.remove(territory); 
    13321346                } else { 
    13331347                    nonModernCurrencyCodes.put(currency, 
    1334                         new Pair<String, CurrencyDateInfo>(territory, 
    1335                             dateInfo)); 
     1348                            new Pair<String, CurrencyDateInfo>(territory, 
     1349                                    dateInfo)); 
    13361350                } 
    13371351                logln(territory 
    1338                     + "\t" 
    1339                     + dateInfo.toString() 
    1340                     + "\t" 
    1341                     + testInfo.getEnglish().getName(CLDRFile.CURRENCY_NAME, 
    1342                         currency)); 
     1352                        + "\t" 
     1353                        + dateInfo.toString() 
     1354                        + "\t" 
     1355                        + testInfo.getEnglish().getName(CLDRFile.CURRENCY_NAME, 
     1356                                currency)); 
    13431357            } 
    13441358        } 
     
    13461360        nonModernCurrencyCodes.removeAll(modernCurrencyCodes.keySet()); 
    13471361        Relation<String, String> isoCurrenciesToCountries = Relation.of( 
    1348             new TreeMap<String, Set<String>>(), TreeSet.class) 
    1349             .addAllInverted(isoCodes.getCountryToCodes()); 
     1362                new TreeMap<String, Set<String>>(), TreeSet.class) 
     1363                .addAllInverted(isoCodes.getCountryToCodes()); 
    13501364        // now print error messages 
    13511365        logln("Modern Codes: " + modernCurrencyCodes.size() + "\t" 
    1352             + modernCurrencyCodes); 
     1366                + modernCurrencyCodes); 
    13531367        Set<String> missing = new TreeSet<String>( 
    1354             isoCurrenciesToCountries.keySet()); 
     1368                isoCurrenciesToCountries.keySet()); 
    13551369        missing.removeAll(modernCurrencyCodes.keySet()); 
    13561370        if (missing.size() != 0) { 
     
    13601374        for (String currency : modernCurrencyCodes.keySet()) { 
    13611375            Set<Pair<String, CurrencyDateInfo>> data = modernCurrencyCodes 
    1362                 .getAll(currency); 
     1376                    .getAll(currency); 
    13631377            final String name = testInfo.getEnglish().getName( 
    1364                 CLDRFile.CURRENCY_NAME, currency); 
     1378                    CLDRFile.CURRENCY_NAME, currency); 
    13651379 
    13661380            Set<String> isoCountries = isoCurrenciesToCountries 
    1367                 .getAll(currency); 
     1381                    .getAll(currency); 
    13681382            if (isoCountries == null) { 
    13691383                isoCountries = new TreeSet<String>(); 
     
    13761390            if (!isoCountries.equals(cldrCountries)) { 
    13771391                errln("Mismatch between ISO and Cldr modern currencies for " 
    1378                     + currency + "\tISO:" + isoCountries + "\tCLDR:" 
    1379                     + cldrCountries); 
     1392                        + currency + "\tISO:" + isoCountries + "\tCLDR:" 
     1393                        + cldrCountries); 
    13801394                showCountries("iso-cldr", isoCountries, cldrCountries, missing); 
    13811395                showCountries("cldr-iso", cldrCountries, isoCountries, missing); 
     
    13841398            if (oldMatcher.reset(name).find()) { 
    13851399                errln("Has 'old' in name but still used " + "\t" + currency 
    1386                     + "\t" + name + "\t" + data); 
     1400                        + "\t" + name + "\t" + data); 
    13871401            } 
    13881402            if (newMatcher.reset(name).find() 
    1389                 && !EXCEPTION_CURRENCIES_WITH_NEW.contains(currency)) { 
     1403                    && !EXCEPTION_CURRENCIES_WITH_NEW.contains(currency)) { 
    13901404                // find the first use. If older than 5 years, flag as error 
    13911405                if (currencyFirstValid.get(currency).compareTo( 
    1392                     LIMIT_FOR_NEW_CURRENCY) < 0) { 
     1406                        LIMIT_FOR_NEW_CURRENCY) < 0) { 
    13931407                    errln("Has 'new' in name but used since " 
    1394                         + CurrencyDateInfo.formatDate(currencyFirstValid 
    1395                             .get(currency)) + "\t" + currency + "\t" 
    1396                             + name + "\t" + data); 
     1408                            + CurrencyDateInfo.formatDate(currencyFirstValid 
     1409                                    .get(currency)) + "\t" + currency + "\t" 
     1410                                    + name + "\t" + data); 
    13971411                } else { 
    13981412                    logln("Has 'new' in name but used since " 
    1399                         + CurrencyDateInfo.formatDate(currencyFirstValid 
    1400                             .get(currency)) + "\t" + currency + "\t" 
    1401                             + name + "\t" + data); 
     1413                            + CurrencyDateInfo.formatDate(currencyFirstValid 
     1414                                    .get(currency)) + "\t" + currency + "\t" 
     1415                                    + name + "\t" + data); 
    14021416                } 
    14031417            } 
    14041418        } 
    14051419        logln("Non-Modern Codes (with dates): " + nonModernCurrencyCodes.size() 
    1406             + "\t" + nonModernCurrencyCodes); 
     1420                + "\t" + nonModernCurrencyCodes); 
    14071421        for (String currency : nonModernCurrencyCodes.keySet()) { 
    14081422            final String name = testInfo.getEnglish().getName( 
    1409                 CLDRFile.CURRENCY_NAME, currency); 
     1423                    CLDRFile.CURRENCY_NAME, currency); 
    14101424            if (newMatcher.reset(name).find() 
    1411                 && !EXCEPTION_CURRENCIES_WITH_NEW.contains(currency)) { 
     1425                    && !EXCEPTION_CURRENCIES_WITH_NEW.contains(currency)) { 
    14121426                logln("Has 'new' in name but NOT used since " 
    1413                     + CurrencyDateInfo.formatDate(currencyLastValid 
    1414                         .get(currency)) + "\t" + currency + "\t" + name 
    1415                         + "\t" + nonModernCurrencyCodes.getAll(currency)); 
     1427                        + CurrencyDateInfo.formatDate(currencyLastValid 
     1428                                .get(currency)) + "\t" + currency + "\t" + name 
     1429                                + "\t" + nonModernCurrencyCodes.getAll(currency)); 
    14161430            } else if (!oldMatcher.reset(name).find() 
    1417                 && !OK_TO_NOT_HAVE_OLD.contains(currency)) { 
     1431                    && !OK_TO_NOT_HAVE_OLD.contains(currency)) { 
    14181432                logln("Doesn't have 'old' or date range in name but NOT used since " 
    1419                     + CurrencyDateInfo.formatDate(currencyLastValid 
    1420                         .get(currency)) 
    1421                         + "\t" 
    1422                         + currency 
    1423                         + "\t" 
    1424                         + name 
    1425                         + "\t" + nonModernCurrencyCodes.getAll(currency)); 
     1433                        + CurrencyDateInfo.formatDate(currencyLastValid 
     1434                                .get(currency)) 
     1435                                + "\t" 
     1436                                + currency 
     1437                                + "\t" 
     1438                                + name 
     1439                                + "\t" + nonModernCurrencyCodes.getAll(currency)); 
    14261440                for (Pair<String, CurrencyDateInfo> pair : nonModernCurrencyCodes 
    1427                     .getAll(currency)) { 
     1441                        .getAll(currency)) { 
    14281442                    final String territory = pair.getFirst(); 
    14291443                    Set<CurrencyDateInfo> currencyInfo = SUPPLEMENTAL 
    1430                         .getCurrencyDateInfo(territory); 
     1444                            .getCurrencyDateInfo(territory); 
    14311445                    for (CurrencyDateInfo dateInfo : currencyInfo) { 
    14321446                        if (dateInfo.getEnd().compareTo(NOW) < 0) { 
     
    14341448                        } 
    14351449                        logln("\tCurrencies used instead: " 
    1436                             + territory 
    1437                             + "\t" 
    1438                             + dateInfo 
    1439                             + "\t" 
    1440                             + testInfo.getEnglish().getName( 
    1441                                 CLDRFile.CURRENCY_NAME, 
    1442                                 dateInfo.getCurrency())); 
     1450                                + territory 
     1451                                + "\t" 
     1452                                + dateInfo 
     1453                                + "\t" 
     1454                                + testInfo.getEnglish().getName( 
     1455                                        CLDRFile.CURRENCY_NAME, 
     1456                                        dateInfo.getCurrency())); 
    14431457 
    14441458                    } 
     
    14541468        if (territoriesWithoutModernCurrencies.size() != 0) { 
    14551469            errln("Modern territory missing currency: " 
    1456                 + territoriesWithoutModernCurrencies); 
     1470                    + territoriesWithoutModernCurrencies); 
    14571471        } 
    14581472    } 
    14591473 
    14601474    private void showCountries(final String title, Set<String> isoCountries, 
    1461         Set<String> cldrCountries, Set<String> missing) { 
     1475            Set<String> cldrCountries, Set<String> missing) { 
    14621476        missing.clear(); 
    14631477        missing.addAll(isoCountries); 
     
    14651479        for (String country : missing) { 
    14661480            logln("\t\tExtra in " + title + "\t" + country + " - " 
    1467                 + getRegionName(country)); 
     1481                    + getRegionName(country)); 
    14681482        } 
    14691483    } 
     
    14721486        IsoCurrencyParser isoCodes = IsoCurrencyParser.getInstance(); 
    14731487        Relation<String, IsoCurrencyParser.Data> codeList = isoCodes 
    1474             .getCodeList(); 
     1488                .getCodeList(); 
    14751489        Set<String> currencyCodes = STANDARD_CODES 
    1476             .getGoodAvailableCodes("currency"); 
     1490                .getGoodAvailableCodes("currency"); 
    14771491        for (String cc : currencyCodes) { 
    14781492            Set<IsoCurrencyParser.Data> d = codeList.get(cc); 
     
    14821496                    if (cni.digits != x.getMinorUnit()) { 
    14831497                        logln("Mismatch between ISO/CLDR for decimal places for currency => " + cc + 
    1484                             ". ISO = " + x.getMinorUnit() + " CLDR = " + cni.digits); 
     1498                                ". ISO = " + x.getMinorUnit() + " CLDR = " + cni.digits); 
    14851499                    } 
    14861500                } 
     
    15111525 
    15121526            String defaultContentScript = baseToDefaultContentScript 
    1513                 .get(baseLanguage); 
     1527                    .get(baseLanguage); 
    15141528            if (defaultContentScript != null) { 
    15151529                assertEquals(loc + " defaultContentScript = default", 
    1516                     defaultScript, defaultContentScript); 
     1530                        defaultScript, defaultContentScript); 
    15171531            } 
    15181532            String likely = likelyData.get(baseLanguage); 
    15191533            String likelyScript = likely == null ? null : CLDRLocale 
    1520                 .getInstance(likely).getScript(); 
     1534                    .getInstance(likely).getScript(); 
    15211535            Map<Type, BasicLanguageData> scriptInfo = supp 
    1522                 .getBasicLanguageDataMap(baseLanguage); 
     1536                    .getBasicLanguageDataMap(baseLanguage); 
    15231537            if (scriptInfo == null) { 
    15241538                errln(loc + ": has no BasicLanguageData"); 
     
    15321546                } else if (!data.getScripts().contains(defaultScript)) { 
    15331547                    errln(loc + ": " + defaultScript 
    1534                         + " not in BasicLanguageData " + data.getScripts()); 
     1548                            + " not in BasicLanguageData " + data.getScripts()); 
    15351549                } 
    15361550            } 
     
    15431557                if (!loc.getScript().equals(defaultScript)) { 
    15441558                    assertNotEquals(locale 
    1545                         + ": only include script if not default", 
    1546                         loc.getScript(), defaultScript); 
     1559                            + ": only include script if not default", 
     1560                            loc.getScript(), defaultScript); 
    15471561                } 
    15481562            } 
     
    15711585 
    15721586        Set<String> testLocales = STANDARD_CODES.getLocaleCoverageLocales( 
    1573             Organization.google, EnumSet.of(Level.MODERN)); 
     1587                Organization.google, EnumSet.of(Level.MODERN)); 
    15741588        Set<String> allLocales = testInfo.getCldrFactory().getAvailable(); 
    15751589        LanguageTagParser ltp = new LanguageTagParser(); 
     
    15851599            } 
    15861600            CoverageIssue needsCoverage = testLocales.contains(locale) 
    1587                 ? CoverageIssue.error 
    1588                     : CoverageIssue.log; 
     1601                    ? CoverageIssue.error 
     1602                            : CoverageIssue.log; 
    15891603            CoverageIssue needsCoverage2 = needsCoverage == CoverageIssue.error ? CoverageIssue.warn : needsCoverage; 
    15901604 
    1591 //            if (logKnownIssue("Cldrbug:8809", "Missing plural rules/samples be and ga locales")) { 
    1592 //                if (locale.equals("be") || locale.equals("ga")) { 
    1593 //                    needsCoverage = CoverageIssue.warn; 
    1594 //                } 
    1595 //            } 
     1605            //            if (logKnownIssue("Cldrbug:8809", "Missing plural rules/samples be and ga locales")) { 
     1606            //                if (locale.equals("be") || locale.equals("ga")) { 
     1607            //                    needsCoverage = CoverageIssue.warn; 
     1608            //                } 
     1609            //            } 
    15961610            ULocale ulocale = new ULocale(locale); 
    15971611            PluralRulesFactory prf = PluralRulesFactory 
    1598                 .getInstance(TestAll.TestInfo.getInstance() 
    1599                     .getSupplementalDataInfo()); 
     1612                    .getInstance(TestAll.TestInfo.getInstance() 
     1613                            .getSupplementalDataInfo()); 
    16001614 
    16011615            for (PluralType type : PluralType.values()) { 
    16021616                PluralInfo pluralInfo = SUPPLEMENTAL.getPlurals(type, locale, 
    1603                     false); 
     1617                        false); 
    16041618                if (pluralInfo == null) { 
    16051619                    errOrLog(needsCoverage, locale + "\t" + type + " \tmissing plural rules", "Cldrbug:7839", "Missing plural data for modern locales"); 
     
    16121626                HashSet<String> samples = new HashSet<String>(); 
    16131627                EnumSet<Count> countsWithNoSamples = EnumSet 
    1614                     .noneOf(Count.class); 
     1628                        .noneOf(Count.class); 
    16151629                Relation<String, Count> samplesToCounts = Relation.of( 
    1616                     new HashMap(), LinkedHashSet.class); 
     1630                        new HashMap(), LinkedHashSet.class); 
    16171631                Set<Count> countsFound = prf.getSampleCounts(ulocale, 
    1618                     type.standardType); 
     1632                        type.standardType); 
    16191633                StringBuilder failureCases = new StringBuilder(); 
    16201634                for (Count count : counts) { 
     
    16271641                        samplesToCounts.put(pattern, count); 
    16281642                        logln(ulocale + "\t" + type + "\t" + count + "\t" 
    1629                             + pattern); 
     1643                                + pattern); 
    16301644                    } 
    16311645                } 
    16321646                if (!countsWithNoSamples.isEmpty()) { 
    16331647                    errOrLog(needsCoverage, ulocale + "\t" + type + "\t missing samples:\t" + countsWithNoSamples, 
    1634                         "cldrbug:7075", "Missing ordinal minimal pairs"); 
     1648                            "cldrbug:7075", "Missing ordinal minimal pairs"); 
    16351649                    errOrLog(needsCoverage2, failureCases.toString()); 
    16361650                } 
    16371651                for (Entry<String, Set<Count>> entry : samplesToCounts 
    1638                     .keyValuesSet()) { 
     1652                        .keyValuesSet()) { 
    16391653                    if (entry.getValue().size() != 1) { 
    16401654                        errOrLog(needsCoverage, ulocale + "\t" + type + "\t duplicate samples: " + entry.getValue() 
    1641                             + " => «" + entry.getKey() + "»", "cldrbug:7119", "Some duplicate minimal pairs"); 
     1655                                + " => «" + entry.getKey() + "»", "cldrbug:7119", "Some duplicate minimal pairs"); 
    16421656                        errOrLog(needsCoverage2, failureCases.toString()); 
    16431657                    } 
     
    16761690        // TODO: Fix so that it works properly on non-BMP digit strings. 
    16771691        String[] knownExceptions = { "brah", "cakm", "hanidec", "osma", "shrd", 
    1678             "sora", "takr" }; 
     1692                "sora", "takr" }; 
    16791693        List<String> knownExceptionList = Arrays.asList(knownExceptions); 
    16801694        for (String ns : SUPPLEMENTAL.getNumericNumberingSystems()) { 
     
    16901704                if (i > 0 && ch != previousChar + 1) { 
    16911705                    errln("Digits for numbering system " 
    1692                         + ns 
    1693                         + " are not in code point order. Previous char = U+" 
    1694                         + Utility.hex(previousChar, 4) 
    1695                         + " Current char = U+" + Utility.hex(ch, 4)); 
     1706                            + ns 
     1707                            + " are not in code point order. Previous char = U+" 
     1708                            + Utility.hex(previousChar, 4) 
     1709                            + " Current char = U+" + Utility.hex(ch, 4)); 
    16961710                    break; 
    16971711                } 
     
    17221736            for (Integer i : unicodeDigits) { 
    17231737                errln("Unicode digit: " + UCharacter.getName(i) + " is not in any numbering system. Script = " 
    1724                     + UScript.getShortName(UScript.getScript(i))); 
     1738                        + UScript.getShortName(UScript.getScript(i))); 
    17251739            } 
    17261740        } 
     
    17411755            } 
    17421756            final Set<MetaZoneRange> ranges = SUPPLEMENTAL 
    1743                 .getMetaZoneRanges(timezone); 
     1757                    .getMetaZoneRanges(timezone); 
    17441758 
    17451759            if (assertNotNull("metazones for " + timezone, ranges)) { 
     
    17551769                } 
    17561770                assertRelation(timezone + " has metazone before 1970?", true, 
    1757                     goalMin, LEQ, new Date(min)); 
     1771                        goalMin, LEQ, new Date(min)); 
    17581772                assertRelation(timezone 
    1759                     + " has metazone until way in the future?", true, 
    1760                     goalMax, GEQ, new Date(max)); 
     1773                        + " has metazone until way in the future?", true, 
     1774                        goalMax, GEQ, new Date(max)); 
    17611775            } 
    17621776        } 
    17631777        com.google.common.collect.Interners i; 
    17641778    } 
     1779 
     1780    public void Test9924 () { 
     1781        PopulationData zhCNData = SUPPLEMENTAL.getLanguageAndTerritoryPopulationData(LOCALES_FIXED ? "zh" : "zh_Hans", "CN"); 
     1782        PopulationData yueCNData = SUPPLEMENTAL.getLanguageAndTerritoryPopulationData("yue", "CN"); 
     1783        assertTrue("yue*10 < zh", yueCNData.getPopulation() < zhCNData.getPopulation()); 
     1784    } 
    17651785} 
Note: See TracChangeset for help on using the changeset viewer.