StringAndJsonUtilsTests.java revision 7cd7cf73f4ce6f0e577d6382eb0fc25f60dc63e1 
1/*
2 * Copyright (C) 2012 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
17package com.android.inputmethod.latin.utils;
18
19import com.android.inputmethod.latin.settings.SettingsValues;
20
21import android.test.AndroidTestCase;
22import android.test.suitebuilder.annotation.SmallTest;
23
24import java.util.Arrays;
25import java.util.List;
26import java.util.Locale;
27
28@SmallTest
29public class StringAndJsonUtilsTests extends AndroidTestCase {
30    public void testContainsInArray() {
31        assertFalse("empty array", StringUtils.containsInArray("key", new String[0]));
32        assertFalse("not in 1 element", StringUtils.containsInArray("key", new String[] {
33                "key1"
34        }));
35        assertFalse("not in 2 elements", StringUtils.containsInArray("key", new String[] {
36                "key1", "key2"
37        }));
38
39        assertTrue("in 1 element", StringUtils.containsInArray("key", new String[] {
40                "key"
41        }));
42        assertTrue("in 2 elements", StringUtils.containsInArray("key", new String[] {
43                "key1", "key"
44        }));
45    }
46
47    public void testContainsInCommaSplittableText() {
48        assertFalse("null", StringUtils.containsInCommaSplittableText("key", null));
49        assertFalse("empty", StringUtils.containsInCommaSplittableText("key", ""));
50        assertFalse("not in 1 element",
51                StringUtils.containsInCommaSplittableText("key", "key1"));
52        assertFalse("not in 2 elements",
53                StringUtils.containsInCommaSplittableText("key", "key1,key2"));
54
55        assertTrue("in 1 element", StringUtils.containsInCommaSplittableText("key", "key"));
56        assertTrue("in 2 elements", StringUtils.containsInCommaSplittableText("key", "key1,key"));
57    }
58
59    public void testJoinCommaSplittableText() {
60        assertEquals("2 nulls", "",
61                StringUtils.joinCommaSplittableText(null, null));
62        assertEquals("null and empty", "",
63                StringUtils.joinCommaSplittableText(null, ""));
64        assertEquals("empty and null", "",
65                StringUtils.joinCommaSplittableText("", null));
66        assertEquals("2 empties", "",
67                StringUtils.joinCommaSplittableText("", ""));
68        assertEquals("text and null", "text",
69                StringUtils.joinCommaSplittableText("text", null));
70        assertEquals("text and empty", "text",
71                StringUtils.joinCommaSplittableText("text", ""));
72        assertEquals("null and text", "text",
73                StringUtils.joinCommaSplittableText(null, "text"));
74        assertEquals("empty and text", "text",
75                StringUtils.joinCommaSplittableText("", "text"));
76        assertEquals("2 texts", "text1,text2",
77                StringUtils.joinCommaSplittableText("text1", "text2"));
78    }
79
80    public void testAppendToCommaSplittableTextIfNotExists() {
81        assertEquals("null", "key",
82                StringUtils.appendToCommaSplittableTextIfNotExists("key", null));
83        assertEquals("empty", "key",
84                StringUtils.appendToCommaSplittableTextIfNotExists("key", ""));
85
86        assertEquals("not in 1 element", "key1,key",
87                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1"));
88        assertEquals("not in 2 elements", "key1,key2,key",
89                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key2"));
90
91        assertEquals("in 1 element", "key",
92                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key"));
93        assertEquals("in 2 elements at position 1", "key,key2",
94                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key,key2"));
95        assertEquals("in 2 elements at position 2", "key1,key",
96                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key"));
97        assertEquals("in 3 elements at position 2", "key1,key,key3",
98                StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key,key3"));
99    }
100
101    public void testRemoveFromCommaSplittableTextIfExists() {
102        assertEquals("null", "", StringUtils.removeFromCommaSplittableTextIfExists("key", null));
103        assertEquals("empty", "", StringUtils.removeFromCommaSplittableTextIfExists("key", ""));
104
105        assertEquals("not in 1 element", "key1",
106                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1"));
107        assertEquals("not in 2 elements", "key1,key2",
108                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key2"));
109
110        assertEquals("in 1 element", "",
111                StringUtils.removeFromCommaSplittableTextIfExists("key", "key"));
112        assertEquals("in 2 elements at position 1", "key2",
113                StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key2"));
114        assertEquals("in 2 elements at position 2", "key1",
115                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key"));
116        assertEquals("in 3 elements at position 2", "key1,key3",
117                StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key,key3"));
118
119        assertEquals("in 3 elements at position 1,2,3", "",
120                StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key,key"));
121        assertEquals("in 5 elements at position 2,4", "key1,key3,key5",
122                StringUtils.removeFromCommaSplittableTextIfExists(
123                        "key", "key1,key,key3,key,key5"));
124    }
125
126
127    public void testCapitalizeFirstCodePoint() {
128        assertEquals("SSaa",
129                StringUtils.capitalizeFirstCodePoint("ßaa", Locale.GERMAN));
130        assertEquals("Aßa",
131                StringUtils.capitalizeFirstCodePoint("aßa", Locale.GERMAN));
132        assertEquals("Iab",
133                StringUtils.capitalizeFirstCodePoint("iab", Locale.ENGLISH));
134        assertEquals("CAmElCaSe",
135                StringUtils.capitalizeFirstCodePoint("cAmElCaSe", Locale.ENGLISH));
136        assertEquals("İab",
137                StringUtils.capitalizeFirstCodePoint("iab", new Locale("tr")));
138        assertEquals("AİB",
139                StringUtils.capitalizeFirstCodePoint("AİB", new Locale("tr")));
140        assertEquals("A",
141                StringUtils.capitalizeFirstCodePoint("a", Locale.ENGLISH));
142        assertEquals("A",
143                StringUtils.capitalizeFirstCodePoint("A", Locale.ENGLISH));
144    }
145
146    public void testCapitalizeFirstAndDowncaseRest() {
147        assertEquals("SSaa",
148                StringUtils.capitalizeFirstAndDowncaseRest("ßaa", Locale.GERMAN));
149        assertEquals("Aßa",
150                StringUtils.capitalizeFirstAndDowncaseRest("aßa", Locale.GERMAN));
151        assertEquals("Iab",
152                StringUtils.capitalizeFirstAndDowncaseRest("iab", Locale.ENGLISH));
153        assertEquals("Camelcase",
154                StringUtils.capitalizeFirstAndDowncaseRest("cAmElCaSe", Locale.ENGLISH));
155        assertEquals("İab",
156                StringUtils.capitalizeFirstAndDowncaseRest("iab", new Locale("tr")));
157        assertEquals("Aib",
158                StringUtils.capitalizeFirstAndDowncaseRest("AİB", new Locale("tr")));
159        assertEquals("A",
160                StringUtils.capitalizeFirstAndDowncaseRest("a", Locale.ENGLISH));
161        assertEquals("A",
162                StringUtils.capitalizeFirstAndDowncaseRest("A", Locale.ENGLISH));
163    }
164
165    public void testGetCapitalizationType() {
166        assertEquals(StringUtils.CAPITALIZE_NONE,
167                StringUtils.getCapitalizationType("capitalize"));
168        assertEquals(StringUtils.CAPITALIZE_NONE,
169                StringUtils.getCapitalizationType("cApITalize"));
170        assertEquals(StringUtils.CAPITALIZE_NONE,
171                StringUtils.getCapitalizationType("capitalizE"));
172        assertEquals(StringUtils.CAPITALIZE_NONE,
173                StringUtils.getCapitalizationType("__c a piu$@tali56ze"));
174        assertEquals(StringUtils.CAPITALIZE_FIRST,
175                StringUtils.getCapitalizationType("A__c a piu$@tali56ze"));
176        assertEquals(StringUtils.CAPITALIZE_FIRST,
177                StringUtils.getCapitalizationType("Capitalize"));
178        assertEquals(StringUtils.CAPITALIZE_FIRST,
179                StringUtils.getCapitalizationType("     Capitalize"));
180        assertEquals(StringUtils.CAPITALIZE_ALL,
181                StringUtils.getCapitalizationType("CAPITALIZE"));
182        assertEquals(StringUtils.CAPITALIZE_ALL,
183                StringUtils.getCapitalizationType("  PI26LIE"));
184        assertEquals(StringUtils.CAPITALIZE_NONE,
185                StringUtils.getCapitalizationType(""));
186    }
187
188    public void testIsIdenticalAfterUpcaseIsIdenticalAfterDowncase() {
189        assertFalse(StringUtils.isIdenticalAfterUpcase("capitalize"));
190        assertTrue(StringUtils.isIdenticalAfterDowncase("capitalize"));
191        assertFalse(StringUtils.isIdenticalAfterUpcase("cApITalize"));
192        assertFalse(StringUtils.isIdenticalAfterDowncase("cApITalize"));
193        assertFalse(StringUtils.isIdenticalAfterUpcase("capitalizE"));
194        assertFalse(StringUtils.isIdenticalAfterDowncase("capitalizE"));
195        assertFalse(StringUtils.isIdenticalAfterUpcase("__c a piu$@tali56ze"));
196        assertTrue(StringUtils.isIdenticalAfterDowncase("__c a piu$@tali56ze"));
197        assertFalse(StringUtils.isIdenticalAfterUpcase("A__c a piu$@tali56ze"));
198        assertFalse(StringUtils.isIdenticalAfterDowncase("A__c a piu$@tali56ze"));
199        assertFalse(StringUtils.isIdenticalAfterUpcase("Capitalize"));
200        assertFalse(StringUtils.isIdenticalAfterDowncase("Capitalize"));
201        assertFalse(StringUtils.isIdenticalAfterUpcase("     Capitalize"));
202        assertFalse(StringUtils.isIdenticalAfterDowncase("     Capitalize"));
203        assertTrue(StringUtils.isIdenticalAfterUpcase("CAPITALIZE"));
204        assertFalse(StringUtils.isIdenticalAfterDowncase("CAPITALIZE"));
205        assertTrue(StringUtils.isIdenticalAfterUpcase("  PI26LIE"));
206        assertFalse(StringUtils.isIdenticalAfterDowncase("  PI26LIE"));
207        assertTrue(StringUtils.isIdenticalAfterUpcase(""));
208        assertTrue(StringUtils.isIdenticalAfterDowncase(""));
209    }
210
211    public void testLooksValidForDictionaryInsertion() {
212        final SettingsValues settings =
213                SettingsValues.makeDummySettingsValuesForTest(Locale.ENGLISH);
214        assertTrue(StringUtils.looksValidForDictionaryInsertion("aochaueo", settings));
215        assertFalse(StringUtils.looksValidForDictionaryInsertion("", settings));
216        assertTrue(StringUtils.looksValidForDictionaryInsertion("ao-ch'aueo", settings));
217        assertFalse(StringUtils.looksValidForDictionaryInsertion("2908743256", settings));
218        assertTrue(StringUtils.looksValidForDictionaryInsertion("31aochaueo", settings));
219        assertFalse(StringUtils.looksValidForDictionaryInsertion("akeo  raeoch oerch .", settings));
220        assertFalse(StringUtils.looksValidForDictionaryInsertion("!!!", settings));
221    }
222
223    private static void checkCapitalize(final String src, final String dst, final String separators,
224            final Locale locale) {
225        assertEquals(dst, StringUtils.capitalizeEachWord(src, separators, locale));
226        assert(src.equals(dst)
227                == StringUtils.isIdenticalAfterCapitalizeEachWord(src, separators));
228    }
229
230    public void testCapitalizeEachWord() {
231        checkCapitalize("", "", " ", Locale.ENGLISH);
232        checkCapitalize("test", "Test", " ", Locale.ENGLISH);
233        checkCapitalize("    test", "    Test", " ", Locale.ENGLISH);
234        checkCapitalize("Test", "Test", " ", Locale.ENGLISH);
235        checkCapitalize("    Test", "    Test", " ", Locale.ENGLISH);
236        checkCapitalize(".Test", ".test", " ", Locale.ENGLISH);
237        checkCapitalize(".Test", ".Test", " .", Locale.ENGLISH);
238        checkCapitalize(".Test", ".Test", ". ", Locale.ENGLISH);
239        checkCapitalize("test and retest", "Test And Retest", " .", Locale.ENGLISH);
240        checkCapitalize("Test and retest", "Test And Retest", " .", Locale.ENGLISH);
241        checkCapitalize("Test And Retest", "Test And Retest", " .", Locale.ENGLISH);
242        checkCapitalize("Test And.Retest  ", "Test And.Retest  ", " .", Locale.ENGLISH);
243        checkCapitalize("Test And.retest  ", "Test And.Retest  ", " .", Locale.ENGLISH);
244        checkCapitalize("Test And.retest  ", "Test And.retest  ", " ", Locale.ENGLISH);
245        checkCapitalize("Test And.Retest  ", "Test And.retest  ", " ", Locale.ENGLISH);
246        checkCapitalize("test and ietest", "Test And İetest", " .", new Locale("tr"));
247        checkCapitalize("test and ietest", "Test And Ietest", " .", Locale.ENGLISH);
248        checkCapitalize("Test&Retest", "Test&Retest", " \n.!?*()&", Locale.ENGLISH);
249        checkCapitalize("Test&retest", "Test&Retest", " \n.!?*()&", Locale.ENGLISH);
250        checkCapitalize("test&Retest", "Test&Retest", " \n.!?*()&", Locale.ENGLISH);
251        checkCapitalize("rest\nrecreation! And in the end...",
252                "Rest\nRecreation! And In The End...", " \n.!?*,();&", Locale.ENGLISH);
253        checkCapitalize("lorem ipsum dolor sit amet", "Lorem Ipsum Dolor Sit Amet",
254                " \n.,!?*()&;", Locale.ENGLISH);
255        checkCapitalize("Lorem!Ipsum (Dolor) Sit * Amet", "Lorem!Ipsum (Dolor) Sit * Amet",
256                " \n,.;!?*()&", Locale.ENGLISH);
257        checkCapitalize("Lorem!Ipsum (dolor) Sit * Amet", "Lorem!Ipsum (Dolor) Sit * Amet",
258                " \n,.;!?*()&", Locale.ENGLISH);
259    }
260
261    public void testLooksLikeURL() {
262        assertTrue(StringUtils.lastPartLooksLikeURL("http://www.google."));
263        assertFalse(StringUtils.lastPartLooksLikeURL("word wo"));
264        assertTrue(StringUtils.lastPartLooksLikeURL("/etc/foo"));
265        assertFalse(StringUtils.lastPartLooksLikeURL("left/right"));
266        assertTrue(StringUtils.lastPartLooksLikeURL("www.goo"));
267        assertTrue(StringUtils.lastPartLooksLikeURL("www."));
268        assertFalse(StringUtils.lastPartLooksLikeURL("U.S.A"));
269        assertFalse(StringUtils.lastPartLooksLikeURL("U.S.A."));
270        assertTrue(StringUtils.lastPartLooksLikeURL("rtsp://foo."));
271        assertTrue(StringUtils.lastPartLooksLikeURL("://"));
272        assertFalse(StringUtils.lastPartLooksLikeURL("abc/"));
273        assertTrue(StringUtils.lastPartLooksLikeURL("abc.def/ghi"));
274        assertFalse(StringUtils.lastPartLooksLikeURL("abc.def"));
275        // TODO: ideally this would not look like a URL, but to keep down the complexity of the
276        // code for now True is acceptable.
277        assertTrue(StringUtils.lastPartLooksLikeURL("abc./def"));
278        // TODO: ideally this would not look like a URL, but to keep down the complexity of the
279        // code for now True is acceptable.
280        assertTrue(StringUtils.lastPartLooksLikeURL(".abc/def"));
281    }
282
283    public void testHexStringUtils() {
284        final byte[] bytes = new byte[] { (byte)0x01, (byte)0x11, (byte)0x22, (byte)0x33,
285                (byte)0x55, (byte)0x88, (byte)0xEE };
286        final String bytesStr = StringUtils.byteArrayToHexString(bytes);
287        final byte[] bytes2 = StringUtils.hexStringToByteArray(bytesStr);
288        for (int i = 0; i < bytes.length; ++i) {
289            assertTrue(bytes[i] == bytes2[i]);
290        }
291        final String bytesStr2 = StringUtils.byteArrayToHexString(bytes2);
292        assertTrue(bytesStr.equals(bytesStr2));
293    }
294
295    public void testContainsOnlyWhitespace() {
296        assertTrue(StringUtils.containsOnlyWhitespace("   "));
297        assertTrue(StringUtils.containsOnlyWhitespace(""));
298        assertTrue(StringUtils.containsOnlyWhitespace("  \n\t\t"));
299        // U+2002 : EN SPACE
300        // U+2003 : EM SPACE
301        // U+3000 : IDEOGRAPHIC SPACE (commonly "double-width space")
302        assertTrue(StringUtils.containsOnlyWhitespace("\u2002\u2003\u3000"));
303        assertFalse(StringUtils.containsOnlyWhitespace("  a "));
304        assertFalse(StringUtils.containsOnlyWhitespace(". "));
305        assertFalse(StringUtils.containsOnlyWhitespace("."));
306        assertTrue(StringUtils.containsOnlyWhitespace(""));
307    }
308
309    public void testJsonUtils() {
310        final Object[] objs = new Object[] { 1, "aaa", "bbb", 3 };
311        final List<Object> objArray = Arrays.asList(objs);
312        final String str = JsonUtils.listToJsonStr(objArray);
313        final List<Object> newObjArray = JsonUtils.jsonStrToList(str);
314        for (int i = 0; i < objs.length; ++i) {
315            assertEquals(objs[i], newObjArray.get(i));
316        }
317    }
318}
319