| /* |
| * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /* |
| * @test |
| * @bug 7069824 8042360 |
| * @summary Verify implementation for Locale matching. |
| * @run main Bug7069824 |
| */ |
| |
| import java.util.*; |
| import java.util.Locale.*; |
| import static java.util.Locale.FilteringMode.*; |
| import static java.util.Locale.LanguageRange.*; |
| |
| public class Bug7069824 { |
| |
| static boolean err = false; |
| |
| public static void main(String[] args) { |
| testLanguageRange(); |
| testLocale(); |
| |
| if (err) { |
| throw new RuntimeException("Failed."); |
| } |
| } |
| |
| private static void testLanguageRange() { |
| System.out.println("Test LanguageRange class..."); |
| testConstants(); |
| testConstructors(); |
| testMethods(); |
| } |
| |
| private static void testLocale() { |
| System.out.println("Test Locale class..."); |
| test_filter(); |
| test_filterTags(); |
| test_lookup(); |
| test_lookupTag(); |
| } |
| |
| private static void testConstants() { |
| boolean error = false; |
| |
| if (MIN_WEIGHT != 0.0) { |
| error = true; |
| System.err.println(" MIN_WEIGHT should be 0.0 but got " |
| + MIN_WEIGHT); |
| } |
| |
| if (MAX_WEIGHT != 1.0) { |
| error = true; |
| System.err.println(" MAX_WEIGHT should be 1.0 but got " |
| + MAX_WEIGHT); |
| } |
| |
| if (error) { |
| err = true; |
| System.err.println(" testConstants() failed."); |
| } else { |
| System.out.println(" testConstants() passed."); |
| } |
| } |
| |
| private static void testConstructors() { |
| boolean error = false; |
| |
| LanguageRange lr; |
| String range; |
| double weight; |
| |
| // Testcase for 8042360 |
| range = "en-Latn-1234567890"; |
| try { |
| lr = new LanguageRange(range); |
| error = true; |
| System.err.println(" IAE should be thrown for LanguageRange(" |
| + range + ")."); |
| } |
| catch (IllegalArgumentException ex) { |
| } |
| |
| range = null; |
| try { |
| lr = new LanguageRange(range); |
| error = true; |
| System.err.println(" NPE should be thrown for LanguageRange(" |
| + range + ")."); |
| } |
| catch (NullPointerException ex) { |
| } |
| |
| range = null; |
| weight = 0.8; |
| try { |
| lr = new LanguageRange(range, weight); |
| error = true; |
| System.err.println(" NPE should be thrown for LanguageRange(" |
| + range + ", " + weight + ")."); |
| } |
| catch (NullPointerException ex) { |
| } |
| |
| range = "elvish"; |
| try { |
| lr = new LanguageRange(range); |
| } |
| catch (Exception ex) { |
| error = true; |
| System.err.println(" " + ex |
| + " should not be thrown for LanguageRange(" + range + ")."); |
| } |
| |
| range = "de-DE"; |
| try { |
| lr = new LanguageRange(range); |
| } |
| catch (Exception ex) { |
| error = true; |
| System.err.println(" " + ex |
| + " should not be thrown for LanguageRange(" + range + ")."); |
| } |
| |
| range = "ar"; |
| weight = 0.8; |
| try { |
| lr = new LanguageRange(range, weight); |
| } |
| catch (Exception ex) { |
| error = true; |
| System.err.println(" " + ex |
| + " should not be thrown for LanguageRange(" + range + ", " |
| + weight + ")."); |
| } |
| |
| range = "ja"; |
| weight = -0.8; |
| try { |
| lr = new LanguageRange(range, weight); |
| error = true; |
| System.err.println(" IAE should be thrown for LanguageRange(" |
| + range + ", " + weight + ")."); |
| } |
| catch (IllegalArgumentException ex) { |
| } |
| |
| range = "Elvish"; |
| weight = 3.0; |
| try { |
| lr = new LanguageRange(range, weight); |
| error = true; |
| System.err.println(" IAE should be thrown for LanguageRange(" |
| + range + ", " + weight + ")."); |
| } |
| catch (IllegalArgumentException ex) { |
| } |
| |
| String[] illformedRanges = {"-ja", "ja--JP", "en-US-", "a4r", "ar*", |
| "ar-*EG", "", "abcdefghijklmn", "ja-J=", "ja-opqrstuvwxyz"}; |
| for (String r : illformedRanges) { |
| try { |
| lr = new LanguageRange(r); |
| error = true; |
| System.err.println(" IAE should be thrown for LanguageRange(" |
| + r + ")."); |
| } |
| catch (IllegalArgumentException ex) { |
| } |
| } |
| |
| |
| if (error) { |
| err = true; |
| System.err.println(" testConstructors() failed."); |
| } else { |
| System.out.println(" testConstructors() passed."); |
| } |
| } |
| |
| private static void testMethods() { |
| test_getRange(); |
| test_getWeight(); |
| test_equals(); |
| test_parse(); |
| test_mapEquivalents(); |
| } |
| |
| private static void test_getRange() { |
| boolean error = false; |
| |
| String range = "ja"; |
| double weight = 0.5; |
| LanguageRange lr = new LanguageRange(range, weight); |
| if (!lr.getRange().equals(range)) { |
| error = true; |
| System.err.println(" LanguageRange.getRange() returned unexpected value. Expected: " |
| + range + ", got: " + lr.getRange()); |
| } |
| |
| range = "en-US"; |
| weight = 0.5; |
| lr = new LanguageRange(range, weight); |
| if (!lr.getRange().equals(range.toLowerCase())) { |
| error = true; |
| System.err.println(" LanguageRange.getRange() returned unexpected value. Expected: " |
| + range + ", got: " + lr.getRange()); |
| } |
| |
| if (error) { |
| err = true; |
| System.err.println(" test_getRange() failed."); |
| } else { |
| System.out.println(" test_getRange() passed."); |
| } |
| } |
| |
| private static void test_getWeight() { |
| boolean error = false; |
| |
| String range = "ja"; |
| double weight = 0.5; |
| LanguageRange lr = new LanguageRange(range, weight); |
| if (lr.getWeight() != weight) { |
| error = true; |
| System.err.println(" LanguageRange.getWeight() returned unexpected value. Expected: " |
| + weight + ", got: " + lr.getWeight()); |
| } |
| |
| range = "ja"; |
| weight = MAX_WEIGHT; // default |
| lr = new LanguageRange(range); |
| if (!lr.getRange().equals(range) || lr.getWeight() != MAX_WEIGHT) { |
| error = true; |
| System.err.println(" LanguageRange.getWeight() returned unexpected value. Expected: " |
| + weight + ", got: " + lr.getWeight()); |
| } |
| |
| if (error) { |
| err = true; |
| System.err.println(" test_getWeight() failed."); |
| } else { |
| System.out.println(" test_getWeight() passed."); |
| } |
| } |
| |
| private static void test_equals() { |
| boolean error = false; |
| |
| LanguageRange lr1 = new LanguageRange("ja", 1.0); |
| LanguageRange lr2 = new LanguageRange("ja"); |
| LanguageRange lr3 = new LanguageRange("ja", 0.1); |
| LanguageRange lr4 = new LanguageRange("en", 1.0); |
| |
| if (!lr1.equals(lr2)) { |
| error = true; |
| System.err.println(" LanguageRange(LR(ja, 1.0)).equals(LR(ja)) should return true."); |
| } |
| |
| if (lr1.equals(lr3)) { |
| error = true; |
| System.err.println(" LanguageRange(LR(ja, 1.0)).equals(LR(ja, 0.1)) should return false."); |
| } |
| |
| if (lr1.equals(lr4)) { |
| error = true; |
| System.err.println(" LanguageRange(LR(ja, 1.0)).equals(LR(en, 1.0)) should return false."); |
| } |
| |
| if (lr1.equals(null)) { |
| error = true; |
| System.err.println(" LanguageRange(LR(ja, 1.0)).equals(null) should return false."); |
| } |
| |
| if (lr1.equals("")) { |
| error = true; |
| System.err.println(" LanguageRange(LR(ja, 1.0)).equals(\"\") should return false."); |
| |
| } |
| |
| if (error) { |
| err = true; |
| System.err.println(" test_equals() failed."); |
| } else { |
| System.out.println(" test_equals() passed."); |
| } |
| } |
| |
| private static void test_parse() { |
| boolean error = false; |
| |
| List<LanguageRange> list; |
| String str = null; |
| try { |
| list = LanguageRange.parse(str); |
| error = true; |
| System.err.println(" NPE should be thrown for parse(" |
| + str + ")."); |
| } |
| catch (NullPointerException ex) { |
| } |
| |
| str = ""; |
| try { |
| list = LanguageRange.parse(""); |
| error = true; |
| System.err.println(" IAE should be thrown for parse(" |
| + str + ")."); |
| } |
| catch (IllegalArgumentException ex) { |
| } |
| |
| str = "ja;q=3"; |
| try { |
| list = LanguageRange.parse(str); |
| error = true; |
| System.err.println("IAE should be thrown for parse(" |
| + str + ")."); |
| } |
| catch (IllegalArgumentException ex) { |
| } |
| |
| str = "Accept-Language: fr-FX,de-DE;q=0.5, fr-tp-x-FOO;q=0.1," |
| + "en-X-tp;q=0.6,en-FR;q=.7,de-de;q=0.8, iw;q=0.4, " |
| + "he;q=0.4, de-de;q=0.5,ja, in-tpp, in-tp;q=0.2"; |
| ArrayList<LanguageRange> expected = new ArrayList<>(); |
| expected.add(new LanguageRange("fr-fx", 1.0)); |
| expected.add(new LanguageRange("fr-fr", 1.0)); |
| expected.add(new LanguageRange("ja", 1.0)); |
| expected.add(new LanguageRange("in-tpp", 1.0)); |
| expected.add(new LanguageRange("id-tpp", 1.0)); |
| expected.add(new LanguageRange("en-fr", 0.7)); |
| expected.add(new LanguageRange("en-fx", 0.7)); |
| expected.add(new LanguageRange("en-x-tp", 0.6)); |
| expected.add(new LanguageRange("de-de", 0.5)); |
| expected.add(new LanguageRange("de-dd", 0.5)); |
| expected.add(new LanguageRange("iw", 0.4)); |
| expected.add(new LanguageRange("he", 0.4)); |
| expected.add(new LanguageRange("in-tp", 0.2)); |
| expected.add(new LanguageRange("id-tl", 0.2)); |
| expected.add(new LanguageRange("id-tp", 0.2)); |
| expected.add(new LanguageRange("in-tl", 0.2)); |
| expected.add(new LanguageRange("fr-tp-x-foo", 0.1)); |
| expected.add(new LanguageRange("fr-tl-x-foo", 0.1)); |
| List<LanguageRange> got = LanguageRange.parse(str); |
| if (!areEqual(expected, got)) { |
| error = true; |
| System.err.println(" #1 parse() test failed."); |
| } |
| |
| str = "Accept-Language: hak-CN;q=0.8, no-bok-NO;q=0.9, no-nyn, cmn-CN;q=0.1"; |
| expected = new ArrayList<>(); |
| expected.add(new LanguageRange("no-nyn", 1.0)); |
| expected.add(new LanguageRange("nn", 1.0)); |
| expected.add(new LanguageRange("no-bok-no", 0.9)); |
| expected.add(new LanguageRange("nb-no", 0.9)); |
| expected.add(new LanguageRange("hak-CN", 0.8)); |
| expected.add(new LanguageRange("zh-hakka-CN", 0.8)); |
| expected.add(new LanguageRange("i-hak-CN", 0.8)); |
| expected.add(new LanguageRange("cmn-CN", 0.1)); |
| expected.add(new LanguageRange("zh-cmn-CN", 0.1)); |
| expected.add(new LanguageRange("zh-guoyu-CN", 0.1)); |
| got = LanguageRange.parse(str); |
| if (!areEqual(expected, got)) { |
| error = true; |
| System.err.println(" #2 parse() test failed."); |
| } |
| |
| str = "Accept-Language: rki;q=0.4, no-bok-NO;q=0.9, ccq;q=0.5"; |
| expected = new ArrayList<>(); |
| expected.add(new LanguageRange("no-bok-no", 0.9)); |
| expected.add(new LanguageRange("nb-no", 0.9)); |
| expected.add(new LanguageRange("rki", 0.4)); |
| expected.add(new LanguageRange("ybd", 0.4)); |
| expected.add(new LanguageRange("ccq", 0.4)); |
| got = LanguageRange.parse(str); |
| if (!areEqual(expected, got)) { |
| error = true; |
| System.err.println(" #3 parse() test failed."); |
| } |
| |
| if (error) { |
| err = true; |
| System.err.println(" test_parse() failed."); |
| } else { |
| System.out.println(" test_parse() passed."); |
| } |
| } |
| |
| private static boolean areEqual(List<LanguageRange> expected, |
| List<LanguageRange> got) { |
| boolean error = false; |
| |
| int expectedSize = expected.size(); |
| int actualSize = got.size(); |
| |
| if (expectedSize != actualSize) { |
| error = true; |
| |
| System.err.println(" Expected size=" + expectedSize); |
| for (LanguageRange lr : expected) { |
| System.err.println(" range=" + lr.getRange() |
| + ", weight=" + lr.getWeight()); |
| } |
| |
| System.out.println(" Actual size=" + actualSize); |
| for (LanguageRange lr : got) { |
| System.err.println(" range=" + lr.getRange() |
| + ", weight=" + lr.getWeight()); |
| } |
| } else { |
| for (int i = 0; i < expectedSize; i++) { |
| LanguageRange lr1 = expected.get(i); |
| LanguageRange lr2 = got.get(i); |
| |
| if (!lr1.getRange().equals(lr2.getRange()) |
| || lr1.getWeight() != lr2.getWeight()) { |
| error = true; |
| System.err.println(" " + i + ": Expected: range=" + lr1.getRange() |
| + ", weight=" + lr1.getWeight()); |
| System.err.println(" " + i + ": Actual: range=" + lr2.getRange() |
| + ", weight=" + lr2.getWeight()); |
| } |
| } |
| } |
| |
| return !error; |
| } |
| |
| private static void test_mapEquivalents() { |
| boolean error = false; |
| |
| String ranges = "zh, zh-TW;q=0.8, ar;q=0.9, EN, zh-HK, ja-JP;q=0.2, es;q=0.4"; |
| List<LanguageRange> priorityList = LanguageRange.parse(ranges); |
| HashMap<String, List<String>> map = null; |
| |
| try { |
| List<LanguageRange> list = |
| LanguageRange.mapEquivalents(priorityList, null); |
| } |
| catch (Exception ex) { |
| error = true; |
| System.err.println(ex |
| + " should not be thrown for mapEquivalents(priorityList, null)."); |
| } |
| |
| map = new HashMap<>(); |
| try { |
| List<LanguageRange> list = |
| LanguageRange.mapEquivalents(priorityList, map); |
| } |
| catch (Exception ex) { |
| error = true; |
| System.err.println(ex |
| + " should not be thrown for mapEquivalents(priorityList, empty map)."); |
| } |
| |
| ArrayList<String> equivalentList = new ArrayList<>(); |
| equivalentList.add("ja"); |
| equivalentList.add("ja-Hira"); |
| map.put("ja", equivalentList); |
| try { |
| List<LanguageRange> list = LanguageRange.mapEquivalents(null, map); |
| error = true; |
| System.err.println("NPE should be thrown for mapEquivalents(null, map)."); |
| } |
| catch (NullPointerException ex) { |
| } |
| |
| map = new LinkedHashMap<>(); |
| ArrayList<String> equivalentList1 = new ArrayList<>(); |
| equivalentList1.add("ja"); |
| equivalentList1.add("ja-Hira"); |
| map.put("ja", equivalentList1); |
| ArrayList<String> equivalentList2 = new ArrayList<>(); |
| equivalentList2.add("zh-Hans"); |
| equivalentList2.add("zh-Hans-CN"); |
| equivalentList2.add("zh-CN"); |
| map.put("zh", equivalentList2); |
| ArrayList<String> equivalentList3 = new ArrayList<>(); |
| equivalentList3.add("zh-TW"); |
| equivalentList3.add("zh-Hant"); |
| map.put("zh-TW", equivalentList3); |
| map.put("es", null); |
| ArrayList<String> equivalentList4 = new ArrayList<>(); |
| map.put("en", equivalentList4); |
| ArrayList<String> equivalentList5 = new ArrayList<>(); |
| equivalentList5.add("de"); |
| map.put("zh-HK", equivalentList5); |
| |
| ArrayList<LanguageRange> expected = new ArrayList<>(); |
| expected.add(new LanguageRange("zh-hans", 1.0)); |
| expected.add(new LanguageRange("zh-hans-cn", 1.0)); |
| expected.add(new LanguageRange("zh-cn", 1.0)); |
| expected.add(new LanguageRange("de", 1.0)); |
| expected.add(new LanguageRange("ar", 0.9)); |
| expected.add(new LanguageRange("zh-tw", 0.8)); |
| expected.add(new LanguageRange("zh-hant", 0.8)); |
| expected.add(new LanguageRange("ja-jp", 0.2)); |
| expected.add(new LanguageRange("ja-hira-jp", 0.2)); |
| List<LanguageRange> got = |
| LanguageRange.mapEquivalents(priorityList, map); |
| |
| if (!areEqual(expected, got)) { |
| error = true; |
| } |
| |
| if (error) { |
| err = true; |
| System.err.println(" test_mapEquivalents() failed."); |
| } else { |
| System.out.println(" test_mapEquivalents() passed."); |
| } |
| } |
| |
| private static void test_filter() { |
| boolean error = false; |
| |
| String ranges = "ja-JP, fr-FR"; |
| String tags = "de-DE, en, ja-JP-hepburn, fr, he, ja-Latn-JP"; |
| FilteringMode mode = EXTENDED_FILTERING; |
| |
| List<LanguageRange> priorityList = LanguageRange.parse(ranges); |
| List<Locale> tagList = generateLocales(tags); |
| String actualLocales = |
| showLocales(Locale.filter(priorityList, tagList, mode)); |
| String expectedLocales = "ja-JP-hepburn, ja-Latn-JP"; |
| |
| if (!expectedLocales.equals(actualLocales)) { |
| error = true; |
| showErrorMessage("#1 filter(" + mode + ")", |
| ranges, tags, expectedLocales, actualLocales); |
| } |
| |
| |
| ranges = "ja-*-JP, fr-FR"; |
| tags = "de-DE, en, ja-JP-hepburn, fr, he, ja-Latn-JP"; |
| mode = EXTENDED_FILTERING; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| actualLocales = showLocales(Locale.filter(priorityList, tagList, mode)); |
| expectedLocales = "ja-JP-hepburn, ja-Latn-JP"; |
| |
| if (!expectedLocales.equals(actualLocales)) { |
| error = true; |
| showErrorMessage("#2 filter(" + mode + ")", |
| ranges, tags, expectedLocales, actualLocales); |
| } |
| |
| |
| ranges = "ja-*-JP, fr-FR, de-de;q=0.2"; |
| tags = "de-DE, en, ja-JP-hepburn, de-de, fr, he, ja-Latn-JP"; |
| mode = AUTOSELECT_FILTERING; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| actualLocales = showLocales(Locale.filter(priorityList, tagList, mode)); |
| expectedLocales = "ja-JP-hepburn, ja-Latn-JP, de-DE"; |
| |
| if (!expectedLocales.equals(actualLocales)) { |
| error = true; |
| showErrorMessage("#3 filter(" + mode + ")", |
| ranges, tags,expectedLocales, actualLocales); |
| } |
| |
| ranges = "ja-JP, fr-FR, de-de;q=0.2"; |
| tags = "de-DE, en, ja-JP-hepburn, de-de, fr, he, ja-Latn-JP"; |
| mode = AUTOSELECT_FILTERING; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| actualLocales = showLocales(Locale.filter(priorityList, tagList, mode)); |
| expectedLocales = "ja-JP-hepburn, de-DE"; |
| |
| if (!expectedLocales.equals(actualLocales)) { |
| error = true; |
| showErrorMessage("#4 filter(" + mode + ")", |
| ranges, tags, expectedLocales, actualLocales); |
| } |
| |
| |
| ranges = "en;q=0.2, ja-*-JP, fr-JP"; |
| tags = "de-DE, en, ja-JP-hepburn, fr, he, ja-Latn-JP"; |
| mode = IGNORE_EXTENDED_RANGES; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| actualLocales = showLocales(Locale.filter(priorityList, tagList, mode)); |
| expectedLocales = "en"; |
| |
| if (!expectedLocales.equals(actualLocales)) { |
| error = true; |
| showErrorMessage("#5 filter(" + mode + ")", |
| ranges, tags, expectedLocales, actualLocales); |
| } |
| |
| |
| ranges = "en;q=0.2, ja-*-JP, fr-JP"; |
| tags = "de-DE, en, ja-JP-hepburn, fr, he, ja-Latn-JP"; |
| mode = MAP_EXTENDED_RANGES; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| actualLocales = showLocales(Locale.filter(priorityList, tagList, mode)); |
| expectedLocales = "ja-JP-hepburn, en"; |
| |
| if (!expectedLocales.equals(actualLocales)) { |
| error = true; |
| showErrorMessage("#6 filter(" + mode + ")", |
| ranges, tags, expectedLocales, actualLocales); |
| } |
| |
| |
| ranges = "en;q=0.2, ja-JP, fr-JP"; |
| tags = "de-DE, en, ja-JP-hepburn, fr, he, ja-Latn-JP"; |
| mode = REJECT_EXTENDED_RANGES; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| actualLocales = showLocales(Locale.filter(priorityList, tagList, mode)); |
| expectedLocales = "ja-JP-hepburn, en"; |
| |
| if (!expectedLocales.equals(actualLocales)) { |
| error = true; |
| showErrorMessage("#7 filter(" + mode + ")", |
| ranges, tags, expectedLocales, actualLocales); |
| } |
| |
| |
| ranges = "en;q=0.2, ja-*-JP, fr-JP"; |
| tags = "de-DE, en, ja-JP-hepburn, fr, he, ja-Latn-JP"; |
| mode = REJECT_EXTENDED_RANGES; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| try { |
| actualLocales = |
| showLocales(Locale.filter(priorityList, tagList, mode)); |
| error = true; |
| System.out.println("IAE should be thrown for filter(" |
| + mode + ")."); |
| } |
| catch (IllegalArgumentException ex) { |
| } |
| |
| |
| ranges = "en;q=0.2, ja-*-JP, fr-JP"; |
| tags = null; |
| mode = REJECT_EXTENDED_RANGES; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| try { |
| actualLocales = |
| showLocales(Locale.filter(priorityList, tagList, mode)); |
| error = true; |
| System.out.println("NPE should be thrown for filter(tags=null)."); |
| } |
| catch (NullPointerException ex) { |
| } |
| |
| |
| ranges = null; |
| tags = "de-DE, en, ja-JP-hepburn, fr, he, ja-Latn-JP"; |
| mode = REJECT_EXTENDED_RANGES; |
| |
| try { |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| actualLocales = |
| showLocales(Locale.filter(priorityList, tagList, mode)); |
| error = true; |
| System.out.println("NPE should be thrown for filter(ranges=null)."); |
| } |
| catch (NullPointerException ex) { |
| } |
| |
| |
| ranges = "en;q=0.2, ja-*-JP, fr-JP"; |
| tags = ""; |
| mode = REJECT_EXTENDED_RANGES; |
| |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLocales(tags); |
| try { |
| actualLocales = |
| showLocales(Locale.filter(priorityList, tagList, mode)); |
| } |
| catch (Exception ex) { |
| error = true; |
| System.out.println(ex |
| + " should not be thrown for filter(" + ranges + ", \"\")."); |
| } |
| |
| |
| if (error) { |
| err = true; |
| System.out.println(" test_filter() failed."); |
| } else { |
| System.out.println(" test_filter() passed."); |
| } |
| } |
| |
| private static void test_filterTags() { |
| boolean error = false; |
| |
| String ranges = "en;q=0.2, *;q=0.6, ja"; |
| String tags = "de-DE, en, ja-JP-hepburn, fr-JP, he"; |
| |
| List<LanguageRange> priorityList = LanguageRange.parse(ranges); |
| List<String> tagList = generateLanguageTags(tags); |
| String actualTags = |
| showLanguageTags(Locale.filterTags(priorityList, tagList)); |
| String expectedTags = tags; |
| |
| if (!expectedTags.equals(actualTags)) { |
| error = true; |
| showErrorMessage("#1 filterTags()", |
| ranges, tags, expectedTags, actualTags); |
| } |
| |
| |
| ranges = "en;q=0.2, ja-JP, fr-JP"; |
| tags = "de-DE, en, ja-JP-hepburn, fr, he"; |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLanguageTags(tags); |
| actualTags = showLanguageTags(Locale.filterTags(priorityList, tagList)); |
| expectedTags = "ja-jp-hepburn, en"; |
| |
| if (!expectedTags.equals(actualTags)) { |
| error = true; |
| showErrorMessage("#2 filterTags()", |
| ranges, tags, expectedTags, actualTags); |
| } |
| |
| |
| ranges = "de-DE"; |
| tags = "de-DE, de-de, de-Latn-DE, de-Latf-DE, de-DE-x-goethe, " |
| + "de-Latn-DE-1996, de-Deva-DE, de, de-x-DE, de-Deva"; |
| FilteringMode mode = MAP_EXTENDED_RANGES; |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLanguageTags(tags); |
| actualTags = showLanguageTags(Locale.filterTags(priorityList, tagList, mode)); |
| expectedTags = "de-de, de-de-x-goethe"; |
| |
| if (!expectedTags.equals(actualTags)) { |
| error = true; |
| showErrorMessage("#3 filterTags(" + mode + ")", |
| ranges, tags, expectedTags, actualTags); |
| } |
| |
| |
| ranges = "de-DE"; |
| tags = "de-DE, de-de, de-Latn-DE, de-Latf-DE, de-DE-x-goethe, " |
| + "de-Latn-DE-1996, de-Deva-DE, de, de-x-DE, de-Deva"; |
| mode = EXTENDED_FILTERING; |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLanguageTags(tags); |
| actualTags = showLanguageTags(Locale.filterTags(priorityList, tagList, mode)); |
| expectedTags = "de-de, de-latn-de, de-latf-de, de-de-x-goethe, " |
| + "de-latn-de-1996, de-deva-de"; |
| |
| if (!expectedTags.equals(actualTags)) { |
| error = true; |
| showErrorMessage("#4 filterTags(" + mode + ")", |
| ranges, tags, expectedTags, actualTags); |
| } |
| |
| |
| ranges = "de-*-DE"; |
| tags = "de-DE, de-de, de-Latn-DE, de-Latf-DE, de-DE-x-goethe, " |
| + "de-Latn-DE-1996, de-Deva-DE, de, de-x-DE, de-Deva"; |
| mode = EXTENDED_FILTERING; |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLanguageTags(tags); |
| actualTags = showLanguageTags(Locale.filterTags(priorityList, tagList, mode)); |
| expectedTags = "de-de, de-latn-de, de-latf-de, de-de-x-goethe, " |
| + "de-latn-de-1996, de-deva-de"; |
| |
| if (!expectedTags.equals(actualTags)) { |
| error = true; |
| showErrorMessage("#5 filterTags(" + mode + ")", |
| ranges, tags, expectedTags, actualTags); |
| } |
| |
| if (error) { |
| err = true; |
| System.out.println(" test_filterTags() failed."); |
| } else { |
| System.out.println(" test_filterTags() passed."); |
| } |
| } |
| |
| private static void test_lookup() { |
| boolean error = false; |
| |
| String ranges = "en;q=0.2, *-JP;q=0.6, iw"; |
| String tags = "de-DE, en, ja-JP-hepburn, fr-JP, he"; |
| List<LanguageRange> priorityList = LanguageRange.parse(ranges); |
| List<Locale> localeList = generateLocales(tags); |
| String actualLocale = |
| Locale.lookup(priorityList, localeList).toLanguageTag(); |
| String expectedLocale ="he"; |
| |
| if (!expectedLocale.equals(actualLocale)) { |
| error = true; |
| showErrorMessage("#1 lookup()", ranges, tags, expectedLocale, actualLocale); |
| } |
| |
| |
| ranges = "en;q=0.2, *-JP;q=0.6, iw"; |
| tags = "de-DE, he-IL, en, iw"; |
| priorityList = LanguageRange.parse(ranges); |
| localeList = generateLocales(tags); |
| actualLocale = Locale.lookup(priorityList, localeList).toLanguageTag(); |
| expectedLocale = "he"; |
| |
| if (!expectedLocale.equals(actualLocale)) { |
| error = true; |
| showErrorMessage("#2 lookup()", ranges, tags, expectedLocale, actualLocale); |
| } |
| |
| |
| ranges = "en;q=0.2, ja-*-JP-x-foo;q=0.6, iw"; |
| tags = "de-DE, fr, en, ja-Latn-JP"; |
| priorityList = LanguageRange.parse(ranges); |
| localeList = generateLocales(tags); |
| actualLocale = Locale.lookup(priorityList, localeList).toLanguageTag(); |
| expectedLocale = "ja-Latn-JP"; |
| |
| if (!expectedLocale.equals(actualLocale)) { |
| error = true; |
| showErrorMessage("#3 lookup()", ranges, tags, expectedLocale, actualLocale); |
| } |
| |
| if (error) { |
| err = true; |
| System.out.println(" test_lookup() failed."); |
| } else { |
| System.out.println(" test_lookup() passed."); |
| } |
| } |
| |
| private static void test_lookupTag() { |
| boolean error = false; |
| |
| String ranges = "en, *"; |
| String tags = "es, de, ja-JP"; |
| List<LanguageRange> priorityList = LanguageRange.parse(ranges); |
| List<String> tagList = generateLanguageTags(tags); |
| String actualTag = Locale.lookupTag(priorityList, tagList); |
| String expectedTag = null; |
| |
| if (actualTag != null) { |
| error = true; |
| showErrorMessage("#1 lookupTag()", ranges, tags, expectedTag, actualTag); |
| } |
| |
| |
| ranges= "en;q=0.2, *-JP"; |
| tags = "de-DE, en, ja-JP-hepburn, fr-JP, en-JP"; |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLanguageTags(tags); |
| actualTag = Locale.lookupTag(priorityList, tagList); |
| expectedTag = "fr-jp"; |
| |
| if (!expectedTag.equals(actualTag)) { |
| error = true; |
| showErrorMessage("#2 lookupTag()", ranges, tags, expectedTag, actualTag); |
| } |
| |
| |
| ranges = "en;q=0.2, ar-MO, iw"; |
| tags = "de-DE, he, fr-JP"; |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLanguageTags(tags); |
| actualTag = Locale.lookupTag(priorityList, tagList); |
| expectedTag = "he"; |
| |
| if (!expectedTag.equals(actualTag)) { |
| error = true; |
| showErrorMessage("#3 lookupTag()", ranges, tags, expectedTag, actualTag); |
| } |
| |
| |
| ranges = "en;q=0.2, ar-MO, he"; |
| tags = "de-DE, iw, fr-JP"; |
| priorityList = LanguageRange.parse(ranges); |
| tagList = generateLanguageTags(tags); |
| actualTag = Locale.lookupTag(priorityList, tagList); |
| expectedTag = "iw"; |
| |
| if (!expectedTag.equals(actualTag)) { |
| error = true; |
| showErrorMessage("#4 lookupTag()", ranges, tags, expectedTag, actualTag); |
| } |
| |
| if (error) { |
| err = true; |
| System.out.println(" test_lookupTag() failed."); |
| } else { |
| System.out.println(" test_lookupTag() passed."); |
| } |
| } |
| |
| private static List<Locale> generateLocales(String tags) { |
| if (tags == null) { |
| return null; |
| } |
| |
| List<Locale> localeList = new ArrayList<>(); |
| if (tags.equals("")) { |
| return localeList; |
| } |
| String[] t = tags.split(", "); |
| for (String tag : t) { |
| localeList.add(Locale.forLanguageTag(tag)); |
| } |
| return localeList; |
| } |
| |
| private static List<String> generateLanguageTags(String tags) { |
| List<String> tagList = new ArrayList<>(); |
| String[] t = tags.split(", "); |
| for (String tag : t) { |
| tagList.add(tag); |
| } |
| return tagList; |
| } |
| |
| private static String showPriorityList(List<LanguageRange> priorityList) { |
| StringBuilder sb = new StringBuilder(); |
| |
| Iterator<LanguageRange> itr = priorityList.iterator(); |
| LanguageRange lr; |
| if (itr.hasNext()) { |
| lr = itr.next(); |
| sb.append(lr.getRange()); |
| sb.append(";q="); |
| sb.append(lr.getWeight()); |
| } |
| while (itr.hasNext()) { |
| sb.append(", "); |
| lr = itr.next(); |
| sb.append(lr.getRange()); |
| sb.append(";q="); |
| sb.append(lr.getWeight()); |
| } |
| |
| return sb.toString(); |
| } |
| |
| private static String showLanguageTags(List<String> tags) { |
| StringBuilder sb = new StringBuilder(); |
| |
| Iterator<String> itr = tags.iterator(); |
| if (itr.hasNext()) { |
| sb.append(itr.next()); |
| } |
| while (itr.hasNext()) { |
| sb.append(", "); |
| sb.append(itr.next()); |
| } |
| |
| return sb.toString().trim(); |
| } |
| |
| private static String showLocales(List<Locale> locales) { |
| StringBuilder sb = new StringBuilder(); |
| |
| Iterator<Locale> itr = locales.iterator(); |
| if (itr.hasNext()) { |
| sb.append(itr.next().toLanguageTag()); |
| } |
| while (itr.hasNext()) { |
| sb.append(", "); |
| sb.append(itr.next().toLanguageTag()); |
| } |
| |
| return sb.toString().trim(); |
| } |
| |
| private static void showErrorMessage(String methodName, |
| String priorityList, |
| String tags, |
| String expectedTags, |
| String actualTags) { |
| System.out.println("\nIncorrect " + methodName + " result."); |
| System.out.println(" Priority list : " + priorityList); |
| System.out.println(" Language tags : " + tags); |
| System.out.println(" Expected value : " + expectedTags); |
| System.out.println(" Actual value : " + actualTags); |
| } |
| |
| } |
