| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.commons.lang; |
| |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Modifier; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Set; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Unit tests for {@link LocaleUtils}. |
| * |
| * @author Apache Software Foundation |
| * @author Chris Hyzer |
| * @version $Id$ |
| */ |
| public class LocaleUtilsTest extends TestCase { |
| |
| private static final Locale LOCALE_EN = new Locale("en", ""); |
| private static final Locale LOCALE_EN_US = new Locale("en", "US"); |
| private static final Locale LOCALE_EN_US_ZZZZ = new Locale("en", "US", "ZZZZ"); |
| private static final Locale LOCALE_FR = new Locale("fr", ""); |
| private static final Locale LOCALE_FR_CA = new Locale("fr", "CA"); |
| private static final Locale LOCALE_QQ = new Locale("qq", ""); |
| private static final Locale LOCALE_QQ_ZZ = new Locale("qq", "ZZ"); |
| |
| /** |
| * Constructor. |
| * |
| * @param name |
| */ |
| public LocaleUtilsTest(String name) { |
| super(name); |
| } |
| |
| |
| public void setUp() throws Exception { |
| super.setUp(); |
| |
| // Testing #LANG-304. Must be called before availableLocaleSet is called. |
| LocaleUtils.isAvailableLocale(Locale.getDefault()); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Test that constructors are public, and work, etc. |
| */ |
| public void testConstructor() { |
| assertNotNull(new LocaleUtils()); |
| Constructor[] cons = LocaleUtils.class.getDeclaredConstructors(); |
| assertEquals(1, cons.length); |
| assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); |
| assertEquals(true, Modifier.isPublic(LocaleUtils.class.getModifiers())); |
| assertEquals(false, Modifier.isFinal(LocaleUtils.class.getModifiers())); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Pass in a valid language, test toLocale. |
| * |
| * @param language the language string |
| */ |
| private void assertValidToLocale(String language) { |
| Locale locale = LocaleUtils.toLocale(language); |
| assertNotNull("valid locale", locale); |
| assertEquals(language, locale.getLanguage()); |
| //country and variant are empty |
| assertTrue(locale.getCountry() == null || locale.getCountry().length() == 0); |
| assertTrue(locale.getVariant() == null || locale.getVariant().length() == 0); |
| } |
| |
| /** |
| * Pass in a valid language, test toLocale. |
| * |
| * @param localeString to pass to toLocale() |
| * @param language of the resulting Locale |
| * @param country of the resulting Locale |
| */ |
| private void assertValidToLocale(String localeString, String language, String country) { |
| Locale locale = LocaleUtils.toLocale(localeString); |
| assertNotNull("valid locale", locale); |
| assertEquals(language, locale.getLanguage()); |
| assertEquals(country, locale.getCountry()); |
| //variant is empty |
| assertTrue(locale.getVariant() == null || locale.getVariant().length() == 0); |
| } |
| |
| /** |
| * Pass in a valid language, test toLocale. |
| * |
| * @param localeString to pass to toLocale() |
| * @param language of the resulting Locale |
| * @param country of the resulting Locale |
| * @param variant of the resulting Locale |
| */ |
| private void assertValidToLocale( |
| String localeString, String language, |
| String country, String variant) { |
| Locale locale = LocaleUtils.toLocale(localeString); |
| assertNotNull("valid locale", locale); |
| assertEquals(language, locale.getLanguage()); |
| assertEquals(country, locale.getCountry()); |
| assertEquals(variant, locale.getVariant()); |
| |
| } |
| |
| /** |
| * Test toLocale() method. |
| */ |
| public void testToLocale_1Part() { |
| assertEquals(null, LocaleUtils.toLocale((String) null)); |
| |
| assertValidToLocale("us"); |
| assertValidToLocale("fr"); |
| assertValidToLocale("de"); |
| assertValidToLocale("zh"); |
| // Valid format but lang doesnt exist, should make instance anyway |
| assertValidToLocale("qq"); |
| |
| try { |
| LocaleUtils.toLocale("Us"); |
| fail("Should fail if not lowercase"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("US"); |
| fail("Should fail if not lowercase"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("uS"); |
| fail("Should fail if not lowercase"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("u#"); |
| fail("Should fail if not lowercase"); |
| } catch (IllegalArgumentException iae) {} |
| |
| try { |
| LocaleUtils.toLocale("u"); |
| fail("Must be 2 chars if less than 5"); |
| } catch (IllegalArgumentException iae) {} |
| |
| try { |
| LocaleUtils.toLocale("uuu"); |
| fail("Must be 2 chars if less than 5"); |
| } catch (IllegalArgumentException iae) {} |
| |
| try { |
| LocaleUtils.toLocale("uu_U"); |
| fail("Must be 2 chars if less than 5"); |
| } catch (IllegalArgumentException iae) {} |
| } |
| |
| /** |
| * Test toLocale() method. |
| */ |
| public void testToLocale_2Part() { |
| assertValidToLocale("us_EN", "us", "EN"); |
| //valid though doesnt exist |
| assertValidToLocale("us_ZH", "us", "ZH"); |
| |
| try { |
| LocaleUtils.toLocale("us-EN"); |
| fail("Should fail as not underscore"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("us_En"); |
| fail("Should fail second part not uppercase"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("us_en"); |
| fail("Should fail second part not uppercase"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("us_eN"); |
| fail("Should fail second part not uppercase"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("uS_EN"); |
| fail("Should fail first part not lowercase"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("us_E3"); |
| fail("Should fail second part not uppercase"); |
| } catch (IllegalArgumentException iae) {} |
| } |
| |
| /** |
| * Test toLocale() method. |
| */ |
| public void testToLocale_3Part() { |
| assertValidToLocale("us_EN_A", "us", "EN", "A"); |
| // this isn't pretty, but was caused by a jdk bug it seems |
| // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4210525 |
| if (SystemUtils.isJavaVersionAtLeast(1.4f)) { |
| assertValidToLocale("us_EN_a", "us", "EN", "a"); |
| assertValidToLocale("us_EN_SFsafdFDsdfF", "us", "EN", "SFsafdFDsdfF"); |
| } else { |
| assertValidToLocale("us_EN_a", "us", "EN", "A"); |
| assertValidToLocale("us_EN_SFsafdFDsdfF", "us", "EN", "SFSAFDFDSDFF"); |
| } |
| |
| try { |
| LocaleUtils.toLocale("us_EN-a"); |
| fail("Should fail as not underscore"); |
| } catch (IllegalArgumentException iae) {} |
| try { |
| LocaleUtils.toLocale("uu_UU_"); |
| fail("Must be 3, 5 or 7+ in length"); |
| } catch (IllegalArgumentException iae) {} |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Helper method for local lookups. |
| * |
| * @param locale the input locale |
| * @param defaultLocale the input default locale |
| * @param expected expected results |
| */ |
| private void assertLocaleLookupList(Locale locale, Locale defaultLocale, Locale[] expected) { |
| List localeList = defaultLocale == null ? |
| LocaleUtils.localeLookupList(locale) : |
| LocaleUtils.localeLookupList(locale, defaultLocale); |
| |
| assertEquals(expected.length, localeList.size()); |
| assertEquals(Arrays.asList(expected), localeList); |
| assertUnmodifiableCollection(localeList); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Test localeLookupList() method. |
| */ |
| public void testLocaleLookupList_Locale() { |
| assertLocaleLookupList(null, null, new Locale[0]); |
| assertLocaleLookupList(LOCALE_QQ, null, new Locale[]{LOCALE_QQ}); |
| assertLocaleLookupList(LOCALE_EN, null, new Locale[]{LOCALE_EN}); |
| assertLocaleLookupList(LOCALE_EN, null, new Locale[]{LOCALE_EN}); |
| assertLocaleLookupList(LOCALE_EN_US, null, |
| new Locale[] { |
| LOCALE_EN_US, |
| LOCALE_EN}); |
| assertLocaleLookupList(LOCALE_EN_US_ZZZZ, null, |
| new Locale[] { |
| LOCALE_EN_US_ZZZZ, |
| LOCALE_EN_US, |
| LOCALE_EN}); |
| } |
| |
| /** |
| * Test localeLookupList() method. |
| */ |
| public void testLocaleLookupList_LocaleLocale() { |
| assertLocaleLookupList(LOCALE_QQ, LOCALE_QQ, |
| new Locale[]{LOCALE_QQ}); |
| assertLocaleLookupList(LOCALE_EN, LOCALE_EN, |
| new Locale[]{LOCALE_EN}); |
| |
| assertLocaleLookupList(LOCALE_EN_US, LOCALE_EN_US, |
| new Locale[]{ |
| LOCALE_EN_US, |
| LOCALE_EN}); |
| assertLocaleLookupList(LOCALE_EN_US, LOCALE_QQ, |
| new Locale[] { |
| LOCALE_EN_US, |
| LOCALE_EN, |
| LOCALE_QQ}); |
| assertLocaleLookupList(LOCALE_EN_US, LOCALE_QQ_ZZ, |
| new Locale[] { |
| LOCALE_EN_US, |
| LOCALE_EN, |
| LOCALE_QQ_ZZ}); |
| |
| assertLocaleLookupList(LOCALE_EN_US_ZZZZ, null, |
| new Locale[] { |
| LOCALE_EN_US_ZZZZ, |
| LOCALE_EN_US, |
| LOCALE_EN}); |
| assertLocaleLookupList(LOCALE_EN_US_ZZZZ, LOCALE_EN_US_ZZZZ, |
| new Locale[] { |
| LOCALE_EN_US_ZZZZ, |
| LOCALE_EN_US, |
| LOCALE_EN}); |
| assertLocaleLookupList(LOCALE_EN_US_ZZZZ, LOCALE_QQ, |
| new Locale[] { |
| LOCALE_EN_US_ZZZZ, |
| LOCALE_EN_US, |
| LOCALE_EN, |
| LOCALE_QQ}); |
| assertLocaleLookupList(LOCALE_EN_US_ZZZZ, LOCALE_QQ_ZZ, |
| new Locale[] { |
| LOCALE_EN_US_ZZZZ, |
| LOCALE_EN_US, |
| LOCALE_EN, |
| LOCALE_QQ_ZZ}); |
| assertLocaleLookupList(LOCALE_FR_CA, LOCALE_EN, |
| new Locale[] { |
| LOCALE_FR_CA, |
| LOCALE_FR, |
| LOCALE_EN}); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Test availableLocaleList() method. |
| */ |
| public void testAvailableLocaleList() { |
| List list = LocaleUtils.availableLocaleList(); |
| List list2 = LocaleUtils.availableLocaleList(); |
| assertNotNull(list); |
| assertSame(list, list2); |
| assertUnmodifiableCollection(list); |
| |
| Locale[] jdkLocaleArray = Locale.getAvailableLocales(); |
| List jdkLocaleList = Arrays.asList(jdkLocaleArray); |
| assertEquals(jdkLocaleList, list); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Test availableLocaleSet() method. |
| */ |
| public void testAvailableLocaleSet() { |
| Set set = LocaleUtils.availableLocaleSet(); |
| Set set2 = LocaleUtils.availableLocaleSet(); |
| assertNotNull(set); |
| assertSame(set, set2); |
| assertUnmodifiableCollection(set); |
| |
| Locale[] jdkLocaleArray = Locale.getAvailableLocales(); |
| List jdkLocaleList = Arrays.asList(jdkLocaleArray); |
| Set jdkLocaleSet = new HashSet(jdkLocaleList); |
| assertEquals(jdkLocaleSet, set); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Test availableLocaleSet() method. |
| */ |
| public void testIsAvailableLocale() { |
| Set set = LocaleUtils.availableLocaleSet(); |
| assertEquals(set.contains(LOCALE_EN), LocaleUtils.isAvailableLocale(LOCALE_EN)); |
| assertEquals(set.contains(LOCALE_EN_US), LocaleUtils.isAvailableLocale(LOCALE_EN_US)); |
| assertEquals(set.contains(LOCALE_EN_US_ZZZZ), LocaleUtils.isAvailableLocale(LOCALE_EN_US_ZZZZ)); |
| assertEquals(set.contains(LOCALE_FR), LocaleUtils.isAvailableLocale(LOCALE_FR)); |
| assertEquals(set.contains(LOCALE_FR_CA), LocaleUtils.isAvailableLocale(LOCALE_FR_CA)); |
| assertEquals(set.contains(LOCALE_QQ), LocaleUtils.isAvailableLocale(LOCALE_QQ)); |
| assertEquals(set.contains(LOCALE_QQ_ZZ), LocaleUtils.isAvailableLocale(LOCALE_QQ_ZZ)); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Make sure the language by country is correct. It checks that |
| * the LocaleUtils.languagesByCountry(country) call contains the |
| * array of languages passed in. It may contain more due to JVM |
| * variations. |
| * |
| * @param country |
| * @param languages array of languages that should be returned |
| */ |
| private void assertLanguageByCountry(String country, String[] languages) { |
| List list = LocaleUtils.languagesByCountry(country); |
| List list2 = LocaleUtils.languagesByCountry(country); |
| assertNotNull(list); |
| assertSame(list, list2); |
| //search through langauges |
| for (int i = 0; i < languages.length; i++) { |
| Iterator iterator = list.iterator(); |
| boolean found = false; |
| // see if it was returned by the set |
| while (iterator.hasNext()) { |
| Locale locale = (Locale) iterator.next(); |
| // should have an en empty variant |
| assertTrue(locale.getVariant() == null |
| || locale.getVariant().length() == 0); |
| assertEquals(country, locale.getCountry()); |
| if (languages[i].equals(locale.getLanguage())) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| fail("Cound not find language: " + languages[i] |
| + " for country: " + country); |
| } |
| } |
| assertUnmodifiableCollection(list); |
| } |
| |
| /** |
| * Test languagesByCountry() method. |
| */ |
| public void testLanguagesByCountry() { |
| assertLanguageByCountry(null, new String[0]); |
| assertLanguageByCountry("GB", new String[]{"en"}); |
| assertLanguageByCountry("ZZ", new String[0]); |
| assertLanguageByCountry("CH", new String[]{"fr", "de", "it"}); |
| } |
| |
| //----------------------------------------------------------------------- |
| /** |
| * Make sure the country by language is correct. It checks that |
| * the LocaleUtils.countryByLanguage(language) call contains the |
| * array of countries passed in. It may contain more due to JVM |
| * variations. |
| * |
| * |
| * @param language |
| * @param countries array of countries that should be returned |
| */ |
| private void assertCountriesByLanguage(String language, String[] countries) { |
| List list = LocaleUtils.countriesByLanguage(language); |
| List list2 = LocaleUtils.countriesByLanguage(language); |
| assertNotNull(list); |
| assertSame(list, list2); |
| //search through langauges |
| for (int i = 0; i < countries.length; i++) { |
| Iterator iterator = list.iterator(); |
| boolean found = false; |
| // see if it was returned by the set |
| while (iterator.hasNext()) { |
| Locale locale = (Locale) iterator.next(); |
| // should have an en empty variant |
| assertTrue(locale.getVariant() == null |
| || locale.getVariant().length() == 0); |
| assertEquals(language, locale.getLanguage()); |
| if (countries[i].equals(locale.getCountry())) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| fail("Cound not find language: " + countries[i] |
| + " for country: " + language); |
| } |
| } |
| assertUnmodifiableCollection(list); |
| } |
| |
| /** |
| * Test countriesByLanguage() method. |
| */ |
| public void testCountriesByLanguage() { |
| assertCountriesByLanguage(null, new String[0]); |
| assertCountriesByLanguage("de", new String[]{"DE", "CH", "AT", "LU"}); |
| assertCountriesByLanguage("zz", new String[0]); |
| assertCountriesByLanguage("it", new String[]{"IT", "CH"}); |
| } |
| |
| /** |
| * @param coll the collection to check |
| */ |
| private static void assertUnmodifiableCollection(Collection coll) { |
| try { |
| coll.add("Unmodifiable"); |
| fail(); |
| } catch (UnsupportedOperationException ex) {} |
| } |
| |
| /** |
| * Tests #LANG-328 - only language+variant |
| */ |
| public void testLang328() { |
| assertValidToLocale("fr__POSIX", "fr", "", "POSIX"); |
| } |
| |
| } |
