Home | History | Annotate | Download | only in cts 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.os.cts;
     18 
     19 import android.os.LocaleList;
     20 import android.os.Parcel;
     21 import android.test.AndroidTestCase;
     22 
     23 import java.util.Locale;
     24 
     25 public class LocaleListTest extends AndroidTestCase {
     26     public void testEmptyLocaleList() {
     27         LocaleList ll = new LocaleList();
     28         assertNotNull(ll);
     29         assertTrue(ll.isEmpty());
     30         assertEquals(0, ll.size());
     31         assertNull(ll.get(0));
     32         assertNull(ll.get(1));
     33         assertNull(ll.get(10));
     34 
     35         ll = new LocaleList(new Locale[0]);
     36         assertNotNull(ll);
     37         assertTrue(ll.isEmpty());
     38         assertEquals(0, ll.size());
     39         assertNull(ll.get(0));
     40         assertNull(ll.get(1));
     41         assertNull(ll.get(10));
     42     }
     43 
     44     public void testOneMemberLocaleList() {
     45         final LocaleList ll = new LocaleList(Locale.US);
     46         assertNotNull(ll);
     47         assertFalse(ll.isEmpty());
     48         assertEquals(1, ll.size());
     49         assertEquals(Locale.US, ll.get(0));
     50         assertNull(ll.get(10));
     51     }
     52 
     53     public void testTwoMemberLocaleList() {
     54         final Locale enPH = Locale.forLanguageTag("en-PH");
     55         final Locale[] la = {enPH, Locale.US};
     56         final LocaleList ll = new LocaleList(la);
     57         assertNotNull(ll);
     58         assertFalse(ll.isEmpty());
     59         assertEquals(2, ll.size());
     60         assertEquals(enPH, ll.get(0));
     61         assertEquals(Locale.US, ll.get(1));
     62         assertNull(ll.get(10));
     63     }
     64 
     65     public void testNullArgument() {
     66         try {
     67             LocaleList ll = new LocaleList((Locale) null);
     68             fail("Initializing a LocaleList with a null argument should throw.");
     69         } catch (Throwable e) {
     70             assertEquals(NullPointerException.class, e.getClass());
     71         }
     72         try {
     73             LocaleList ll = new LocaleList((Locale[]) null);
     74             fail("Initializing a LocaleList with a null array should throw.");
     75         } catch (Throwable e) {
     76             assertEquals(NullPointerException.class, e.getClass());
     77         }
     78     }
     79 
     80     public void testNullArguments() {
     81         final Locale[] la = {Locale.US, null};
     82         LocaleList ll = null;
     83         try {
     84             ll = new LocaleList(la);
     85             fail("Initializing a LocaleList with an array containing null should throw.");
     86         } catch (Throwable e) {
     87             assertEquals(NullPointerException.class, e.getClass());
     88         }
     89     }
     90 
     91     public void testRepeatedArguments() {
     92         final Locale[] la = {Locale.US, Locale.US};
     93         LocaleList ll = null;
     94         try {
     95             ll = new LocaleList(la);
     96             fail("Initializing a LocaleList with an array containing duplicates should throw.");
     97         } catch (Throwable e) {
     98             assertEquals(IllegalArgumentException.class, e.getClass());
     99         }
    100     }
    101 
    102     public void testIndexOf() {
    103         final LocaleList empty = new LocaleList();
    104         assertEquals(-1, empty.indexOf(Locale.US));
    105 
    106         final LocaleList oneMember = new LocaleList(Locale.US);
    107         assertEquals(0, oneMember.indexOf(Locale.US));
    108         assertEquals(-1, oneMember.indexOf(Locale.ENGLISH));
    109 
    110         final LocaleList twoMember = LocaleList.forLanguageTags("en,fr");
    111         assertEquals(0, twoMember.indexOf(Locale.forLanguageTag("en")));
    112         assertEquals(1, twoMember.indexOf(Locale.forLanguageTag("fr")));
    113         assertEquals(-1, twoMember.indexOf(Locale.forLanguageTag("en-US")));
    114     }
    115 
    116     public void testEquals() {
    117         final LocaleList empty = new LocaleList();
    118         final LocaleList anotherEmpty = new LocaleList();
    119         LocaleList oneMember = new LocaleList(Locale.US);
    120         LocaleList sameOneMember = new LocaleList(new Locale("en", "US"));
    121         LocaleList differentOneMember = new LocaleList(Locale.FRENCH);
    122         Locale[] la = {Locale.US, Locale.FRENCH};
    123         LocaleList twoMember = new LocaleList(la);
    124 
    125         assertFalse(empty.equals(null));
    126         assertFalse(oneMember.equals(null));
    127 
    128         assertFalse(empty.equals(new Object()));
    129 
    130         assertTrue(empty.equals(empty));
    131         assertTrue(oneMember.equals(oneMember));
    132 
    133         assertFalse(empty.equals(oneMember));
    134         assertFalse(oneMember.equals(twoMember));
    135 
    136         assertFalse(oneMember.equals(differentOneMember));
    137 
    138         assertTrue(empty.equals(anotherEmpty));
    139         assertTrue(oneMember.equals(sameOneMember));
    140     }
    141 
    142     public void testHashCode() {
    143         final LocaleList empty = new LocaleList();
    144         final LocaleList anotherEmpty = new LocaleList();
    145         Locale[] la1 = {Locale.US};
    146         LocaleList oneMember = new LocaleList(la1);
    147         LocaleList sameOneMember = new LocaleList(la1);
    148 
    149         assertEquals(empty.hashCode(), anotherEmpty.hashCode());
    150         assertEquals(oneMember.hashCode(), sameOneMember.hashCode());
    151     }
    152 
    153     public void testToString() {
    154         LocaleList ll = new LocaleList();
    155         assertEquals("[]", ll.toString());
    156 
    157         final Locale[] la1 = {Locale.US};
    158         ll = new LocaleList(la1);
    159         assertEquals("["+Locale.US.toString()+"]", ll.toString());
    160 
    161         final Locale[] la2 = {Locale.US, Locale.FRENCH};
    162         ll = new LocaleList(la2);
    163         assertEquals("["+Locale.US.toString()+","+Locale.FRENCH.toString()+"]", ll.toString());
    164     }
    165 
    166     public void testToLanguageTags() {
    167         LocaleList ll = new LocaleList();
    168         assertEquals("", ll.toLanguageTags());
    169 
    170         final Locale[] la1 = {Locale.US};
    171         ll = new LocaleList(la1);
    172         assertEquals(Locale.US.toLanguageTag(), ll.toLanguageTags());
    173 
    174         final Locale[] la2 = {Locale.US, Locale.FRENCH};
    175         ll = new LocaleList(la2);
    176         assertEquals(Locale.US.toLanguageTag()+","+Locale.FRENCH.toLanguageTag(),
    177                 ll.toLanguageTags());
    178     }
    179 
    180     public void testGetEmptyLocaleList() {
    181         LocaleList empty = LocaleList.getEmptyLocaleList();
    182         LocaleList anotherEmpty = LocaleList.getEmptyLocaleList();
    183         LocaleList constructedEmpty = new LocaleList();
    184 
    185         assertEquals(constructedEmpty, empty);
    186         assertSame(empty, anotherEmpty);
    187     }
    188 
    189     public void testForLanguageTags() {
    190         assertEquals(LocaleList.getEmptyLocaleList(), LocaleList.forLanguageTags(null));
    191         assertEquals(LocaleList.getEmptyLocaleList(), LocaleList.forLanguageTags(""));
    192 
    193         assertEquals(new LocaleList(Locale.forLanguageTag("en-US")),
    194                 LocaleList.forLanguageTags("en-US"));
    195 
    196         final Locale[] la = {Locale.forLanguageTag("en-PH"), Locale.forLanguageTag("en-US")};
    197         assertEquals(new LocaleList(la), LocaleList.forLanguageTags("en-PH,en-US"));
    198     }
    199 
    200     public void testGetDefault() {
    201         final LocaleList ll = LocaleList.getDefault();
    202         assertNotNull(ll);
    203         assertTrue(ll.size() >= 1);
    204 
    205         final Locale defaultLocale = Locale.getDefault();
    206         assertTrue(ll.indexOf(defaultLocale) != -1);
    207     }
    208 
    209     public void testGetAdjustedDefault() {
    210         final LocaleList ll = LocaleList.getDefault();
    211         assertNotNull(ll);
    212         assertTrue(ll.size() >= 1);
    213 
    214         final Locale defaultLocale = Locale.getDefault();
    215         assertTrue(ll.indexOf(defaultLocale) == 0);
    216     }
    217 
    218     public void testGetDefault_localeSetDefaultCalled() {
    219         final Locale originalLocale = Locale.getDefault();
    220         final LocaleList originalLocaleList = LocaleList.getDefault();
    221 
    222         LocaleList.setDefault(LocaleList.forLanguageTags("ae,en,ja"));
    223 
    224         try {
    225             Locale.setDefault(Locale.forLanguageTag("fr"));
    226             assertEquals("fr,ae,en,ja", LocaleList.getDefault().toLanguageTags());
    227             assertEquals("fr,ae,en,ja", LocaleList.getAdjustedDefault().toLanguageTags());
    228 
    229             Locale.setDefault(Locale.forLanguageTag("de"));
    230             assertEquals("de,ae,en,ja", LocaleList.getDefault().toLanguageTags());
    231             assertEquals("de,ae,en,ja", LocaleList.getAdjustedDefault().toLanguageTags());
    232 
    233             Locale.setDefault(Locale.forLanguageTag("en"));
    234             assertEquals("en,ae,ja", LocaleList.getDefault().toLanguageTags());
    235             assertEquals("en,ae,ja", LocaleList.getAdjustedDefault().toLanguageTags());
    236 
    237             Locale.setDefault(Locale.forLanguageTag("es"));
    238             assertEquals("es,ae,en,ja", LocaleList.getDefault().toLanguageTags());
    239             assertEquals("es,ae,en,ja", LocaleList.getAdjustedDefault().toLanguageTags());
    240 
    241             Locale.setDefault(Locale.forLanguageTag("ja"));
    242             assertEquals("ja,ae,en", LocaleList.getDefault().toLanguageTags());
    243             assertEquals("ja,ae,en", LocaleList.getAdjustedDefault().toLanguageTags());
    244 
    245             Locale.setDefault(Locale.forLanguageTag("ae"));
    246             assertEquals("ae,en,ja", LocaleList.getDefault().toLanguageTags());
    247             assertEquals("ae,en,ja", LocaleList.getAdjustedDefault().toLanguageTags());
    248         } finally {
    249             // restore the original values
    250             LocaleList.setDefault(originalLocaleList, originalLocaleList.indexOf(originalLocale));
    251         }
    252     }
    253 
    254     public void testSetDefault_null() {
    255         try {
    256             LocaleList.setDefault(null);
    257             fail("Setting the default locale list to null should throw.");
    258         } catch (Throwable e) {
    259             assertEquals(NullPointerException.class, e.getClass());
    260         }
    261     }
    262 
    263     public void testSetDefault_empty() {
    264         try {
    265             LocaleList.setDefault(LocaleList.getEmptyLocaleList());
    266             fail("Setting the default locale list to an empty list should throw.");
    267         } catch (Throwable e) {
    268             assertEquals(IllegalArgumentException.class, e.getClass());
    269         }
    270     }
    271 
    272     public void testSetDefault_oneLocale() {
    273         final Locale originalLocale = Locale.getDefault();
    274         final LocaleList originalLocaleList = LocaleList.getDefault();
    275 
    276         final LocaleList locales = LocaleList.forLanguageTags("ae");
    277         LocaleList.setDefault(locales);
    278         try {
    279             assertEquals("ae", Locale.getDefault().toLanguageTag());
    280             assertEquals(locales, LocaleList.getDefault());
    281             assertEquals(locales, LocaleList.getAdjustedDefault());
    282         } finally {
    283             // restore the original values
    284             LocaleList.setDefault(originalLocaleList, originalLocaleList.indexOf(originalLocale));
    285         }
    286     }
    287 
    288     public void testSetDefault_twoLocales() {
    289         final Locale originalLocale = Locale.getDefault();
    290         final LocaleList originalLocaleList = LocaleList.getDefault();
    291 
    292         final LocaleList locales = LocaleList.forLanguageTags("ae,en");
    293         LocaleList.setDefault(locales);
    294         try {
    295             assertEquals("ae", Locale.getDefault().toLanguageTag());
    296             assertEquals(locales, LocaleList.getDefault());
    297             assertEquals(locales, LocaleList.getAdjustedDefault());
    298         } finally {
    299             // restore the original values
    300             LocaleList.setDefault(originalLocaleList, originalLocaleList.indexOf(originalLocale));
    301         }
    302     }
    303 
    304     public void testParcelable() {
    305         // Make sure an empty LocaleList can be marshalled/unmarshalled via Parcel.
    306         assertEquals(LocaleList.getEmptyLocaleList(),
    307                 cloneViaParcel(LocaleList.getEmptyLocaleList()));
    308 
    309         // Make sure a non-empty LocaleList can be marshalled/unmarshalled via Parcel.
    310         LocaleList original = LocaleList.forLanguageTags("en-PH,en-US");
    311         assertEquals(original, cloneViaParcel(original));
    312     }
    313 
    314     public void testDescribeContents_doesNotThrowException() {
    315         // Just check calling describeContents() should not cause any exceptions.
    316         LocaleList.forLanguageTags("en").describeContents();
    317         LocaleList.forLanguageTags("").describeContents();
    318         LocaleList.forLanguageTags(null).describeContents();
    319         LocaleList.getEmptyLocaleList().describeContents();
    320     }
    321 
    322     private static LocaleList cloneViaParcel(final LocaleList original) {
    323         Parcel parcel = null;
    324         try {
    325             parcel = Parcel.obtain();
    326             original.writeToParcel(parcel, 0);
    327             parcel.setDataPosition(0);
    328             return LocaleList.CREATOR.createFromParcel(parcel);
    329         } finally {
    330             if (parcel != null) {
    331                 parcel.recycle();
    332             }
    333         }
    334     }
    335 
    336     public void testGetFirstMatch_noAssets() {
    337         String[] noAssets = {};
    338         assertNull(LocaleList.getEmptyLocaleList().getFirstMatch(noAssets));
    339         assertEquals(
    340                 Locale.forLanguageTag("fr-BE"),
    341                 LocaleList.forLanguageTags("fr-BE").getFirstMatch(noAssets));
    342         assertEquals(
    343                 Locale.forLanguageTag("fr-BE"),
    344                 LocaleList.forLanguageTags("fr-BE,nl-BE").getFirstMatch(noAssets));
    345     }
    346 
    347     public void testGetFirstMatch_oneAsset() {
    348         String[] oneDutchAsset = {"nl"};
    349         assertNull(LocaleList.getEmptyLocaleList().getFirstMatch(oneDutchAsset));
    350         assertEquals(
    351                 Locale.forLanguageTag("fr-BE"),
    352                 LocaleList.forLanguageTags("fr-BE").getFirstMatch(oneDutchAsset));
    353         assertEquals(
    354                 Locale.forLanguageTag("nl-BE"),
    355                 LocaleList.forLanguageTags("nl-BE").getFirstMatch(oneDutchAsset));
    356         assertEquals(
    357                 Locale.forLanguageTag("nl-BE"),
    358                 LocaleList.forLanguageTags("fr-BE,nl-BE").getFirstMatch(oneDutchAsset));
    359         assertEquals(
    360                 Locale.forLanguageTag("nl-BE"),
    361                 LocaleList.forLanguageTags("nl-BE,fr-BE").getFirstMatch(oneDutchAsset));
    362     }
    363 
    364     public void testGetFirstMatch_twoAssets() {
    365         String[] FrenchAndDutchAssets = {"fr", "nl"};
    366         assertNull(LocaleList.getEmptyLocaleList().getFirstMatch(FrenchAndDutchAssets));
    367         assertEquals(
    368                 Locale.forLanguageTag("fr-BE"),
    369                 LocaleList.forLanguageTags("fr-BE").getFirstMatch(FrenchAndDutchAssets));
    370         assertEquals(
    371                 Locale.forLanguageTag("nl-BE"),
    372                 LocaleList.forLanguageTags("nl-BE").getFirstMatch(FrenchAndDutchAssets));
    373         assertEquals(
    374                 Locale.forLanguageTag("fr-BE"),
    375                 LocaleList.forLanguageTags("fr-BE,nl-BE").getFirstMatch(FrenchAndDutchAssets));
    376         assertEquals(
    377                 Locale.forLanguageTag("nl-BE"),
    378                 LocaleList.forLanguageTags("nl-BE,fr-BE").getFirstMatch(FrenchAndDutchAssets));
    379     }
    380 
    381     public void testGetFirstMatch_oneChineseAsset() {
    382         String[] oneChineseAsset = {"zh-CN"};  // Assumed to mean zh-Hans-CN
    383         // The following Chinese examples would all match, so they will be chosen.
    384         assertEquals(
    385                 Locale.forLanguageTag("zh"),
    386                 LocaleList.forLanguageTags("ko-KR,zh").getFirstMatch(oneChineseAsset));
    387         assertEquals(
    388                 Locale.forLanguageTag("zh-CN"),
    389                 LocaleList.forLanguageTags("ko-KR,zh-CN").getFirstMatch(oneChineseAsset));
    390         assertEquals(
    391                 Locale.forLanguageTag("zh-Hans"),
    392                 LocaleList.forLanguageTags("ko-KR,zh-Hans").getFirstMatch(oneChineseAsset));
    393         assertEquals(
    394                 Locale.forLanguageTag("zh-Hans-CN"),
    395                 LocaleList.forLanguageTags("ko-KR,zh-Hans-CN").getFirstMatch(oneChineseAsset));
    396         assertEquals(
    397                 Locale.forLanguageTag("zh-Hans-HK"),
    398                 LocaleList.forLanguageTags("ko-KR,zh-Hans-HK").getFirstMatch(oneChineseAsset));
    399 
    400         // The following Chinese examples wouldn't match, so the first locale will be chosen
    401         // instead.
    402         assertEquals(
    403                 Locale.forLanguageTag("ko-KR"),
    404                 LocaleList.forLanguageTags("ko-KR,zh-TW").getFirstMatch(oneChineseAsset));
    405         assertEquals(
    406                 Locale.forLanguageTag("ko-KR"),
    407                 LocaleList.forLanguageTags("ko-KR,zh-Hant").getFirstMatch(oneChineseAsset));
    408         assertEquals(
    409                 Locale.forLanguageTag("ko-KR"),
    410                 LocaleList.forLanguageTags("ko-KR,zh-Hant-TW").getFirstMatch(oneChineseAsset));
    411     }
    412 
    413     public void testGetFirstMatch_serbianCyrillic() {
    414         String[] oneSerbianAsset = {"sr"};  // Assumed to mean sr-Cyrl-RS
    415         // The following Serbian examples would all match, so they will be chosen.
    416         assertEquals(
    417                 Locale.forLanguageTag("sr"),
    418                 LocaleList.forLanguageTags("hr-HR,sr").getFirstMatch(oneSerbianAsset));
    419         assertEquals(
    420                 Locale.forLanguageTag("sr-RS"),
    421                 LocaleList.forLanguageTags("hr-HR,sr-RS").getFirstMatch(oneSerbianAsset));
    422         assertEquals(
    423                 Locale.forLanguageTag("sr-Cyrl"),
    424                 LocaleList.forLanguageTags("hr-HR,sr-Cyrl").getFirstMatch(oneSerbianAsset));
    425         assertEquals(
    426                 Locale.forLanguageTag("sr-Cyrl-RS"),
    427                 LocaleList.forLanguageTags("hr-HR,sr-Cyrl-RS").getFirstMatch(oneSerbianAsset));
    428         assertEquals(
    429                 Locale.forLanguageTag("sr-Cyrl-ME"),
    430                 LocaleList.forLanguageTags("hr-HR,sr-Cyrl-ME").getFirstMatch(oneSerbianAsset));
    431 
    432         // The following Serbian examples wouldn't match, so the first locale will be chosen
    433         // instead.
    434         assertEquals(
    435                 Locale.forLanguageTag("hr-HR"),
    436                 LocaleList.forLanguageTags("hr-HR,sr-ME").getFirstMatch(oneSerbianAsset));
    437         assertEquals(
    438                 Locale.forLanguageTag("hr-HR"),
    439                 LocaleList.forLanguageTags("hr-HR,sr-Latn").getFirstMatch(oneSerbianAsset));
    440         assertEquals(
    441                 Locale.forLanguageTag("hr-HR"),
    442                 LocaleList.forLanguageTags("hr-HR,sr-Latn-ME").getFirstMatch(oneSerbianAsset));
    443     }
    444 
    445     public void testGetFirstMatch_LtrPseudoLocale() {
    446         String[] onePseudoLocale = {"en-XA"};
    447         // "en-XA" matches itself
    448         assertEquals(
    449                 Locale.forLanguageTag("en-XA"),
    450                 LocaleList.forLanguageTags("sr,en-XA").getFirstMatch(onePseudoLocale));
    451 
    452         // "en-XA" doesn't match "en" or "en-US"
    453         assertEquals(
    454                 Locale.forLanguageTag("sr"),
    455                 LocaleList.forLanguageTags("sr,en").getFirstMatch(onePseudoLocale));
    456         assertEquals(
    457                 Locale.forLanguageTag("sr"),
    458                 LocaleList.forLanguageTags("sr,en-US").getFirstMatch(onePseudoLocale));
    459     }
    460 
    461     public void testGetFirstMatch_RtlPseudoLocale() {
    462         String[] onePseudoLocale = {"ar-XB"};
    463         // "ar-XB" matches itself
    464         assertEquals(
    465                 Locale.forLanguageTag("ar-XB"),
    466                 LocaleList.forLanguageTags("sr,ar-XB").getFirstMatch(onePseudoLocale));
    467 
    468         // "ar-XB" doesn't match "ar" or "ar-EG"
    469         assertEquals(
    470                 Locale.forLanguageTag("sr"),
    471                 LocaleList.forLanguageTags("sr,ar").getFirstMatch(onePseudoLocale));
    472         assertEquals(
    473                 Locale.forLanguageTag("sr"),
    474                 LocaleList.forLanguageTags("sr,ar-EG").getFirstMatch(onePseudoLocale));
    475     }
    476 
    477     public void testGetFirstMatch_privateUseWithoutCountry() {
    478         String[] onePrivateLocale = {"qaa"};
    479         // "qaa" supports itself and "qaa-CA"
    480         assertEquals(
    481                 Locale.forLanguageTag("qaa"),
    482                 LocaleList.forLanguageTags("sr,qaa").getFirstMatch(onePrivateLocale));
    483         assertEquals(
    484                 Locale.forLanguageTag("qaa-CA"),
    485                 LocaleList.forLanguageTags("sr,qaa-CA").getFirstMatch(onePrivateLocale));
    486     }
    487 
    488     public void testGetFirstMatch_privateUseWithCountry() {
    489         String[] onePrivateLocale = {"qaa-US"};
    490         // "qaa-US" supports itself
    491         assertEquals(
    492                 Locale.forLanguageTag("qaa-US"),
    493                 LocaleList.forLanguageTags("sr,qaa-US").getFirstMatch(onePrivateLocale));
    494 
    495         // "qaa-US" doesn't support "qaa" or "qaa-CA"
    496         assertEquals(
    497                 Locale.forLanguageTag("sr"),
    498                 LocaleList.forLanguageTags("sr,qaa-CA").getFirstMatch(onePrivateLocale));
    499         assertEquals(
    500                 Locale.forLanguageTag("sr"),
    501                 LocaleList.forLanguageTags("sr,qaa").getFirstMatch(onePrivateLocale));
    502     }
    503 }
    504