1/*
2 * Copyright (C) 2014 Google Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
5 * use this file except in compliance with the License. You may obtain a copy of
6 * 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, WITHOUT
12 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
13 * License for the specific language governing permissions and limitations under
14 * the License.
15 */
16
17package libcore.java.util;
18
19import java.util.Collections;
20import java.util.HashMap;
21import java.util.HashSet;
22import java.util.Locale;
23import java.util.Map;
24import java.util.Set;
25import java.util.TreeMap;
26import junit.framework.TestCase;
27import libcore.icu.ICU;
28
29public class LocaleInternalsTest extends TestCase {
30/*
31    public void test_serializeExtensions() {
32        Map<Character, String> extensions = new TreeMap<Character, String>();
33
34        extensions.put('x', "fooo-baar-baaz");
35        assertEquals("x-fooo-baar-baaz", Locale.serializeExtensions(extensions));
36
37        extensions.put('y', "gaaa-caar-caaz");
38        // Must show up in lexical order.
39        assertEquals("x-fooo-baar-baaz-y-gaaa-caar-caaz",
40                Locale.serializeExtensions(extensions));
41    }
42
43    public void test_parseSerializedExtensions() {
44        Map<Character, String> extensions = new HashMap<Character, String>();
45
46        Locale.parseSerializedExtensions("x-foo", extensions);
47        assertEquals("foo", extensions.get('x'));
48
49        extensions.clear();
50        Locale.parseSerializedExtensions("x-foo-y-bar-z-baz", extensions);
51        assertEquals("foo", extensions.get('x'));
52        assertEquals("bar", extensions.get('y'));
53        assertEquals("baz", extensions.get('z'));
54
55        extensions.clear();
56        Locale.parseSerializedExtensions("x-fooo-baar-baaz", extensions);
57        assertEquals("fooo-baar-baaz", extensions.get('x'));
58
59        extensions.clear();
60        Locale.parseSerializedExtensions("x-fooo-baar-baaz-y-gaaa-caar-caaz", extensions);
61        assertEquals("fooo-baar-baaz", extensions.get('x'));
62        assertEquals("gaaa-caar-caaz", extensions.get('y'));
63    }
64
65    public void test_parseUnicodeExtension() {
66        Map<String, String> keywords = new HashMap<String, String>();
67        Set<String> attributes = new HashSet<String>();
68
69        // Only attributes.
70        Locale.parseUnicodeExtension("foooo".split("-"), keywords, attributes);
71        assertTrue(attributes.contains("foooo"));
72        assertEquals(Collections.EMPTY_SET, keywords.keySet());
73
74        attributes.clear();
75        keywords.clear();
76        Locale.parseUnicodeExtension("foooo-baa-baaabaaa".split("-"),
77                keywords, attributes);
78        assertTrue(attributes.contains("foooo"));
79        assertTrue(attributes.contains("baa"));
80        assertTrue(attributes.contains("baaabaaa"));
81        assertEquals(Collections.EMPTY_SET, keywords.keySet());
82
83        // Only keywords
84        attributes.clear();
85        keywords.clear();
86        Locale.parseUnicodeExtension("ko-koko".split("-"), keywords, attributes);
87        assertTrue(attributes.isEmpty());
88        assertEquals("koko", keywords.get("ko"));
89
90        attributes.clear();
91        keywords.clear();
92        Locale.parseUnicodeExtension("ko-koko-kokoko".split("-"), keywords, attributes);
93        assertTrue(attributes.isEmpty());
94        assertEquals("koko-kokoko", keywords.get("ko"));
95
96        attributes.clear();
97        keywords.clear();
98        Locale.parseUnicodeExtension("ko-koko-kokoko-ba-baba-bababa".split("-"),
99                keywords, attributes);
100        assertTrue(attributes.isEmpty());
101        assertEquals("koko-kokoko", keywords.get("ko"));
102        assertEquals("baba-bababa", keywords.get("ba"));
103
104        // A mixture of attributes and keywords.
105        attributes.clear();
106        keywords.clear();
107        Locale.parseUnicodeExtension("attri1-attri2-k1-type1-type1-k2-type2".split("-"),
108                keywords, attributes);
109        assertTrue(attributes.contains("attri1"));
110        assertTrue(attributes.contains("attri2"));
111        assertEquals("type1-type1", keywords.get("k1"));
112        assertEquals("type2", keywords.get("k2"));
113    }
114
115    public void test_setDefault_setsICUDefaultLocale() {
116        Locale.setDefault(Locale.GERMANY);
117        assertEquals("de_DE", ICU.getDefaultLocale());
118
119        try {
120            Locale.setDefault(null);
121            fail();
122        } catch (NullPointerException expected) {
123            assertEquals(Locale.GERMANY, Locale.getDefault());
124        }
125
126        Locale.setDefault(new Locale("bogus", "LOCALE"));
127        assertEquals("und", ICU.getDefaultLocale());
128    } */
129}
130