| /* |
| * 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 libcore.java.lang; |
| |
| import java.util.Arrays; |
| import java.util.IllegalFormatException; |
| import java.util.Locale; |
| import java.util.regex.PatternSyntaxException; |
| |
| public class OldStringTest extends junit.framework.TestCase { |
| |
| String hw1 = "HelloWorld"; |
| |
| String hw2 = "HelloWorld"; |
| |
| String hwlc = "helloworld"; |
| |
| String hwuc = "HELLOWORLD"; |
| |
| String comp11 = "Test String"; |
| |
| char[] buf = { 'W', 'o', 'r', 'l', 'd' }; |
| |
| public void test_charAtI() { |
| // Test for method char java.lang.String.charAt(int) |
| assertTrue("Incorrect character returned", hw1.charAt(5) == 'W' |
| && (hw1.charAt(1) != 'Z')); |
| |
| String testString = "Test String"; |
| try { |
| testString.charAt(testString.length()); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| |
| try { |
| testString.charAt(Integer.MAX_VALUE); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| |
| try { |
| testString.charAt(-1); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException iobe) { |
| //expected |
| } |
| } |
| |
| public void test_endsWithLjava_lang_String() { |
| assertFalse("Doesn't return false value.", hw1.endsWith("ld ")); |
| assertFalse("Doesn't return false value.", hw1.endsWith(" ")); |
| assertTrue("Returned incorrect value for empty string.", hw1.endsWith("")); |
| try { |
| hw1.endsWith(null); |
| fail("NullPointerException is not thrown."); |
| } catch(NullPointerException npe) { |
| //expected |
| } |
| } |
| |
| public void test_equalsLjava_lang_Object() { |
| assertTrue("String not equal", hw1.equals(hw2) && !(hw1.equals(comp11))); |
| } |
| |
| public void test_equalsIgnoreCaseLjava_lang_String() { |
| assertTrue("Returned false for equals strings.", hwlc |
| .equalsIgnoreCase(hwlc)); |
| |
| assertFalse("Returned true for different strings.", hwlc |
| .equalsIgnoreCase(hwuc + " ")); |
| } |
| |
| @SuppressWarnings("deprecation") |
| public void test_getBytesII$BI() { |
| try { |
| "Hello World".getBytes(-1, 1, null, 0); |
| fail("Expected IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException expected) { |
| } catch (NullPointerException expected) { |
| } |
| |
| try { |
| "Hello World".getBytes(6, 2, null, 0); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch (IndexOutOfBoundsException expected) { |
| } catch (NullPointerException expected) { |
| } |
| |
| try { |
| "Hello World".getBytes(2, 10, new byte[10], 4); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch (IndexOutOfBoundsException expected) { |
| } |
| } |
| |
| public void test_getCharsII$CI() { |
| try { |
| "Hello World".getChars(-1, 1, null, 0); |
| fail("Expected IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException expected) { |
| } catch (NullPointerException expected) { |
| } |
| |
| try { |
| "Hello World".getChars(6, 2, null, 0); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch (IndexOutOfBoundsException expected) { |
| } catch (NullPointerException expected) { |
| } |
| |
| try { |
| "Hello World".getChars(2, 10, new char[10], 4); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch (IndexOutOfBoundsException expected) { |
| } |
| } |
| |
| public void test_regionMatchesILjava_lang_StringII() { |
| assertFalse("Returned true for negative offset.", hw1.regionMatches(-1, |
| hw2, 2, 5)); |
| assertFalse("Returned true for negative offset.", hw1.regionMatches(2, |
| hw2, -1, 5)); |
| assertFalse("Returned true for toffset+len is greater than the length.", |
| hw1.regionMatches(5, hw2, 2, 6)); |
| assertFalse("Returned true for ooffset+len is greater than the length.", |
| hw1.regionMatches(2, hw2, 5, 6)); |
| } |
| |
| public void test_regionMatchesZILjava_lang_StringII() { |
| String bogusString = "xxcedkedkleiorem lvvwr e''' 3r3r 23r"; |
| |
| assertFalse("Returned true for negative offset.", hw1.regionMatches(true, |
| -1, hw2, 2, 5)); |
| assertFalse("Returned true for negative offset.", hw1.regionMatches(false, |
| 2, hw2, -1, 5)); |
| assertFalse("Returned true for toffset+len is greater than the length.", |
| hw1.regionMatches(true, 5, hw2, 2, 6)); |
| assertFalse("Returned true for ooffset+len is greater than the length.", |
| hw1.regionMatches(false, 2, hw2, 5, 6)); |
| |
| assertTrue("identical regions failed comparison", hwuc.regionMatches( |
| true, 0, hwlc, 0, hwuc.length())); |
| assertFalse("non identical regions failed comparison", hwuc.regionMatches( |
| false, 0, hwlc, 0, hwuc.length())); |
| } |
| |
| public void test_replaceCC() { |
| assertEquals("Returned incorrect string.", hw1, hw1.replace("!", ".")); |
| } |
| |
| public void test_replaceAll() { |
| String str = "!'123123.123HelloWorld!123123helloworld#"; |
| String [] patterns = {"[hw\\p{Upper}]", "(o|l){2,}", "([\'\"]?)(\\d+)", |
| "^!.*#$"}; |
| |
| String [] results = {"!\'123123.123?ello?orld!123123?ello?orld#", |
| "!\'123123.123He?World!123123he?world#", |
| "!?.?HelloWorld!?helloworld#", "?"}; |
| |
| for(int i = 0; i < patterns.length; i++) { |
| assertEquals("Returned incorrect string", |
| results[i], str.replaceAll(patterns[i], "?")); |
| } |
| |
| try { |
| str.replaceAll("[abc*", "?"); |
| fail("PatternSyntaxException is not thrown."); |
| } catch(PatternSyntaxException pse) { |
| //expected |
| } |
| } |
| |
| public void test_replaceFirst() { |
| String str = "!'123123.123HelloWorld!123123helloworld#"; |
| String [] patterns = {"[hw\\p{Upper}]", "(o|l){2,}", "([\'\"]?)(\\d+)", |
| "^!.*#$"}; |
| |
| String [] results = {"!'123123.123?elloWorld!123123helloworld#", |
| "!'123123.123He?World!123123helloworld#", |
| "!?.123HelloWorld!123123helloworld#", "?"}; |
| |
| for(int i = 0; i < patterns.length; i++) { |
| assertEquals("Returned incorrect string", |
| results[i], str.replaceFirst(patterns[i], "?")); |
| } |
| |
| try { |
| str.replaceFirst("[abc*", "?"); |
| fail("PatternSyntaxException is not thrown."); |
| } catch(PatternSyntaxException pse) { |
| //expected |
| } |
| } |
| |
| public void test_splitLString() { |
| String str = "!'123123.123HelloWorld!123123helloworld#"; |
| String [] patterns = {"[!.1]", "(\\d+).*e(l+)o.*orld"}; |
| String [][] results = {{"", "'","23", "23", "", "23HelloWorld", "", "23", |
| "23helloworld#"}, |
| {"!'", "#"}}; |
| |
| for(int i = 0; i < patterns.length; i++) { |
| assertTrue("Returned incorrect string array for pattern: " + |
| patterns[i], Arrays.equals(results[i], str.split(patterns[i]))); |
| } |
| |
| try { |
| str.split("[a}"); |
| fail("PatternSyntaxException is not thrown."); |
| } catch(PatternSyntaxException pse) { |
| //expected |
| } |
| } |
| |
| public void test_splitLStringLint() { |
| String str = "!'123123.123HelloWorld!123123helloworld#"; |
| String pattern = "[!.1]"; |
| String [][] results = {{"", "'","23", "23.123HelloWorld!123123helloworld#"}, |
| {"", "'","23", "23", "", "23HelloWorld", "", "23", |
| "23helloworld#"}}; |
| |
| assertTrue("Returned incorrect string array for limit 4", |
| Arrays.equals(results[0], str.split(pattern, 4))); |
| assertTrue("Returned incorrect string array for limit 9", |
| Arrays.equals(results[1], str.split(pattern, 9))); |
| assertTrue("Returned incorrect string array for limit 0", |
| Arrays.equals(results[1], str.split(pattern, 0))); |
| assertTrue("Returned incorrect string array for limit -1", |
| Arrays.equals(results[1], str.split(pattern, -1))); |
| assertTrue("Returned incorrect string array for limit 10", |
| Arrays.equals(results[1], str.split(pattern, 10))); |
| assertTrue("Returned incorrect string array for limit Integer.MAX_VALUE", |
| Arrays.equals(results[1], str.split(pattern, Integer.MAX_VALUE))); |
| |
| try { |
| str.split("[a}", 0); |
| fail("PatternSyntaxException is not thrown."); |
| } catch(PatternSyntaxException pse) { |
| //expected |
| } |
| } |
| |
| public void test_replaceLjava_langCharSequenceLjava_langCharSequence() { |
| assertEquals("Failed replace", "aaccdd", "aabbdd".replace( |
| new StringBuffer("bb"), "cc")); |
| assertEquals("Failed replace by bigger seq", "cccbccc", "aba".replace( |
| "a", "ccc")); |
| assertEquals("Failed replace by smaller seq", "$bba^", |
| "$aaaaa^".replace(new StringBuilder("aa"), "b")); |
| |
| try { |
| "".replace((CharSequence) null, "123".subSequence(0, 1)); |
| fail("NullPointerException is not thrown."); |
| } catch(NullPointerException npe) { |
| //expected |
| } |
| |
| try { |
| "".replace("123".subSequence(0, 1), (CharSequence) null); |
| fail("NullPointerException is not thrown."); |
| } catch(NullPointerException npe) { |
| //expected |
| } |
| } |
| |
| public void test_substringI() { |
| try { |
| hw1.substring(-1); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| hw1.substring(hw1.length() + 1); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| hw1.substring(Integer.MAX_VALUE); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| } |
| |
| public void test_substringII() { |
| try { |
| hw1.substring(-1, hw1.length()); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| hw1.substring(Integer.MAX_VALUE, hw1.length()); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| hw1.substring(0, Integer.MAX_VALUE); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| } |
| |
| public void test_subSequence() { |
| // Test for method java.lang.String java.lang.String.substring(int, int) |
| assertTrue("Incorrect substring returned", hw1.subSequence(0, 5).equals( |
| "Hello") && (hw1.subSequence(5, 10).equals("World"))); |
| assertTrue("not identical", hw1.subSequence(0, hw1.length()) == hw1); |
| |
| try { |
| hw1.subSequence(0, Integer.MAX_VALUE); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| hw1.subSequence(Integer.MAX_VALUE, hw1.length()); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| hw1.subSequence(-1, hw1.length()); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| } |
| |
| public void test_trim() { |
| assertEquals("Incorrect string returned", hw1, " HelloWorld ".trim()); |
| assertTrue("Incorrect string returned", " ".trim().equals("")); |
| } |
| |
| public void test_valueOf$C() { |
| assertEquals("Returned incorrect String", |
| "World", String.valueOf(buf)); |
| assertEquals("Returned incorrect String", |
| "", String.valueOf(new char[]{})); |
| try { |
| String.valueOf(null); |
| fail("NullPointerException was not thrown."); |
| } catch(NullPointerException npe) { |
| //expected |
| } |
| } |
| |
| public void test_valueOf$CII() { |
| char[] t = { 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' }; |
| |
| try { |
| String.valueOf(t, 0, t.length + 1); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| String.valueOf(t, 0, -1); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| |
| try { |
| String.valueOf(t, 0, Integer.MAX_VALUE); |
| fail("IndexOutOfBoundsException was not thrown."); |
| } catch(IndexOutOfBoundsException ioobe) { |
| //expected |
| } |
| } |
| |
| public void test_valueOfLjava_lang_Object() { |
| assertEquals("Incorrect value was returned for null.", |
| "null", String.valueOf((Object) null)); |
| } |
| |
| @SuppressWarnings("boxing") |
| public void test_format() { |
| assertEquals("3 2 1 4 3 2 1", String.format( |
| "%3$d %2$d %1$d %4$d %3$d %2$d %1$d", 1, 2, 3, 4)); |
| |
| assertEquals("empty format", "", String.format("", 123, this)); |
| try { |
| String.format(null); |
| fail("NPE is expected on null format"); |
| } catch (NullPointerException ok){} |
| |
| try { |
| String.format("%d%% of %s is 0x%x", "123"); |
| fail("IllegalFormatException was not thrown."); |
| } catch(IllegalFormatException ife) { |
| //expected |
| } |
| |
| try { |
| String.format("%tu", "123"); |
| fail("IllegalFormatException was not thrown."); |
| } catch(IllegalFormatException ife) { |
| //expected |
| } |
| |
| } |
| |
| @SuppressWarnings("boxing") |
| public void test_format_Locale() { |
| Locale l = new Locale("UK"); |
| assertEquals("13% of sum is 0x11", |
| String.format(l, "%d%% of %s is 0x%x", 13, "sum", 17)); |
| assertEquals("empty format", "", String.format("", 123, this)); |
| try { |
| String.format(l, null, ""); |
| fail("NPE is expected on null format"); |
| } catch (NullPointerException ok){} |
| |
| try { |
| String.format(l, "%d", "test"); |
| fail("IllegalFormatException wasn't thrown."); |
| } catch(IllegalFormatException ife) { |
| //expected |
| } |
| } |
| |
| public void test_matches() { |
| String[] patterns = { |
| "(a|b)*abb", |
| "(1*2*3*4*)*567", |
| "(a|b|c|d)*aab", |
| "(1|2|3|4|5|6|7|8|9|0)(1|2|3|4|5|6|7|8|9|0)*", |
| "(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)*", |
| "(a|b)*(a|b)*A(a|b)*lice.*", |
| "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(a|b|c|d|e|f|g|h|" |
| + "i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)*(1|2|3|4|5|6|7|8|9|0)*|while|for|struct|if|do", |
| |
| }; |
| |
| String[] patternsInc = { |
| "(ac)*bb", |
| "(1)*567", |
| "(c)*ab", |
| "(|8|9|0)(1|2|7|8|9|0)*", |
| "(z)", |
| "(a)*A(b)*lice.", |
| "(a|b|c|d|e)", |
| |
| }; |
| |
| String[][] strings = { |
| { "abb", "ababb", "abababbababb", "abababbababbabababbbbbabb" }, |
| { "213567", "12324567", "1234567", "213213567", |
| "21312312312567", "444444567" }, |
| { "abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab" }, |
| { "213234567", "3458", "0987654", "7689546432", "0398576", |
| "98432", "5" }, |
| { |
| "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", |
| "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" }, |
| { "ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa", |
| "abbbAbbbliceaaa", "Alice" }, |
| { "a123", "bnxnvgds156", "for", "while", "if", "struct" }, |
| { "xy" }, { "xy" }, { "xcy" } |
| |
| }; |
| |
| for (int i = 0; i < patterns.length; i++) { |
| for (int j = 0; j < strings[i].length; j++) { |
| assertTrue("Incorrect match: " + patterns[i] + " vs " |
| + strings[i][j], strings[i][j].matches(patterns[i])); |
| assertFalse("" + i, strings[i][j].matches(patternsInc[i])); |
| } |
| } |
| } |
| |
| public void test_indexOfI() { |
| assertEquals("Doesn't return -1 if there is no such character.", -1, |
| hw1.indexOf('q')); |
| } |
| |
| public void test_indexOfII() { |
| assertEquals("Doesn't return -1 if there is no such character.", -1, |
| hw1.indexOf('H', 2)); |
| |
| } |
| |
| public void test_indexOfLjava_lang_String() { |
| assertEquals("Doesn't return -1 for unknown string.", |
| -1, hw1.indexOf("Heo")); |
| } |
| } |