StringAndJsonUtilsTests.java revision eac8670830a172dd2ba2fea0632ecc7f7ec95992
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 android.test.AndroidTestCase; 20import android.test.suitebuilder.annotation.SmallTest; 21import android.text.SpannableString; 22import android.text.Spanned; 23import android.text.SpannedString; 24 25import com.android.inputmethod.latin.Constants; 26 27import java.util.Arrays; 28import java.util.List; 29import java.util.Locale; 30 31@SmallTest 32public class StringAndJsonUtilsTests extends AndroidTestCase { 33 public void testContainsInArray() { 34 assertFalse("empty array", StringUtils.containsInArray("key", new String[0])); 35 assertFalse("not in 1 element", StringUtils.containsInArray("key", new String[] { 36 "key1" 37 })); 38 assertFalse("not in 2 elements", StringUtils.containsInArray("key", new String[] { 39 "key1", "key2" 40 })); 41 42 assertTrue("in 1 element", StringUtils.containsInArray("key", new String[] { 43 "key" 44 })); 45 assertTrue("in 2 elements", StringUtils.containsInArray("key", new String[] { 46 "key1", "key" 47 })); 48 } 49 50 public void testContainsInCommaSplittableText() { 51 assertFalse("null", StringUtils.containsInCommaSplittableText("key", null)); 52 assertFalse("empty", StringUtils.containsInCommaSplittableText("key", "")); 53 assertFalse("not in 1 element", 54 StringUtils.containsInCommaSplittableText("key", "key1")); 55 assertFalse("not in 2 elements", 56 StringUtils.containsInCommaSplittableText("key", "key1,key2")); 57 58 assertTrue("in 1 element", StringUtils.containsInCommaSplittableText("key", "key")); 59 assertTrue("in 2 elements", StringUtils.containsInCommaSplittableText("key", "key1,key")); 60 } 61 62 public void testRemoveFromCommaSplittableTextIfExists() { 63 assertEquals("null", "", StringUtils.removeFromCommaSplittableTextIfExists("key", null)); 64 assertEquals("empty", "", StringUtils.removeFromCommaSplittableTextIfExists("key", "")); 65 66 assertEquals("not in 1 element", "key1", 67 StringUtils.removeFromCommaSplittableTextIfExists("key", "key1")); 68 assertEquals("not in 2 elements", "key1,key2", 69 StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key2")); 70 71 assertEquals("in 1 element", "", 72 StringUtils.removeFromCommaSplittableTextIfExists("key", "key")); 73 assertEquals("in 2 elements at position 1", "key2", 74 StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key2")); 75 assertEquals("in 2 elements at position 2", "key1", 76 StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key")); 77 assertEquals("in 3 elements at position 2", "key1,key3", 78 StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key,key3")); 79 80 assertEquals("in 3 elements at position 1,2,3", "", 81 StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key,key")); 82 assertEquals("in 5 elements at position 2,4", "key1,key3,key5", 83 StringUtils.removeFromCommaSplittableTextIfExists( 84 "key", "key1,key,key3,key,key5")); 85 } 86 87 88 public void testCapitalizeFirstCodePoint() { 89 assertEquals("SSaa", 90 StringUtils.capitalizeFirstCodePoint("ßaa", Locale.GERMAN)); 91 assertEquals("Aßa", 92 StringUtils.capitalizeFirstCodePoint("aßa", Locale.GERMAN)); 93 assertEquals("Iab", 94 StringUtils.capitalizeFirstCodePoint("iab", Locale.ENGLISH)); 95 assertEquals("CAmElCaSe", 96 StringUtils.capitalizeFirstCodePoint("cAmElCaSe", Locale.ENGLISH)); 97 assertEquals("İab", 98 StringUtils.capitalizeFirstCodePoint("iab", new Locale("tr"))); 99 assertEquals("AİB", 100 StringUtils.capitalizeFirstCodePoint("AİB", new Locale("tr"))); 101 assertEquals("A", 102 StringUtils.capitalizeFirstCodePoint("a", Locale.ENGLISH)); 103 assertEquals("A", 104 StringUtils.capitalizeFirstCodePoint("A", Locale.ENGLISH)); 105 } 106 107 public void testCapitalizeFirstAndDowncaseRest() { 108 assertEquals("SSaa", 109 StringUtils.capitalizeFirstAndDowncaseRest("ßaa", Locale.GERMAN)); 110 assertEquals("Aßa", 111 StringUtils.capitalizeFirstAndDowncaseRest("aßa", Locale.GERMAN)); 112 assertEquals("Iab", 113 StringUtils.capitalizeFirstAndDowncaseRest("iab", Locale.ENGLISH)); 114 assertEquals("Camelcase", 115 StringUtils.capitalizeFirstAndDowncaseRest("cAmElCaSe", Locale.ENGLISH)); 116 assertEquals("İab", 117 StringUtils.capitalizeFirstAndDowncaseRest("iab", new Locale("tr"))); 118 assertEquals("Aib", 119 StringUtils.capitalizeFirstAndDowncaseRest("AİB", new Locale("tr"))); 120 assertEquals("A", 121 StringUtils.capitalizeFirstAndDowncaseRest("a", Locale.ENGLISH)); 122 assertEquals("A", 123 StringUtils.capitalizeFirstAndDowncaseRest("A", Locale.ENGLISH)); 124 } 125 126 public void testGetCapitalizationType() { 127 assertEquals(StringUtils.CAPITALIZE_NONE, 128 StringUtils.getCapitalizationType("capitalize")); 129 assertEquals(StringUtils.CAPITALIZE_NONE, 130 StringUtils.getCapitalizationType("cApITalize")); 131 assertEquals(StringUtils.CAPITALIZE_NONE, 132 StringUtils.getCapitalizationType("capitalizE")); 133 assertEquals(StringUtils.CAPITALIZE_NONE, 134 StringUtils.getCapitalizationType("__c a piu$@tali56ze")); 135 assertEquals(StringUtils.CAPITALIZE_FIRST, 136 StringUtils.getCapitalizationType("A__c a piu$@tali56ze")); 137 assertEquals(StringUtils.CAPITALIZE_FIRST, 138 StringUtils.getCapitalizationType("Capitalize")); 139 assertEquals(StringUtils.CAPITALIZE_FIRST, 140 StringUtils.getCapitalizationType(" Capitalize")); 141 assertEquals(StringUtils.CAPITALIZE_ALL, 142 StringUtils.getCapitalizationType("CAPITALIZE")); 143 assertEquals(StringUtils.CAPITALIZE_ALL, 144 StringUtils.getCapitalizationType(" PI26LIE")); 145 assertEquals(StringUtils.CAPITALIZE_NONE, 146 StringUtils.getCapitalizationType("")); 147 } 148 149 public void testIsIdenticalAfterUpcaseIsIdenticalAfterDowncase() { 150 assertFalse(StringUtils.isIdenticalAfterUpcase("capitalize")); 151 assertTrue(StringUtils.isIdenticalAfterDowncase("capitalize")); 152 assertFalse(StringUtils.isIdenticalAfterUpcase("cApITalize")); 153 assertFalse(StringUtils.isIdenticalAfterDowncase("cApITalize")); 154 assertFalse(StringUtils.isIdenticalAfterUpcase("capitalizE")); 155 assertFalse(StringUtils.isIdenticalAfterDowncase("capitalizE")); 156 assertFalse(StringUtils.isIdenticalAfterUpcase("__c a piu$@tali56ze")); 157 assertTrue(StringUtils.isIdenticalAfterDowncase("__c a piu$@tali56ze")); 158 assertFalse(StringUtils.isIdenticalAfterUpcase("A__c a piu$@tali56ze")); 159 assertFalse(StringUtils.isIdenticalAfterDowncase("A__c a piu$@tali56ze")); 160 assertFalse(StringUtils.isIdenticalAfterUpcase("Capitalize")); 161 assertFalse(StringUtils.isIdenticalAfterDowncase("Capitalize")); 162 assertFalse(StringUtils.isIdenticalAfterUpcase(" Capitalize")); 163 assertFalse(StringUtils.isIdenticalAfterDowncase(" Capitalize")); 164 assertTrue(StringUtils.isIdenticalAfterUpcase("CAPITALIZE")); 165 assertFalse(StringUtils.isIdenticalAfterDowncase("CAPITALIZE")); 166 assertTrue(StringUtils.isIdenticalAfterUpcase(" PI26LIE")); 167 assertFalse(StringUtils.isIdenticalAfterDowncase(" PI26LIE")); 168 assertTrue(StringUtils.isIdenticalAfterUpcase("")); 169 assertTrue(StringUtils.isIdenticalAfterDowncase("")); 170 } 171 172 private static void checkCapitalize(final String src, final String dst, 173 final int[] sortedSeparators, final Locale locale) { 174 assertEquals(dst, StringUtils.capitalizeEachWord(src, sortedSeparators, locale)); 175 assert(src.equals(dst) 176 == StringUtils.isIdenticalAfterCapitalizeEachWord(src, sortedSeparators)); 177 } 178 179 private static final int[] SPACE = { Constants.CODE_SPACE }; 180 private static final int[] SPACE_PERIOD = StringUtils.toSortedCodePointArray(" ."); 181 private static final int[] SENTENCE_SEPARATORS = 182 StringUtils.toSortedCodePointArray(" \n.!?*()&"); 183 private static final int[] WORD_SEPARATORS = StringUtils.toSortedCodePointArray(" \n.!?*,();&"); 184 185 public void testCapitalizeEachWord() { 186 checkCapitalize("", "", SPACE, Locale.ENGLISH); 187 checkCapitalize("test", "Test", SPACE, Locale.ENGLISH); 188 checkCapitalize(" test", " Test", SPACE, Locale.ENGLISH); 189 checkCapitalize("Test", "Test", SPACE, Locale.ENGLISH); 190 checkCapitalize(" Test", " Test", SPACE, Locale.ENGLISH); 191 checkCapitalize(".Test", ".test", SPACE, Locale.ENGLISH); 192 checkCapitalize(".Test", ".Test", SPACE_PERIOD, Locale.ENGLISH); 193 checkCapitalize("test and retest", "Test And Retest", SPACE_PERIOD, Locale.ENGLISH); 194 checkCapitalize("Test and retest", "Test And Retest", SPACE_PERIOD, Locale.ENGLISH); 195 checkCapitalize("Test And Retest", "Test And Retest", SPACE_PERIOD, Locale.ENGLISH); 196 checkCapitalize("Test And.Retest ", "Test And.Retest ", SPACE_PERIOD, Locale.ENGLISH); 197 checkCapitalize("Test And.retest ", "Test And.Retest ", SPACE_PERIOD, Locale.ENGLISH); 198 checkCapitalize("Test And.retest ", "Test And.retest ", SPACE, Locale.ENGLISH); 199 checkCapitalize("Test And.Retest ", "Test And.retest ", SPACE, Locale.ENGLISH); 200 checkCapitalize("test and ietest", "Test And İetest", SPACE_PERIOD, new Locale("tr")); 201 checkCapitalize("test and ietest", "Test And Ietest", SPACE_PERIOD, Locale.ENGLISH); 202 checkCapitalize("Test&Retest", "Test&Retest", SENTENCE_SEPARATORS, Locale.ENGLISH); 203 checkCapitalize("Test&retest", "Test&Retest", SENTENCE_SEPARATORS, Locale.ENGLISH); 204 checkCapitalize("test&Retest", "Test&Retest", SENTENCE_SEPARATORS, Locale.ENGLISH); 205 checkCapitalize("rest\nrecreation! And in the end...", 206 "Rest\nRecreation! And In The End...", WORD_SEPARATORS, Locale.ENGLISH); 207 checkCapitalize("lorem ipsum dolor sit amet", "Lorem Ipsum Dolor Sit Amet", 208 WORD_SEPARATORS, Locale.ENGLISH); 209 checkCapitalize("Lorem!Ipsum (Dolor) Sit * Amet", "Lorem!Ipsum (Dolor) Sit * Amet", 210 WORD_SEPARATORS, Locale.ENGLISH); 211 checkCapitalize("Lorem!Ipsum (dolor) Sit * Amet", "Lorem!Ipsum (Dolor) Sit * Amet", 212 WORD_SEPARATORS, Locale.ENGLISH); 213 } 214 215 public void testLooksLikeURL() { 216 assertTrue(StringUtils.lastPartLooksLikeURL("http://www.google.")); 217 assertFalse(StringUtils.lastPartLooksLikeURL("word wo")); 218 assertTrue(StringUtils.lastPartLooksLikeURL("/etc/foo")); 219 assertFalse(StringUtils.lastPartLooksLikeURL("left/right")); 220 assertTrue(StringUtils.lastPartLooksLikeURL("www.goo")); 221 assertTrue(StringUtils.lastPartLooksLikeURL("www.")); 222 assertFalse(StringUtils.lastPartLooksLikeURL("U.S.A")); 223 assertFalse(StringUtils.lastPartLooksLikeURL("U.S.A.")); 224 assertTrue(StringUtils.lastPartLooksLikeURL("rtsp://foo.")); 225 assertTrue(StringUtils.lastPartLooksLikeURL("://")); 226 assertFalse(StringUtils.lastPartLooksLikeURL("abc/")); 227 assertTrue(StringUtils.lastPartLooksLikeURL("abc.def/ghi")); 228 assertFalse(StringUtils.lastPartLooksLikeURL("abc.def")); 229 // TODO: ideally this would not look like a URL, but to keep down the complexity of the 230 // code for now True is acceptable. 231 assertTrue(StringUtils.lastPartLooksLikeURL("abc./def")); 232 // TODO: ideally this would not look like a URL, but to keep down the complexity of the 233 // code for now True is acceptable. 234 assertTrue(StringUtils.lastPartLooksLikeURL(".abc/def")); 235 } 236 237 public void testHexStringUtils() { 238 final byte[] bytes = new byte[] { (byte)0x01, (byte)0x11, (byte)0x22, (byte)0x33, 239 (byte)0x55, (byte)0x88, (byte)0xEE }; 240 final String bytesStr = StringUtils.byteArrayToHexString(bytes); 241 final byte[] bytes2 = StringUtils.hexStringToByteArray(bytesStr); 242 for (int i = 0; i < bytes.length; ++i) { 243 assertTrue(bytes[i] == bytes2[i]); 244 } 245 final String bytesStr2 = StringUtils.byteArrayToHexString(bytes2); 246 assertTrue(bytesStr.equals(bytesStr2)); 247 } 248 249 public void testJsonUtils() { 250 final Object[] objs = new Object[] { 1, "aaa", "bbb", 3 }; 251 final List<Object> objArray = Arrays.asList(objs); 252 final String str = JsonUtils.listToJsonStr(objArray); 253 final List<Object> newObjArray = JsonUtils.jsonStrToList(str); 254 for (int i = 0; i < objs.length; ++i) { 255 assertEquals(objs[i], newObjArray.get(i)); 256 } 257 } 258 259 public void testToCodePointArray() { 260 final String STR_WITH_SUPPLEMENTARY_CHAR = "abcde\uD861\uDED7fgh\u0000\u2002\u2003\u3000xx"; 261 final int[] EXPECTED_RESULT = new int[] { 'a', 'b', 'c', 'd', 'e', 0x286D7, 'f', 'g', 'h', 262 0, 0x2002, 0x2003, 0x3000, 'x', 'x'}; 263 final int[] codePointArray = StringUtils.toCodePointArray(STR_WITH_SUPPLEMENTARY_CHAR, 0, 264 STR_WITH_SUPPLEMENTARY_CHAR.length()); 265 assertEquals("toCodePointArray, size matches", codePointArray.length, 266 EXPECTED_RESULT.length); 267 for (int i = 0; i < EXPECTED_RESULT.length; ++i) { 268 assertEquals("toCodePointArray position " + i, codePointArray[i], EXPECTED_RESULT[i]); 269 } 270 } 271 272 public void testCopyCodePointsAndReturnCodePointCount() { 273 final String STR_WITH_SUPPLEMENTARY_CHAR = "AbcDE\uD861\uDED7fGh\u0000\u2002\u3000あx"; 274 final int[] EXPECTED_RESULT = new int[] { 'A', 'b', 'c', 'D', 'E', 0x286D7, 275 'f', 'G', 'h', 0, 0x2002, 0x3000, 'あ', 'x'}; 276 final int[] EXPECTED_RESULT_DOWNCASE = new int[] { 'a', 'b', 'c', 'd', 'e', 0x286D7, 277 'f', 'g', 'h', 0, 0x2002, 0x3000, 'あ', 'x'}; 278 279 int[] codePointArray = new int[50]; 280 int codePointCount = StringUtils.copyCodePointsAndReturnCodePointCount(codePointArray, 281 STR_WITH_SUPPLEMENTARY_CHAR, 0, 282 STR_WITH_SUPPLEMENTARY_CHAR.length(), false /* downCase */); 283 assertEquals("copyCodePointsAndReturnCodePointCount, size matches", codePointCount, 284 EXPECTED_RESULT.length); 285 for (int i = 0; i < codePointCount; ++i) { 286 assertEquals("copyCodePointsAndReturnCodePointCount position " + i, codePointArray[i], 287 EXPECTED_RESULT[i]); 288 } 289 290 codePointCount = StringUtils.copyCodePointsAndReturnCodePointCount(codePointArray, 291 STR_WITH_SUPPLEMENTARY_CHAR, 0, 292 STR_WITH_SUPPLEMENTARY_CHAR.length(), true /* downCase */); 293 assertEquals("copyCodePointsAndReturnCodePointCount downcase, size matches", codePointCount, 294 EXPECTED_RESULT_DOWNCASE.length); 295 for (int i = 0; i < codePointCount; ++i) { 296 assertEquals("copyCodePointsAndReturnCodePointCount position " + i, codePointArray[i], 297 EXPECTED_RESULT_DOWNCASE[i]); 298 } 299 300 final int JAVA_CHAR_COUNT = 8; 301 final int CODEPOINT_COUNT = 7; 302 codePointCount = StringUtils.copyCodePointsAndReturnCodePointCount(codePointArray, 303 STR_WITH_SUPPLEMENTARY_CHAR, 0, JAVA_CHAR_COUNT, false /* downCase */); 304 assertEquals("copyCodePointsAndReturnCodePointCount, size matches", codePointCount, 305 CODEPOINT_COUNT); 306 for (int i = 0; i < codePointCount; ++i) { 307 assertEquals("copyCodePointsAndReturnCodePointCount position " + i, codePointArray[i], 308 EXPECTED_RESULT[i]); 309 } 310 311 boolean exceptionHappened = false; 312 codePointArray = new int[5]; 313 try { 314 codePointCount = StringUtils.copyCodePointsAndReturnCodePointCount(codePointArray, 315 STR_WITH_SUPPLEMENTARY_CHAR, 0, JAVA_CHAR_COUNT, false /* downCase */); 316 } catch (ArrayIndexOutOfBoundsException e) { 317 exceptionHappened = true; 318 } 319 assertTrue("copyCodePointsAndReturnCodePointCount throws when array is too small", 320 exceptionHappened); 321 } 322 323 public void testGetTrailingSingleQuotesCount() { 324 assertEquals(0, StringUtils.getTrailingSingleQuotesCount("")); 325 assertEquals(1, StringUtils.getTrailingSingleQuotesCount("'")); 326 assertEquals(5, StringUtils.getTrailingSingleQuotesCount("'''''")); 327 assertEquals(0, StringUtils.getTrailingSingleQuotesCount("a")); 328 assertEquals(0, StringUtils.getTrailingSingleQuotesCount("'this")); 329 assertEquals(1, StringUtils.getTrailingSingleQuotesCount("'word'")); 330 assertEquals(0, StringUtils.getTrailingSingleQuotesCount("I'm")); 331 } 332 333 private static void assertSpanCount(final int expectedCount, final CharSequence cs) { 334 final int actualCount; 335 if (cs instanceof Spanned) { 336 final Spanned spanned = (Spanned) cs; 337 actualCount = spanned.getSpans(0, spanned.length(), Object.class).length; 338 } else { 339 actualCount = 0; 340 } 341 assertEquals(expectedCount, actualCount); 342 } 343 344 private static void assertSpan(final CharSequence cs, final Object expectedSpan, 345 final int expectedStart, final int expectedEnd, final int expectedFlags) { 346 assertTrue(cs instanceof Spanned); 347 final Spanned spanned = (Spanned) cs; 348 final Object[] actualSpans = spanned.getSpans(0, spanned.length(), Object.class); 349 for (Object actualSpan : actualSpans) { 350 if (actualSpan == expectedSpan) { 351 final int actualStart = spanned.getSpanStart(actualSpan); 352 final int actualEnd = spanned.getSpanEnd(actualSpan); 353 final int actualFlags = spanned.getSpanFlags(actualSpan); 354 assertEquals(expectedStart, actualStart); 355 assertEquals(expectedEnd, actualEnd); 356 assertEquals(expectedFlags, actualFlags); 357 return; 358 } 359 } 360 assertTrue(false); 361 } 362 363 public void testSplitCharSequenceWithSpan() { 364 // text: " a bcd efg hij " 365 // span1: ^^^^^^^ 366 // span2: ^^^^^ 367 // span3: ^ 368 final SpannableString spannableString = new SpannableString(" a bcd efg hij "); 369 final Object span1 = new Object(); 370 final Object span2 = new Object(); 371 final Object span3 = new Object(); 372 final int SPAN1_FLAGS = Spanned.SPAN_EXCLUSIVE_EXCLUSIVE; 373 final int SPAN2_FLAGS = Spanned.SPAN_EXCLUSIVE_INCLUSIVE; 374 final int SPAN3_FLAGS = Spanned.SPAN_INCLUSIVE_INCLUSIVE; 375 spannableString.setSpan(span1, 0, 7, SPAN1_FLAGS); 376 spannableString.setSpan(span2, 0, 5, SPAN2_FLAGS); 377 spannableString.setSpan(span3, 12, 13, SPAN3_FLAGS); 378 final CharSequence[] charSequencesFromSpanned = StringUtils.split( 379 spannableString, " ", true /* preserveTrailingEmptySegmengs */); 380 final CharSequence[] charSequencesFromString = StringUtils.split( 381 spannableString.toString(), " ", true /* preserveTrailingEmptySegmengs */); 382 383 384 assertEquals(7, charSequencesFromString.length); 385 assertEquals(7, charSequencesFromSpanned.length); 386 387 // text: "" 388 // span1: ^ 389 // span2: ^ 390 // span3: 391 assertEquals("", charSequencesFromString[0].toString()); 392 assertSpanCount(0, charSequencesFromString[0]); 393 assertEquals("", charSequencesFromSpanned[0].toString()); 394 assertSpanCount(2, charSequencesFromSpanned[0]); 395 assertSpan(charSequencesFromSpanned[0], span1, 0, 0, SPAN1_FLAGS); 396 assertSpan(charSequencesFromSpanned[0], span2, 0, 0, SPAN2_FLAGS); 397 398 // text: "a" 399 // span1: ^ 400 // span2: ^ 401 // span3: 402 assertEquals("a", charSequencesFromString[1].toString()); 403 assertSpanCount(0, charSequencesFromString[1]); 404 assertEquals("a", charSequencesFromSpanned[1].toString()); 405 assertSpanCount(2, charSequencesFromSpanned[1]); 406 assertSpan(charSequencesFromSpanned[1], span1, 0, 1, SPAN1_FLAGS); 407 assertSpan(charSequencesFromSpanned[1], span2, 0, 1, SPAN2_FLAGS); 408 409 // text: "bcd" 410 // span1: ^^^ 411 // span2: ^^ 412 // span3: 413 assertEquals("bcd", charSequencesFromString[2].toString()); 414 assertSpanCount(0, charSequencesFromString[2]); 415 assertEquals("bcd", charSequencesFromSpanned[2].toString()); 416 assertSpanCount(2, charSequencesFromSpanned[2]); 417 assertSpan(charSequencesFromSpanned[2], span1, 0, 3, SPAN1_FLAGS); 418 assertSpan(charSequencesFromSpanned[2], span2, 0, 2, SPAN2_FLAGS); 419 420 // text: "efg" 421 // span1: 422 // span2: 423 // span3: 424 assertEquals("efg", charSequencesFromString[3].toString()); 425 assertSpanCount(0, charSequencesFromString[3]); 426 assertEquals("efg", charSequencesFromSpanned[3].toString()); 427 assertSpanCount(0, charSequencesFromSpanned[3]); 428 429 // text: "hij" 430 // span1: 431 // span2: 432 // span3: ^ 433 assertEquals("hij", charSequencesFromString[4].toString()); 434 assertSpanCount(0, charSequencesFromString[4]); 435 assertEquals("hij", charSequencesFromSpanned[4].toString()); 436 assertSpanCount(1, charSequencesFromSpanned[4]); 437 assertSpan(charSequencesFromSpanned[4], span3, 1, 2, SPAN3_FLAGS); 438 439 // text: "" 440 // span1: 441 // span2: 442 // span3: 443 assertEquals("", charSequencesFromString[5].toString()); 444 assertSpanCount(0, charSequencesFromString[5]); 445 assertEquals("", charSequencesFromSpanned[5].toString()); 446 assertSpanCount(0, charSequencesFromSpanned[5]); 447 448 // text: "" 449 // span1: 450 // span2: 451 // span3: 452 assertEquals("", charSequencesFromString[6].toString()); 453 assertSpanCount(0, charSequencesFromString[6]); 454 assertEquals("", charSequencesFromSpanned[6].toString()); 455 assertSpanCount(0, charSequencesFromSpanned[6]); 456 } 457 458 public void testSplitCharSequencePreserveTrailingEmptySegmengs() { 459 assertEquals(1, StringUtils.split("", " ", 460 false /* preserveTrailingEmptySegmengs */).length); 461 assertEquals(1, StringUtils.split(new SpannedString(""), " ", 462 false /* preserveTrailingEmptySegmengs */).length); 463 464 assertEquals(1, StringUtils.split("", " ", 465 true /* preserveTrailingEmptySegmengs */).length); 466 assertEquals(1, StringUtils.split(new SpannedString(""), " ", 467 true /* preserveTrailingEmptySegmengs */).length); 468 469 assertEquals(0, StringUtils.split(" ", " ", 470 false /* preserveTrailingEmptySegmengs */).length); 471 assertEquals(0, StringUtils.split(new SpannedString(" "), " ", 472 false /* preserveTrailingEmptySegmengs */).length); 473 474 assertEquals(2, StringUtils.split(" ", " ", 475 true /* preserveTrailingEmptySegmengs */).length); 476 assertEquals(2, StringUtils.split(new SpannedString(" "), " ", 477 true /* preserveTrailingEmptySegmengs */).length); 478 479 assertEquals(3, StringUtils.split("a b c ", " ", 480 false /* preserveTrailingEmptySegmengs */).length); 481 assertEquals(3, StringUtils.split(new SpannedString("a b c "), " ", 482 false /* preserveTrailingEmptySegmengs */).length); 483 484 assertEquals(5, StringUtils.split("a b c ", " ", 485 true /* preserveTrailingEmptySegmengs */).length); 486 assertEquals(5, StringUtils.split(new SpannedString("a b c "), " ", 487 true /* preserveTrailingEmptySegmengs */).length); 488 489 assertEquals(6, StringUtils.split("a b ", " ", 490 false /* preserveTrailingEmptySegmengs */).length); 491 assertEquals(6, StringUtils.split(new SpannedString("a b "), " ", 492 false /* preserveTrailingEmptySegmengs */).length); 493 494 assertEquals(7, StringUtils.split("a b ", " ", 495 true /* preserveTrailingEmptySegmengs */).length); 496 assertEquals(7, StringUtils.split(new SpannedString("a b "), " ", 497 true /* preserveTrailingEmptySegmengs */).length); 498 } 499} 500