| /* 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 org.apache.harmony.regex.tests.java.util.regex; |
| |
| import dalvik.annotation.BrokenTest; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestLevel; |
| |
| import java.util.regex.Matcher; |
| import java.util.regex.Pattern; |
| import java.util.regex.PatternSyntaxException; |
| |
| import junit.framework.TestCase; |
| @TestTargetClass(Pattern.class) |
| /** |
| * Tests simple Pattern compilation and Matcher methods |
| * |
| */ |
| public class Pattern2Test extends TestCase { |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies matches(String regex, CharSequence input) method.", |
| method = "matches", |
| args = {java.lang.String.class, java.lang.CharSequence.class} |
| ) |
| public void testSimpleMatch() throws PatternSyntaxException { |
| Pattern p = Pattern.compile("foo.*"); |
| |
| Matcher m1 = p.matcher("foo123"); |
| assertTrue(m1.matches()); |
| assertTrue(m1.find(0)); |
| assertTrue(m1.lookingAt()); |
| |
| Matcher m2 = p.matcher("fox"); |
| assertFalse(m2.matches()); |
| assertFalse(m2.find(0)); |
| assertFalse(m2.lookingAt()); |
| |
| assertTrue(Pattern.matches("foo.*", "foo123")); |
| assertFalse(Pattern.matches("foo.*", "fox")); |
| |
| assertFalse(Pattern.matches("bar", "foobar")); |
| |
| assertTrue(Pattern.matches("", "")); |
| } |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "matcher", |
| args = {java.lang.CharSequence.class} |
| ) |
| }) |
| public void testCursors() { |
| Pattern p; |
| Matcher m; |
| |
| try { |
| p = Pattern.compile("foo"); |
| |
| m = p.matcher("foobar"); |
| assertTrue(m.find()); |
| assertEquals(0, m.start()); |
| assertEquals(3, m.end()); |
| assertFalse(m.find()); |
| |
| // Note: also testing reset here |
| m.reset(); |
| assertTrue(m.find()); |
| assertEquals(0, m.start()); |
| assertEquals(3, m.end()); |
| assertFalse(m.find()); |
| |
| m.reset("barfoobar"); |
| assertTrue(m.find()); |
| assertEquals(3, m.start()); |
| assertEquals(6, m.end()); |
| assertFalse(m.find()); |
| |
| m.reset("barfoo"); |
| assertTrue(m.find()); |
| assertEquals(3, m.start()); |
| assertEquals(6, m.end()); |
| assertFalse(m.find()); |
| |
| m.reset("foobarfoobarfoo"); |
| assertTrue(m.find()); |
| assertEquals(0, m.start()); |
| assertEquals(3, m.end()); |
| assertTrue(m.find()); |
| assertEquals(6, m.start()); |
| assertEquals(9, m.end()); |
| assertTrue(m.find()); |
| assertEquals(12, m.start()); |
| assertEquals(15, m.end()); |
| assertFalse(m.find()); |
| assertTrue(m.find(0)); |
| assertEquals(0, m.start()); |
| assertEquals(3, m.end()); |
| assertTrue(m.find(4)); |
| assertEquals(6, m.start()); |
| assertEquals(9, m.end()); |
| } catch (PatternSyntaxException e) { |
| System.out.println(e.getMessage()); |
| fail(); |
| } |
| } |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "matcher", |
| args = {java.lang.CharSequence.class} |
| ) |
| }) |
| public void testGroups() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| p = Pattern.compile("(p[0-9]*)#?(q[0-9]*)"); |
| |
| m = p.matcher("p1#q3p2q42p5p71p63#q888"); |
| assertTrue(m.find()); |
| assertEquals(0, m.start()); |
| assertEquals(5, m.end()); |
| assertEquals(2, m.groupCount()); |
| assertEquals(0, m.start(0)); |
| assertEquals(5, m.end(0)); |
| assertEquals(0, m.start(1)); |
| assertEquals(2, m.end(1)); |
| assertEquals(3, m.start(2)); |
| assertEquals(5, m.end(2)); |
| assertEquals("p1#q3", m.group()); |
| assertEquals("p1#q3", m.group(0)); |
| assertEquals("p1", m.group(1)); |
| assertEquals("q3", m.group(2)); |
| |
| assertTrue(m.find()); |
| assertEquals(5, m.start()); |
| assertEquals(10, m.end()); |
| assertEquals(2, m.groupCount()); |
| assertEquals(10, m.end(0)); |
| assertEquals(5, m.start(1)); |
| assertEquals(7, m.end(1)); |
| assertEquals(7, m.start(2)); |
| assertEquals(10, m.end(2)); |
| assertEquals("p2q42", m.group()); |
| assertEquals("p2q42", m.group(0)); |
| assertEquals("p2", m.group(1)); |
| assertEquals("q42", m.group(2)); |
| |
| assertTrue(m.find()); |
| assertEquals(15, m.start()); |
| assertEquals(23, m.end()); |
| assertEquals(2, m.groupCount()); |
| assertEquals(15, m.start(0)); |
| assertEquals(23, m.end(0)); |
| assertEquals(15, m.start(1)); |
| assertEquals(18, m.end(1)); |
| assertEquals(19, m.start(2)); |
| assertEquals(23, m.end(2)); |
| assertEquals("p63#q888", m.group()); |
| assertEquals("p63#q888", m.group(0)); |
| assertEquals("p63", m.group(1)); |
| assertEquals("q888", m.group(2)); |
| assertFalse(m.find()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "matcher", |
| args = {java.lang.CharSequence.class} |
| ) |
| }) |
| public void testReplace() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| // Note: examples from book, |
| // Hitchens, Ron, 2002, "Java NIO", O'Reilly, page 171 |
| p = Pattern.compile("a*b"); |
| |
| m = p.matcher("aabfooaabfooabfoob"); |
| assertTrue(m.replaceAll("-").equals("-foo-foo-foo-")); |
| assertTrue(m.replaceFirst("-").equals("-fooaabfooabfoob")); |
| |
| /* |
| * p = Pattern.compile ("\\p{Blank}"); |
| * |
| * m = p.matcher ("fee fie foe fum"); assertTrue |
| * (m.replaceFirst("-").equals ("fee-fie foe fum")); assertTrue |
| * (m.replaceAll("-").equals ("fee-fie-foe-fum")); |
| */ |
| |
| p = Pattern.compile("([bB])yte"); |
| |
| m = p.matcher("Byte for byte"); |
| assertTrue(m.replaceFirst("$1ite").equals("Bite for byte")); |
| assertTrue(m.replaceAll("$1ite").equals("Bite for bite")); |
| |
| p = Pattern.compile("\\d\\d\\d\\d([- ])"); |
| |
| m = p.matcher("card #1234-5678-1234"); |
| assertTrue(m.replaceFirst("xxxx$1").equals("card #xxxx-5678-1234")); |
| assertTrue(m.replaceAll("xxxx$1").equals("card #xxxx-xxxx-1234")); |
| |
| p = Pattern.compile("(up|left)( *)(right|down)"); |
| |
| m = p.matcher("left right, up down"); |
| assertTrue(m.replaceFirst("$3$2$1").equals("right left, up down")); |
| assertTrue(m.replaceAll("$3$2$1").equals("right left, down up")); |
| |
| p = Pattern.compile("([CcPp][hl]e[ea]se)"); |
| |
| m = p.matcher("I want cheese. Please."); |
| assertTrue(m.replaceFirst("<b> $1 </b>").equals( |
| "I want <b> cheese </b>. Please.")); |
| assertTrue(m.replaceAll("<b> $1 </b>").equals( |
| "I want <b> cheese </b>. <b> Please </b>.")); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "matcher", |
| args = {java.lang.CharSequence.class} |
| ) |
| }) |
| public void testEscapes() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| // Test \\ sequence |
| p = Pattern.compile("([a-z]+)\\\\([a-z]+);"); |
| m = p.matcher("fred\\ginger;abbott\\costello;jekell\\hyde;"); |
| assertTrue(m.find()); |
| assertEquals("fred", m.group(1)); |
| assertEquals("ginger", m.group(2)); |
| assertTrue(m.find()); |
| assertEquals("abbott", m.group(1)); |
| assertEquals("costello", m.group(2)); |
| assertTrue(m.find()); |
| assertEquals("jekell", m.group(1)); |
| assertEquals("hyde", m.group(2)); |
| assertFalse(m.find()); |
| |
| // Test \n, \t, \r, \f, \e, \a sequences |
| p = Pattern.compile("([a-z]+)[\\n\\t\\r\\f\\e\\a]+([a-z]+)"); |
| m = p.matcher("aa\nbb;cc\u0009\rdd;ee\u000C\u001Bff;gg\n\u0007hh"); |
| assertTrue(m.find()); |
| assertEquals("aa", m.group(1)); |
| assertEquals("bb", m.group(2)); |
| assertTrue(m.find()); |
| assertEquals("cc", m.group(1)); |
| assertEquals("dd", m.group(2)); |
| assertTrue(m.find()); |
| assertEquals("ee", m.group(1)); |
| assertEquals("ff", m.group(2)); |
| assertTrue(m.find()); |
| assertEquals("gg", m.group(1)); |
| assertEquals("hh", m.group(2)); |
| assertFalse(m.find()); |
| |
| // Test \\u and \\x sequences |
| /* p = Pattern.compile("([0-9]+)[\\u0020:\\x21];"); |
| m = p.matcher("11:;22 ;33-;44!;"); |
| assertTrue(m.find()); |
| assertEquals("11", m.group(1)); |
| assertTrue(m.find()); |
| assertEquals("22", m.group(1)); |
| assertTrue(m.find()); |
| assertEquals("44", m.group(1)); |
| assertFalse(m.find()); |
| */ |
| // Test invalid unicode sequences |
| /* try { |
| p = Pattern.compile("\\u"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\u;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\u002"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\u002;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| // Test invalid hex sequences |
| try { |
| p = Pattern.compile("\\x"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\x;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\xa"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\xa;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| */ |
| // Test \0 (octal) sequences (1, 2 and 3 digit) |
| p = Pattern.compile("([0-9]+)[\\07\\040\\0160];"); |
| m = p.matcher("11\u0007;22:;33 ;44p;"); |
| assertTrue(m.find()); |
| assertEquals("11", m.group(1)); |
| assertTrue(m.find()); |
| assertEquals("33", m.group(1)); |
| assertTrue(m.find()); |
| assertEquals("44", m.group(1)); |
| assertFalse(m.find()); |
| |
| // Test invalid octal sequences |
| try { |
| p = Pattern.compile("\\08"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| //originally contributed test did not check the result |
| //TODO: check what RI does here |
| // try { |
| // p = Pattern.compile("\\0477"); |
| // fail("PatternSyntaxException expected"); |
| // } catch (PatternSyntaxException e) { |
| // } |
| |
| try { |
| p = Pattern.compile("\\0"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\0;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| |
| // Test \c (control character) sequence |
| p = Pattern.compile("([0-9]+)[\\cA\\cB\\cC\\cD];"); |
| m = p.matcher("11\u0001;22:;33\u0002;44p;55\u0003;66\u0004;"); |
| assertTrue(m.find()); |
| assertEquals("11", m.group(1)); |
| assertTrue(m.find()); |
| assertEquals("33", m.group(1)); |
| assertTrue(m.find()); |
| assertEquals("55", m.group(1)); |
| assertTrue(m.find()); |
| assertEquals("66", m.group(1)); |
| assertFalse(m.find()); |
| |
| // More thorough control escape test |
| // Ensure that each escape matches exactly the corresponding |
| // character |
| // code and no others (well, from 0-255 at least) |
| int i, j; |
| for (i = 0; i < 26; i++) { |
| p = Pattern.compile("\\c" + Character.toString((char) ('A' + i))); |
| int match_char = -1; |
| for (j = 0; j < 255; j++) { |
| m = p.matcher(Character.toString((char) j)); |
| if (m.matches()) { |
| assertEquals(-1, match_char); |
| match_char = j; |
| } |
| } |
| assertTrue(match_char == i + 1); |
| } |
| |
| // Test invalid control escapes |
| // BEGIN android-removed |
| // ICU doesn't complain about illegal control sequences |
| // try { |
| // p = Pattern.compile("\\c"); |
| // fail("PatternSyntaxException expected"); |
| // } catch (PatternSyntaxException e) { |
| // } |
| // END android-removed |
| |
| //originally contributed test did not check the result |
| //TODO: check what RI does here |
| // try { |
| // p = Pattern.compile("\\c;"); |
| // fail("PatternSyntaxException expected"); |
| // } catch (PatternSyntaxException e) { |
| // } |
| // |
| // try { |
| // p = Pattern.compile("\\ca;"); |
| // fail("PatternSyntaxException expected"); |
| // } catch (PatternSyntaxException e) { |
| // } |
| // |
| // try { |
| // p = Pattern.compile("\\c4;"); |
| // fail("PatternSyntaxException expected"); |
| // } catch (PatternSyntaxException e) { |
| // } |
| } |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies patterns with different ranges of characters.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies patterns with different ranges of characters.", |
| method = "matcher", |
| args = {CharSequence.class} |
| ) |
| }) |
| public void testCharacterClasses() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| // Test one character range |
| p = Pattern.compile("[p].*[l]"); |
| m = p.matcher("paul"); |
| assertTrue(m.matches()); |
| m = p.matcher("pool"); |
| assertTrue(m.matches()); |
| m = p.matcher("pong"); |
| assertFalse(m.matches()); |
| m = p.matcher("pl"); |
| assertTrue(m.matches()); |
| |
| // Test two character range |
| p = Pattern.compile("[pm].*[lp]"); |
| m = p.matcher("prop"); |
| assertTrue(m.matches()); |
| m = p.matcher("mall"); |
| assertTrue(m.matches()); |
| m = p.matcher("pong"); |
| assertFalse(m.matches()); |
| m = p.matcher("pill"); |
| assertTrue(m.matches()); |
| |
| // Test range including [ and ] |
| p = Pattern.compile("[<\\[].*[\\]>]"); |
| m = p.matcher("<foo>"); |
| assertTrue(m.matches()); |
| m = p.matcher("[bar]"); |
| assertTrue(m.matches()); |
| m = p.matcher("{foobar]"); |
| assertFalse(m.matches()); |
| m = p.matcher("<pill]"); |
| assertTrue(m.matches()); |
| |
| // Test range using ^ |
| p = Pattern.compile("[^bc][a-z]+[tr]"); |
| m = p.matcher("pat"); |
| assertTrue(m.matches()); |
| m = p.matcher("liar"); |
| assertTrue(m.matches()); |
| m = p.matcher("car"); |
| assertFalse(m.matches()); |
| m = p.matcher("gnat"); |
| assertTrue(m.matches()); |
| |
| // Test character range using - |
| p = Pattern.compile("[a-z]_+[a-zA-Z]-+[0-9p-z]"); |
| m = p.matcher("d__F-8"); |
| assertTrue(m.matches()); |
| m = p.matcher("c_a-q"); |
| assertTrue(m.matches()); |
| m = p.matcher("a__R-a"); |
| assertFalse(m.matches()); |
| m = p.matcher("r_____d-----5"); |
| assertTrue(m.matches()); |
| |
| // Test range using unicode characters and unicode and hex escapes |
| p = Pattern.compile("[\\u1234-\\u2345]_+[a-z]-+[\u0001-\\x11]"); |
| m = p.matcher("\u2000_q-\u0007"); |
| assertTrue(m.matches()); |
| m = p.matcher("\u1234_z-\u0001"); |
| assertTrue(m.matches()); |
| m = p.matcher("r_p-q"); |
| assertFalse(m.matches()); |
| m = p.matcher("\u2345_____d-----\n"); |
| assertTrue(m.matches()); |
| |
| // BEGIN android-removed |
| // The "---" collides with ICU's "--" operator and is likely to be a user error |
| // anyway, so we simply comment this one out. |
| // // Test ranges including the "-" character |
| // p = Pattern.compile("[\\*-/]_+[---]!+[--AP]"); |
| // m = p.matcher("-_-!!A"); |
| // assertTrue(m.matches()); |
| // m = p.matcher("\u002b_-!!!-"); |
| // assertTrue(m.matches()); |
| // m = p.matcher("!_-!@"); |
| // assertFalse(m.matches()); |
| // m = p.matcher(",______-!!!!!!!P"); |
| // assertTrue(m.matches()); |
| // END android-removed |
| |
| // Test nested ranges |
| p = Pattern.compile("[pm[t]][a-z]+[[r]lp]"); |
| m = p.matcher("prop"); |
| assertTrue(m.matches()); |
| m = p.matcher("tsar"); |
| assertTrue(m.matches()); |
| m = p.matcher("pong"); |
| assertFalse(m.matches()); |
| m = p.matcher("moor"); |
| assertTrue(m.matches()); |
| |
| // Test character class intersection with && |
| // TODO: figure out what x&&y or any class with a null intersection |
| // set (like [[a-c]&&[d-f]]) might mean. It doesn't mean "match |
| // nothing" and doesn't mean "match anything" so I'm stumped. |
| p = Pattern.compile("[[a-p]&&[g-z]]+-+[[a-z]&&q]-+[x&&[a-z]]-+"); |
| m = p.matcher("h--q--x--"); |
| assertTrue(m.matches()); |
| m = p.matcher("hog--q-x-"); |
| assertTrue(m.matches()); |
| m = p.matcher("ape--q-x-"); |
| assertFalse(m.matches()); |
| m = p.matcher("mop--q-x----"); |
| assertTrue(m.matches()); |
| |
| // Test error cases with && |
| // BEGIN android-removed |
| // This is more of a bug, and ICU doesn't have this behavior. |
| // p = Pattern.compile("[&&[xyz]]"); |
| // m = p.matcher("&"); |
| // // System.out.println(m.matches()); |
| // m = p.matcher("x"); |
| // // System.out.println(m.matches()); |
| // m = p.matcher("y"); |
| // // System.out.println(m.matches()); |
| // END android-removed |
| p = Pattern.compile("[[xyz]&[axy]]"); |
| m = p.matcher("x"); |
| // System.out.println(m.matches()); |
| m = p.matcher("z"); |
| // System.out.println(m.matches()); |
| m = p.matcher("&"); |
| // System.out.println(m.matches()); |
| p = Pattern.compile("[abc[123]&&[345]def]"); |
| m = p.matcher("a"); |
| // System.out.println(m.matches()); |
| |
| // BEGIN android-removed |
| // This is more of a bug, and ICU doesn't have this behavior. |
| // p = Pattern.compile("[[xyz]&&]"); |
| // END android-removed |
| p = Pattern.compile("[[abc]&]"); |
| |
| try { |
| p = Pattern.compile("[[abc]&&"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| p = Pattern.compile("[[abc]\\&&[xyz]]"); |
| |
| p = Pattern.compile("[[abc]&\\&[xyz]]"); |
| |
| // Test 3-way intersection |
| p = Pattern.compile("[[a-p]&&[g-z]&&[d-k]]"); |
| m = p.matcher("g"); |
| assertTrue(m.matches()); |
| m = p.matcher("m"); |
| assertFalse(m.matches()); |
| |
| // Test nested intersection |
| p = Pattern.compile("[[[a-p]&&[g-z]]&&[d-k]]"); |
| m = p.matcher("g"); |
| assertTrue(m.matches()); |
| m = p.matcher("m"); |
| assertFalse(m.matches()); |
| |
| // Test character class subtraction with && and ^ |
| p = Pattern.compile("[[a-z]&&[^aeiou]][aeiou][[^xyz]&&[a-z]]"); |
| m = p.matcher("pop"); |
| assertTrue(m.matches()); |
| m = p.matcher("tag"); |
| assertTrue(m.matches()); |
| m = p.matcher("eat"); |
| assertFalse(m.matches()); |
| m = p.matcher("tax"); |
| assertFalse(m.matches()); |
| m = p.matcher("zip"); |
| assertTrue(m.matches()); |
| |
| // Test . (DOT), with and without DOTALL |
| // Note: DOT not allowed in character classes |
| p = Pattern.compile(".+/x.z"); |
| m = p.matcher("!$/xyz"); |
| assertTrue(m.matches()); |
| m = p.matcher("%\n\r/x\nz"); |
| assertFalse(m.matches()); |
| p = Pattern.compile(".+/x.z", Pattern.DOTALL); |
| m = p.matcher("%\n\r/x\nz"); |
| assertTrue(m.matches()); |
| |
| // Test \d (digit) |
| p = Pattern.compile("\\d+[a-z][\\dx]"); |
| m = p.matcher("42a6"); |
| assertTrue(m.matches()); |
| m = p.matcher("21zx"); |
| assertTrue(m.matches()); |
| m = p.matcher("ab6"); |
| assertFalse(m.matches()); |
| m = p.matcher("56912f9"); |
| assertTrue(m.matches()); |
| |
| // Test \D (not a digit) |
| p = Pattern.compile("\\D+[a-z]-[\\D3]"); |
| m = p.matcher("za-p"); |
| assertTrue(m.matches()); |
| m = p.matcher("%!e-3"); |
| assertTrue(m.matches()); |
| m = p.matcher("9a-x"); |
| assertFalse(m.matches()); |
| m = p.matcher("\u1234pp\ny-3"); |
| assertTrue(m.matches()); |
| |
| // Test \s (whitespace) |
| p = Pattern.compile("<[a-zA-Z]+\\s+[0-9]+[\\sx][^\\s]>"); |
| m = p.matcher("<cat \t1\fx>"); |
| assertTrue(m.matches()); |
| m = p.matcher("<cat \t1\f >"); |
| assertFalse(m.matches()); |
| m = p |
| .matcher("xyz <foo\n\r22 5> <pp \t\n\f\r \u000b41x\u1234><pp \nx7\rc> zzz"); |
| assertTrue(m.find()); |
| assertTrue(m.find()); |
| assertFalse(m.find()); |
| |
| // Test \S (not whitespace) |
| p = Pattern.compile("<[a-z] \\S[0-9][\\S\n]+[^\\S]221>"); |
| m = p.matcher("<f $0**\n** 221>"); |
| assertTrue(m.matches()); |
| m = p.matcher("<x 441\t221>"); |
| assertTrue(m.matches()); |
| m = p.matcher("<z \t9\ng 221>"); |
| assertFalse(m.matches()); |
| m = p.matcher("<z 60\ngg\u1234\f221>"); |
| assertTrue(m.matches()); |
| p = Pattern.compile("<[a-z] \\S[0-9][\\S\n]+[^\\S]221[\\S&&[^abc]]>"); |
| m = p.matcher("<f $0**\n** 221x>"); |
| assertTrue(m.matches()); |
| m = p.matcher("<x 441\t221z>"); |
| assertTrue(m.matches()); |
| m = p.matcher("<x 441\t221 >"); |
| assertFalse(m.matches()); |
| m = p.matcher("<x 441\t221c>"); |
| assertFalse(m.matches()); |
| m = p.matcher("<z \t9\ng 221x>"); |
| assertFalse(m.matches()); |
| m = p.matcher("<z 60\ngg\u1234\f221\u0001>"); |
| assertTrue(m.matches()); |
| |
| // Test \w (ascii word) |
| p = Pattern.compile("<\\w+\\s[0-9]+;[^\\w]\\w+/[\\w$]+;"); |
| m = p.matcher("<f1 99;!foo5/a$7;"); |
| assertTrue(m.matches()); |
| m = p.matcher("<f$ 99;!foo5/a$7;"); |
| assertFalse(m.matches()); |
| m = p |
| .matcher("<abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789 99;!foo5/a$7;"); |
| assertTrue(m.matches()); |
| |
| // Test \W (not an ascii word) |
| p = Pattern.compile("<\\W\\w+\\s[0-9]+;[\\W_][^\\W]+\\s[0-9]+;"); |
| m = p.matcher("<$foo3\n99;_bar\t0;"); |
| assertTrue(m.matches()); |
| m = p.matcher("<hh 99;_g 0;"); |
| assertFalse(m.matches()); |
| m = p.matcher("<*xx\t00;^zz\f11;"); |
| assertTrue(m.matches()); |
| |
| // Test x|y pattern |
| // TODO |
| } |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for patterns with POSIX characters.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for patterns with POSIX characters.", |
| method = "matcher", |
| args = {java.lang.CharSequence.class} |
| ) |
| }) |
| public void testPOSIXGroups() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| // Test POSIX groups using \p and \P (in the group and not in the group) |
| // Groups are Lower, Upper, ASCII, Alpha, Digit, XDigit, Alnum, Punct, |
| // Graph, Print, Blank, Space, Cntrl |
| // Test \p{Lower} |
| /* |
| * FIXME: Requires complex range processing |
| * p = Pattern.compile("<\\p{Lower}\\d\\P{Lower}:[\\p{Lower}Z]\\s[^\\P{Lower}]>"); |
| * m = p.matcher("<a4P:g x>"); assertTrue(m.matches()); m = |
| * p.matcher("<p4%:Z\tq>"); assertTrue(m.matches()); m = |
| * p.matcher("<A6#:e e>"); assertFalse(m.matches()); |
| */ |
| p = Pattern.compile("\\p{Lower}+"); |
| m = p.matcher("abcdefghijklmnopqrstuvwxyz"); |
| assertTrue(m.matches()); |
| |
| // Invalid uses of \p{Lower} |
| try { |
| p = Pattern.compile("\\p"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\p;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\p{"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\p{;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\p{Lower"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\p{Lower;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| // Test \p{Upper} |
| /* |
| * FIXME: Requires complex range processing |
| * p = Pattern.compile("<\\p{Upper}\\d\\P{Upper}:[\\p{Upper}z]\\s[^\\P{Upper}]>"); |
| * m = p.matcher("<A4p:G X>"); assertTrue(m.matches()); m = |
| * p.matcher("<P4%:z\tQ>"); assertTrue(m.matches()); m = |
| * p.matcher("<a6#:E E>"); assertFalse(m.matches()); |
| */ |
| p = Pattern.compile("\\p{Upper}+"); |
| m = p.matcher("ABCDEFGHIJKLMNOPQRSTUVWXYZ"); |
| assertTrue(m.matches()); |
| |
| // Invalid uses of \p{Upper} |
| try { |
| p = Pattern.compile("\\p{Upper"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\p{Upper;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| // Test \p{ASCII} |
| /* |
| * FIXME: Requires complex range processing p = Pattern.compile("<\\p{ASCII}\\d\\P{ASCII}:[\\p{ASCII}\u1234]\\s[^\\P{ASCII}]>"); |
| * m = p.matcher("<A4\u0080:G X>"); assertTrue(m.matches()); m = |
| * p.matcher("<P4\u00ff:\u1234\t\n>"); assertTrue(m.matches()); m = |
| * p.matcher("<\u00846#:E E>"); assertFalse(m.matches()) |
| */ |
| int i; |
| p = Pattern.compile("\\p{ASCII}"); |
| for (i = 0; i < 0x80; i++) { |
| m = p.matcher(Character.toString((char) i)); |
| assertTrue(m.matches()); |
| } |
| for (; i < 0xff; i++) { |
| m = p.matcher(Character.toString((char) i)); |
| assertFalse(m.matches()); |
| } |
| |
| // Invalid uses of \p{ASCII} |
| try { |
| p = Pattern.compile("\\p{ASCII"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| try { |
| p = Pattern.compile("\\p{ASCII;"); |
| fail("PatternSyntaxException expected"); |
| } catch (PatternSyntaxException e) { |
| } |
| |
| // Test \p{Alpha} |
| // TODO |
| |
| // Test \p{Digit} |
| // TODO |
| |
| // Test \p{XDigit} |
| // TODO |
| |
| // Test \p{Alnum} |
| // TODO |
| |
| // Test \p{Punct} |
| // TODO |
| |
| // Test \p{Graph} |
| // TODO |
| |
| // Test \p{Print} |
| // TODO |
| |
| // Test \p{Blank} |
| // TODO |
| |
| // Test \p{Space} |
| // TODO |
| |
| // Test \p{Cntrl} |
| // TODO |
| } |
| @TestTargetNew( |
| level = TestLevel.ADDITIONAL, |
| notes = "", |
| method = "!", |
| args = {} |
| ) |
| public void testUnicodeCategories() throws PatternSyntaxException { |
| // Test Unicode categories using \p and \P |
| // One letter codes: L, M, N, P, S, Z, C |
| // Two letter codes: Lu, Nd, Sc, Sm, ... |
| // See java.lang.Character and Unicode standard for complete list |
| // TODO |
| // Test \p{L} |
| // TODO |
| |
| // Test \p{N} |
| // TODO |
| |
| // Test two letter codes: |
| // From unicode.org: |
| // Lu |
| // Ll |
| // Lt |
| // Lm |
| // Lo |
| // Mn |
| // Mc |
| // Me |
| // Nd |
| // Nl |
| // No |
| // Pc |
| // Pd |
| // Ps |
| // Pe |
| // Pi |
| // Pf |
| // Po |
| // Sm |
| // Sc |
| // Sk |
| // So |
| // Zs |
| // Zl |
| // Zp |
| // Cc |
| // Cf |
| // Cs |
| // Co |
| // Cn |
| |
| // TODO add more tests per category |
| //{"Cc", "\u0000", "-\u0041"}, |
| testCategory("Cf", "\u202B"); |
| testCategory("Co", "\uE000"); |
| testCategory("Cs", "\uD800"); |
| testCategory("Ll", "a", "b", "x", "y", "z", "-A", "-Z"); |
| testCategory("Lm", "\u02B9"); |
| testCategory("Lu", "B", "C", "-c"); |
| testCategory("Lo", "\u05E2"); |
| testCategory("Lt", "\u01C5"); |
| testCategory("Mc", "\u0903"); |
| testCategory("Me", "\u06DE"); |
| testCategory("Mn", "\u0300"); |
| testCategory("Nd", "\u0030"); |
| testCategory("Nl", "\u2164"); |
| testCategory("No", "\u0BF0"); |
| // testCategory("Pc", "\u30FB"); |
| testCategory("Pd", "\u2015"); |
| testCategory("Pe", "\u207E"); |
| testCategory("Po", "\u00B7"); |
| testCategory("Ps", "\u0F3C"); |
| testCategory("Sc", "\u20A0"); |
| testCategory("Sk", "\u00B8"); |
| testCategory("Sm", "\u002B"); |
| testCategory("So", "\u0B70"); |
| testCategory("Zl", "\u2028"); |
| // testCategory("Pi", "\u200C"); |
| testCategory("Zp", "\u2029"); |
| } |
| |
| private void testCategory(String cat, String... matches) { |
| String pa = "{"+cat+"}"; |
| String pat = "\\p"+pa; |
| String npat = "\\P"+pa; |
| Pattern p = Pattern.compile(pat); |
| Pattern pn = Pattern.compile(npat); |
| for (int j = 0; j < matches.length; j++) { |
| String t = matches[j]; |
| boolean invert = t.startsWith("-"); |
| if (invert) { |
| // test negative case, expected to fail |
| t = t.substring(1); |
| assertFalse("expected '"+t+"' to not be matched " + |
| "by pattern '"+pat, p.matcher(t).matches()); |
| assertTrue("expected '"+t+"' to " + |
| "be matched by pattern '"+npat, pn.matcher(t).matches()); |
| } else { |
| assertTrue("expected '"+t+"' to be matched " + |
| "by pattern '"+pat, p.matcher(t).matches()); |
| assertFalse("expected '"+t+"' to " + |
| "not be matched by pattern '"+npat, pn.matcher(t).matches()); |
| } |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies matcher(CharSequence input) method for input specified by Unicode blocks.", |
| method = "matcher", |
| args = {java.lang.CharSequence.class} |
| ) |
| public void testUnicodeBlocks() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| int i, j; |
| |
| // Test Unicode blocks using \p and \P |
| // FIXME: |
| // Note that LatinExtended-B and ArabicPresentations-B are unrecognized |
| // by the reference JDK. |
| for (i = 0; i < UBlocks.length; i++) { |
| /* |
| * p = Pattern.compile("\\p{"+UBlocks[i].name+"}"); |
| * |
| * if (UBlocks[i].low > 0) { m = |
| * p.matcher(Character.toString((char)(UBlocks[i].low-1))); |
| * assertFalse(m.matches()); } for (j=UBlocks[i].low; j <= |
| * UBlocks[i].high; j++) { m = |
| * p.matcher(Character.toString((char)j)); |
| * assertTrue(m.matches()); } if (UBlocks[i].high < 0xFFFF) { m = |
| * p.matcher(Character.toString((char)(UBlocks[i].high+1))); |
| * assertFalse(m.matches()); } |
| * |
| * p = Pattern.compile("\\P{"+UBlocks[i].name+"}"); |
| * |
| * if (UBlocks[i].low > 0) { m = |
| * p.matcher(Character.toString((char)(UBlocks[i].low-1))); |
| * assertTrue(m.matches()); } for (j=UBlocks[i].low; j < |
| * UBlocks[i].high; j++) { m = |
| * p.matcher(Character.toString((char)j)); |
| * assertFalse(m.matches()); } if (UBlocks[i].high < 0xFFFF) { m = |
| * p.matcher(Character.toString((char)(UBlocks[i].high+1))); |
| * assertTrue(m.matches()); } |
| */ |
| |
| p = Pattern.compile("\\p{In" + UBlocks[i].name + "}"); |
| // BEGIN android-changed |
| // Added the name of the block under test to the assertion to get more output. |
| |
| if (UBlocks[i].low > 0) { |
| m = p.matcher(Character.toString((char) (UBlocks[i].low - 1))); |
| assertFalse(UBlocks[i].name, m.matches()); |
| } |
| for (j = UBlocks[i].low; j <= UBlocks[i].high; j++) { |
| m = p.matcher(Character.toString((char) j)); |
| assertTrue(UBlocks[i].name, m.matches()); |
| } |
| if (UBlocks[i].high < 0xFFFF) { |
| m = p.matcher(Character.toString((char) (UBlocks[i].high + 1))); |
| assertFalse(UBlocks[i].name, m.matches()); |
| } |
| |
| p = Pattern.compile("\\P{In" + UBlocks[i].name + "}"); |
| |
| if (UBlocks[i].low > 0) { |
| m = p.matcher(Character.toString((char) (UBlocks[i].low - 1))); |
| assertTrue(UBlocks[i].name, m.matches()); |
| } |
| for (j = UBlocks[i].low; j < UBlocks[i].high; j++) { |
| m = p.matcher(Character.toString((char) j)); |
| assertFalse(UBlocks[i].name, m.matches()); |
| } |
| if (UBlocks[i].high < 0xFFFF) { |
| m = p.matcher(Character.toString((char) (UBlocks[i].high + 1))); |
| assertTrue(UBlocks[i].name, m.matches()); |
| } |
| |
| // END android-changed |
| } |
| } |
| @TestTargetNew( |
| level = TestLevel.ADDITIONAL, |
| notes = "these tests are still partial, see TODO in the code", |
| method = "!", |
| args = {} |
| ) |
| public void testCapturingGroups() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| // Test simple capturing groups |
| p = Pattern.compile("(a+)b"); |
| m = p.matcher("aaaaaaaab"); |
| assertTrue(m.matches()); |
| assertEquals(1, m.groupCount()); |
| assertEquals("aaaaaaaa", m.group(1)); |
| |
| p = Pattern.compile("((an)+)((as)+)"); |
| m = p.matcher("ananas"); |
| assertTrue(m.matches()); |
| assertEquals(4, m.groupCount()); |
| assertEquals("ananas", m.group(0)); |
| assertEquals("anan", m.group(1)); |
| assertEquals("an", m.group(2)); |
| assertEquals("as", m.group(3)); |
| assertEquals("as", m.group(4)); |
| |
| // Test grouping without capture (?:...) |
| p = Pattern.compile("(?:(?:an)+)(as)"); |
| m = p.matcher("ananas"); |
| assertTrue(m.matches()); |
| assertEquals(1, m.groupCount()); |
| assertEquals("as", m.group(1)); |
| try { |
| m.group(2); |
| fail("expected IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException ioobe) { |
| // expected |
| } |
| |
| // Test combination of grouping and capture |
| // TODO |
| |
| // Test \<num> sequence with capturing and non-capturing groups |
| // TODO |
| |
| // Test \<num> with <num> out of range |
| p = Pattern.compile("((an)+)as\\1"); |
| m = p.matcher("ananasanan"); |
| assertTrue(m.matches()); |
| |
| try { |
| p = Pattern.compile("((an)+)as\\4"); |
| fail("expected PatternSyntaxException"); |
| } catch (PatternSyntaxException pse) { |
| // expected |
| } |
| |
| } |
| @TestTargetNew( |
| level = TestLevel.ADDITIONAL, |
| notes = "", |
| method = "!", |
| args = {} |
| ) |
| public void testRepeats() { |
| Pattern p; |
| Matcher m; |
| |
| // Test ? |
| p = Pattern.compile("(abc)?c"); |
| m = p.matcher("abcc"); |
| assertTrue(m.matches()); |
| m = p.matcher("c"); |
| assertTrue(m.matches()); |
| m = p.matcher("cc"); |
| assertFalse(m.matches()); |
| m = p.matcher("abcabcc"); |
| assertFalse(m.matches()); |
| |
| // Test * |
| p = Pattern.compile("(abc)*c"); |
| m = p.matcher("abcc"); |
| assertTrue(m.matches()); |
| m = p.matcher("c"); |
| assertTrue(m.matches()); |
| m = p.matcher("cc"); |
| assertFalse(m.matches()); |
| m = p.matcher("abcabcc"); |
| assertTrue(m.matches()); |
| |
| // Test + |
| p = Pattern.compile("(abc)+c"); |
| m = p.matcher("abcc"); |
| assertTrue(m.matches()); |
| m = p.matcher("c"); |
| assertFalse(m.matches()); |
| m = p.matcher("cc"); |
| assertFalse(m.matches()); |
| m = p.matcher("abcabcc"); |
| assertTrue(m.matches()); |
| |
| // Test {<num>}, including 0, 1 and more |
| p = Pattern.compile("(abc){0}c"); |
| m = p.matcher("abcc"); |
| assertFalse(m.matches()); |
| m = p.matcher("c"); |
| assertTrue(m.matches()); |
| |
| p = Pattern.compile("(abc){1}c"); |
| m = p.matcher("abcc"); |
| assertTrue(m.matches()); |
| m = p.matcher("c"); |
| assertFalse(m.matches()); |
| m = p.matcher("abcabcc"); |
| assertFalse(m.matches()); |
| |
| p = Pattern.compile("(abc){2}c"); |
| m = p.matcher("abcc"); |
| assertFalse(m.matches()); |
| m = p.matcher("c"); |
| assertFalse(m.matches()); |
| m = p.matcher("cc"); |
| assertFalse(m.matches()); |
| m = p.matcher("abcabcc"); |
| assertTrue(m.matches()); |
| |
| // Test {<num>,}, including 0, 1 and more |
| // TODO |
| |
| // Test {<n1>,<n2>}, with n1 < n2, n1 = n2 and n1 > n2 (illegal?) |
| // TODO |
| } |
| @TestTargetNew( |
| level = TestLevel.ADDITIONAL, |
| notes = "", |
| method = "!", |
| args = {} |
| ) |
| public void testAnchors() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| // Test ^, default and MULTILINE |
| p = Pattern.compile("^abc\\n^abc", Pattern.MULTILINE); |
| m = p.matcher("abc\nabc"); |
| assertTrue(m.matches()); |
| |
| p = Pattern.compile("^abc\\n^abc"); |
| m = p.matcher("abc\nabc"); |
| assertFalse(m.matches()); |
| |
| // Test $, default and MULTILINE |
| // TODO |
| |
| // Test \b (word boundary) |
| // TODO |
| |
| // Test \B (not a word boundary) |
| // TODO |
| |
| // Test \A (beginning of string) |
| // TODO |
| |
| // Test \Z (end of string) |
| // TODO |
| |
| // Test \z (end of string) |
| // TODO |
| |
| // Test \G |
| // TODO |
| |
| // Test positive lookahead using (?=...) |
| // TODO |
| |
| // Test negative lookahead using (?!...) |
| // TODO |
| |
| // Test positive lookbehind using (?<=...) |
| // TODO |
| |
| // Test negative lookbehind using (?<!...) |
| // TODO |
| } |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method and matcher for created pattern.", |
| method = "matcher", |
| args = {java.lang.CharSequence.class} |
| ) |
| }) |
| public void testMisc() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| |
| // Test (?>...) |
| // TODO |
| |
| // Test (?onflags-offflags) |
| // Valid flags are i,m,d,s,u,x |
| // TODO |
| |
| // Test (?onflags-offflags:...) |
| // TODO |
| |
| // Test \Q, \E |
| p = Pattern.compile("[a-z]+;\\Q[a-z]+;\\Q(foo.*);\\E[0-9]+"); |
| m = p.matcher("abc;[a-z]+;\\Q(foo.*);411"); |
| assertTrue(m.matches()); |
| m = p.matcher("abc;def;foo42;555"); |
| assertFalse(m.matches()); |
| m = p.matcher("abc;\\Qdef;\\Qfoo99;\\E123"); |
| assertFalse(m.matches()); |
| |
| p = Pattern.compile("[a-z]+;(foo[0-9]-\\Q(...)\\E);[0-9]+"); |
| m = p.matcher("abc;foo5-(...);123"); |
| assertTrue(m.matches()); |
| assertEquals("foo5-(...)", m.group(1)); |
| m = p.matcher("abc;foo9-(xxx);789"); |
| assertFalse(m.matches()); |
| |
| p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\Q$-\\E]+);[0-9]+"); |
| m = p.matcher("abc;bar0-def$-;123"); |
| assertTrue(m.matches()); |
| |
| // FIXME: |
| // This should work the same as the pattern above but fails with the |
| // the reference JDK |
| p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\Q-$\\E]+);[0-9]+"); |
| m = p.matcher("abc;bar0-def$-;123"); |
| // assertTrue(m.matches()); |
| |
| // FIXME: |
| // This should work too .. it looks as if just about anything that |
| // has more |
| // than one character between \Q and \E is broken in the the reference JDK |
| p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\Q[0-9]\\E]+);[0-9]+"); |
| m = p.matcher("abc;bar0-def[99]-]0x[;123"); |
| // assertTrue(m.matches()); |
| |
| // This is the same as above but with explicit escapes .. and this |
| // does work |
| // on the the reference JDK |
| p = Pattern.compile("[a-z]+;(bar[0-9]-[a-z\\[0\\-9\\]]+);[0-9]+"); |
| m = p.matcher("abc;bar0-def[99]-]0x[;123"); |
| assertTrue(m.matches()); |
| |
| // Test #<comment text> |
| // TODO |
| } |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) method.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ) |
| public void testCompile1() throws PatternSyntaxException { |
| Pattern pattern = Pattern |
| .compile("[0-9A-Za-z][0-9A-Za-z\\x2e\\x3a\\x2d\\x5f]*"); |
| String name = "iso-8859-1"; |
| assertTrue(pattern.matcher(name).matches()); |
| } |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex, int flag) method.", |
| method = "compile", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void testCompile2() throws PatternSyntaxException { |
| String findString = "\\Qimport\\E"; |
| |
| Pattern pattern = Pattern.compile(findString, 0); |
| Matcher matcher = pattern.matcher(new String( |
| "import a.A;\n\n import b.B;\nclass C {}")); |
| |
| assertTrue(matcher.find(0)); |
| } |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) and compile(String regex, int flag) method for specific patterns.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) and compile(String regex, int flag) method for specific patterns.", |
| method = "compile", |
| args = {java.lang.String.class, int.class} |
| ) |
| }) |
| public void testCompile3() throws PatternSyntaxException { |
| Pattern p; |
| Matcher m; |
| p = Pattern.compile("a$"); |
| m = p.matcher("a\n"); |
| assertTrue(m.find()); |
| assertEquals("a", m.group()); |
| assertFalse(m.find()); |
| |
| p = Pattern.compile("(a$)"); |
| m = p.matcher("a\n"); |
| assertTrue(m.find()); |
| assertEquals("a", m.group()); |
| assertEquals("a", m.group(1)); |
| assertFalse(m.find()); |
| |
| p = Pattern.compile("^.*$", Pattern.MULTILINE); |
| |
| m = p.matcher("a\n"); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertEquals("a", m.group()); |
| assertFalse(m.find()); |
| |
| m = p.matcher("a\nb\n"); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertEquals("a", m.group()); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertEquals("b", m.group()); |
| assertFalse(m.find()); |
| |
| m = p.matcher("a\nb"); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertEquals("a", m.group()); |
| assertTrue(m.find()); |
| assertEquals("b", m.group()); |
| assertFalse(m.find()); |
| |
| m = p.matcher("\naa\r\nbb\rcc\n\n"); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertTrue(m.group().equals("")); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertEquals("aa", m.group()); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertEquals("bb", m.group()); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertEquals("cc", m.group()); |
| assertTrue(m.find()); |
| // System.out.println("["+m.group()+"]"); |
| assertTrue(m.group().equals("")); |
| assertFalse(m.find()); |
| |
| m = p.matcher("a"); |
| assertTrue(m.find()); |
| assertEquals("a", m.group()); |
| assertFalse(m.find()); |
| |
| // BEGIN android-removed |
| // Makes no sense to duplicate this weird behavior |
| // m = p.matcher(""); |
| // // FIXME: This matches the reference behaviour but is |
| // // inconsistent with matching "a" - ie. the end of the |
| // // target string should match against $ always but this |
| // // appears to work with the null string only when not in |
| // // multiline mode (see below) |
| // assertFalse(m.find()); |
| // END android-removed |
| |
| p = Pattern.compile("^.*$"); |
| m = p.matcher(""); |
| assertTrue(m.find()); |
| assertTrue(m.group().equals("")); |
| assertFalse(m.find()); |
| } |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex, int flag) method for specific string.", |
| method = "compile", |
| args = {java.lang.String.class, int.class} |
| ) |
| public void testCompile4() throws PatternSyntaxException { |
| String findString = "\\Qpublic\\E"; |
| StringBuffer text = new StringBuffer(" public class Class {\n" |
| + " public class Class {"); |
| |
| Pattern pattern = Pattern.compile(findString, 0); |
| Matcher matcher = pattern.matcher(text); |
| |
| boolean found = matcher.find(); |
| assertTrue(found); |
| assertEquals(4, matcher.start()); |
| if (found) { |
| // modify text |
| text.delete(0, text.length()); |
| text.append("Text have been changed."); |
| matcher.reset(text); |
| } |
| |
| found = matcher.find(); |
| assertFalse(found); |
| } |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies compile(String regex) methodfor specific string.", |
| method = "compile", |
| args = {java.lang.String.class} |
| ) |
| public void testCompile5() throws PatternSyntaxException { |
| Pattern p = Pattern.compile("^[0-9]"); |
| String s[] = p.split("12", -1); |
| assertEquals("", s[0]); |
| assertEquals("2", s[1]); |
| assertEquals(2, s.length); |
| } |
| |
| // public void testCompile6() { |
| // String regex = "[\\p{L}[\\p{Mn}[\\p{Pc}[\\p{Nd}[\\p{Nl}[\\p{Sc}]]]]]]+"; |
| // String regex = "[\\p{L}\\p{Mn}\\p{Pc}\\p{Nd}\\p{Nl}\\p{Sc}]+"; |
| // try { |
| // Pattern pattern = Pattern.compile(regex, Pattern.MULTILINE); |
| // assertTrue(true); |
| // } catch (PatternSyntaxException e) { |
| // System.out.println(e.getMessage()); |
| // assertTrue(false); |
| // } |
| // } |
| |
| private static class UBInfo { |
| public UBInfo(int low, int high, String name) { |
| this.name = name; |
| this.low = low; |
| this.high = high; |
| } |
| |
| public String name; |
| |
| public int low, high; |
| } |
| |
| // A table representing the unicode categories |
| //private static UBInfo[] UCategories = { |
| // Lu |
| // Ll |
| // Lt |
| // Lm |
| // Lo |
| // Mn |
| // Mc |
| // Me |
| // Nd |
| // Nl |
| // No |
| // Pc |
| // Pd |
| // Ps |
| // Pe |
| // Pi |
| // Pf |
| // Po |
| // Sm |
| // Sc |
| // Sk |
| // So |
| // Zs |
| // Zl |
| // Zp |
| // Cc |
| // Cf |
| // Cs |
| // Co |
| // Cn |
| //}; |
| |
| // A table representing the unicode character blocks |
| private static UBInfo[] UBlocks = { |
| /* 0000; 007F; Basic Latin */ |
| new UBInfo(0x0000, 0x007F, "BasicLatin"), // Character.UnicodeBlock.BASIC_LATIN |
| /* 0080; 00FF; Latin-1 Supplement */ |
| new UBInfo(0x0080, 0x00FF, "Latin-1Supplement"), // Character.UnicodeBlock.LATIN_1_SUPPLEMENT |
| /* 0100; 017F; Latin Extended-A */ |
| new UBInfo(0x0100, 0x017F, "LatinExtended-A"), // Character.UnicodeBlock.LATIN_EXTENDED_A |
| /* 0180; 024F; Latin Extended-B */ |
| // new UBInfo (0x0180,0x024F,"InLatinExtended-B"), // |
| // Character.UnicodeBlock.LATIN_EXTENDED_B |
| /* 0250; 02AF; IPA Extensions */ |
| new UBInfo(0x0250, 0x02AF, "IPAExtensions"), // Character.UnicodeBlock.IPA_EXTENSIONS |
| /* 02B0; 02FF; Spacing Modifier Letters */ |
| new UBInfo(0x02B0, 0x02FF, "SpacingModifierLetters"), // Character.UnicodeBlock.SPACING_MODIFIER_LETTERS |
| /* 0300; 036F; Combining Diacritical Marks */ |
| new UBInfo(0x0300, 0x036F, "CombiningDiacriticalMarks"), // Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS |
| /* 0370; 03FF; Greek */ |
| new UBInfo(0x0370, 0x03FF, "Greek"), // Character.UnicodeBlock.GREEK |
| /* 0400; 04FF; Cyrillic */ |
| new UBInfo(0x0400, 0x04FF, "Cyrillic"), // Character.UnicodeBlock.CYRILLIC |
| /* 0530; 058F; Armenian */ |
| new UBInfo(0x0530, 0x058F, "Armenian"), // Character.UnicodeBlock.ARMENIAN |
| /* 0590; 05FF; Hebrew */ |
| new UBInfo(0x0590, 0x05FF, "Hebrew"), // Character.UnicodeBlock.HEBREW |
| /* 0600; 06FF; Arabic */ |
| new UBInfo(0x0600, 0x06FF, "Arabic"), // Character.UnicodeBlock.ARABIC |
| /* 0700; 074F; Syriac */ |
| new UBInfo(0x0700, 0x074F, "Syriac"), // Character.UnicodeBlock.SYRIAC |
| /* 0780; 07BF; Thaana */ |
| new UBInfo(0x0780, 0x07BF, "Thaana"), // Character.UnicodeBlock.THAANA |
| /* 0900; 097F; Devanagari */ |
| new UBInfo(0x0900, 0x097F, "Devanagari"), // Character.UnicodeBlock.DEVANAGARI |
| /* 0980; 09FF; Bengali */ |
| new UBInfo(0x0980, 0x09FF, "Bengali"), // Character.UnicodeBlock.BENGALI |
| /* 0A00; 0A7F; Gurmukhi */ |
| new UBInfo(0x0A00, 0x0A7F, "Gurmukhi"), // Character.UnicodeBlock.GURMUKHI |
| /* 0A80; 0AFF; Gujarati */ |
| new UBInfo(0x0A80, 0x0AFF, "Gujarati"), // Character.UnicodeBlock.GUJARATI |
| /* 0B00; 0B7F; Oriya */ |
| new UBInfo(0x0B00, 0x0B7F, "Oriya"), // Character.UnicodeBlock.ORIYA |
| /* 0B80; 0BFF; Tamil */ |
| new UBInfo(0x0B80, 0x0BFF, "Tamil"), // Character.UnicodeBlock.TAMIL |
| /* 0C00; 0C7F; Telugu */ |
| new UBInfo(0x0C00, 0x0C7F, "Telugu"), // Character.UnicodeBlock.TELUGU |
| /* 0C80; 0CFF; Kannada */ |
| new UBInfo(0x0C80, 0x0CFF, "Kannada"), // Character.UnicodeBlock.KANNADA |
| /* 0D00; 0D7F; Malayalam */ |
| new UBInfo(0x0D00, 0x0D7F, "Malayalam"), // Character.UnicodeBlock.MALAYALAM |
| /* 0D80; 0DFF; Sinhala */ |
| new UBInfo(0x0D80, 0x0DFF, "Sinhala"), // Character.UnicodeBlock.SINHALA |
| /* 0E00; 0E7F; Thai */ |
| new UBInfo(0x0E00, 0x0E7F, "Thai"), // Character.UnicodeBlock.THAI |
| /* 0E80; 0EFF; Lao */ |
| new UBInfo(0x0E80, 0x0EFF, "Lao"), // Character.UnicodeBlock.LAO |
| /* 0F00; 0FFF; Tibetan */ |
| new UBInfo(0x0F00, 0x0FFF, "Tibetan"), // Character.UnicodeBlock.TIBETAN |
| /* 1000; 109F; Myanmar */ |
| new UBInfo(0x1000, 0x109F, "Myanmar"), // Character.UnicodeBlock.MYANMAR |
| /* 10A0; 10FF; Georgian */ |
| new UBInfo(0x10A0, 0x10FF, "Georgian"), // Character.UnicodeBlock.GEORGIAN |
| /* 1100; 11FF; Hangul Jamo */ |
| new UBInfo(0x1100, 0x11FF, "HangulJamo"), // Character.UnicodeBlock.HANGUL_JAMO |
| /* 1200; 137F; Ethiopic */ |
| new UBInfo(0x1200, 0x137F, "Ethiopic"), // Character.UnicodeBlock.ETHIOPIC |
| /* 13A0; 13FF; Cherokee */ |
| new UBInfo(0x13A0, 0x13FF, "Cherokee"), // Character.UnicodeBlock.CHEROKEE |
| /* 1400; 167F; Unified Canadian Aboriginal Syllabics */ |
| new UBInfo(0x1400, 0x167F, "UnifiedCanadianAboriginalSyllabics"), // Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS |
| /* 1680; 169F; Ogham */ |
| new UBInfo(0x1680, 0x169F, "Ogham"), // Character.UnicodeBlock.OGHAM |
| /* 16A0; 16FF; Runic */ |
| new UBInfo(0x16A0, 0x16FF, "Runic"), // Character.UnicodeBlock.RUNIC |
| /* 1780; 17FF; Khmer */ |
| new UBInfo(0x1780, 0x17FF, "Khmer"), // Character.UnicodeBlock.KHMER |
| /* 1800; 18AF; Mongolian */ |
| new UBInfo(0x1800, 0x18AF, "Mongolian"), // Character.UnicodeBlock.MONGOLIAN |
| /* 1E00; 1EFF; Latin Extended Additional */ |
| new UBInfo(0x1E00, 0x1EFF, "LatinExtendedAdditional"), // Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL |
| /* 1F00; 1FFF; Greek Extended */ |
| new UBInfo(0x1F00, 0x1FFF, "GreekExtended"), // Character.UnicodeBlock.GREEK_EXTENDED |
| /* 2000; 206F; General Punctuation */ |
| new UBInfo(0x2000, 0x206F, "GeneralPunctuation"), // Character.UnicodeBlock.GENERAL_PUNCTUATION |
| /* 2070; 209F; Superscripts and Subscripts */ |
| new UBInfo(0x2070, 0x209F, "SuperscriptsandSubscripts"), // Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS |
| /* 20A0; 20CF; Currency Symbols */ |
| new UBInfo(0x20A0, 0x20CF, "CurrencySymbols"), // Character.UnicodeBlock.CURRENCY_SYMBOLS |
| /* 20D0; 20FF; Combining Marks for Symbols */ |
| new UBInfo(0x20D0, 0x20FF, "CombiningMarksforSymbols"), // Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS |
| /* 2100; 214F; Letterlike Symbols */ |
| new UBInfo(0x2100, 0x214F, "LetterlikeSymbols"), // Character.UnicodeBlock.LETTERLIKE_SYMBOLS |
| /* 2150; 218F; Number Forms */ |
| new UBInfo(0x2150, 0x218F, "NumberForms"), // Character.UnicodeBlock.NUMBER_FORMS |
| /* 2190; 21FF; Arrows */ |
| new UBInfo(0x2190, 0x21FF, "Arrows"), // Character.UnicodeBlock.ARROWS |
| /* 2200; 22FF; Mathematical Operators */ |
| new UBInfo(0x2200, 0x22FF, "MathematicalOperators"), // Character.UnicodeBlock.MATHEMATICAL_OPERATORS |
| /* 2300; 23FF; Miscellaneous Technical */ |
| new UBInfo(0x2300, 0x23FF, "MiscellaneousTechnical"), // Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL |
| /* 2400; 243F; Control Pictures */ |
| new UBInfo(0x2400, 0x243F, "ControlPictures"), // Character.UnicodeBlock.CONTROL_PICTURES |
| /* 2440; 245F; Optical Character Recognition */ |
| new UBInfo(0x2440, 0x245F, "OpticalCharacterRecognition"), // Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION |
| /* 2460; 24FF; Enclosed Alphanumerics */ |
| new UBInfo(0x2460, 0x24FF, "EnclosedAlphanumerics"), // Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS |
| /* 2500; 257F; Box Drawing */ |
| new UBInfo(0x2500, 0x257F, "BoxDrawing"), // Character.UnicodeBlock.BOX_DRAWING |
| /* 2580; 259F; Block Elements */ |
| new UBInfo(0x2580, 0x259F, "BlockElements"), // Character.UnicodeBlock.BLOCK_ELEMENTS |
| /* 25A0; 25FF; Geometric Shapes */ |
| new UBInfo(0x25A0, 0x25FF, "GeometricShapes"), // Character.UnicodeBlock.GEOMETRIC_SHAPES |
| /* 2600; 26FF; Miscellaneous Symbols */ |
| new UBInfo(0x2600, 0x26FF, "MiscellaneousSymbols"), // Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS |
| /* 2700; 27BF; Dingbats */ |
| new UBInfo(0x2700, 0x27BF, "Dingbats"), // Character.UnicodeBlock.DINGBATS |
| /* 2800; 28FF; Braille Patterns */ |
| new UBInfo(0x2800, 0x28FF, "BraillePatterns"), // Character.UnicodeBlock.BRAILLE_PATTERNS |
| /* 2E80; 2EFF; CJK Radicals Supplement */ |
| new UBInfo(0x2E80, 0x2EFF, "CJKRadicalsSupplement"), // Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT |
| /* 2F00; 2FDF; Kangxi Radicals */ |
| new UBInfo(0x2F00, 0x2FDF, "KangxiRadicals"), // Character.UnicodeBlock.KANGXI_RADICALS |
| /* 2FF0; 2FFF; Ideographic Description Characters */ |
| new UBInfo(0x2FF0, 0x2FFF, "IdeographicDescriptionCharacters"), // Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS |
| /* 3000; 303F; CJK Symbols and Punctuation */ |
| new UBInfo(0x3000, 0x303F, "CJKSymbolsandPunctuation"), // Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION |
| /* 3040; 309F; Hiragana */ |
| new UBInfo(0x3040, 0x309F, "Hiragana"), // Character.UnicodeBlock.HIRAGANA |
| /* 30A0; 30FF; Katakana */ |
| new UBInfo(0x30A0, 0x30FF, "Katakana"), // Character.UnicodeBlock.KATAKANA |
| /* 3100; 312F; Bopomofo */ |
| new UBInfo(0x3100, 0x312F, "Bopomofo"), // Character.UnicodeBlock.BOPOMOFO |
| /* 3130; 318F; Hangul Compatibility Jamo */ |
| new UBInfo(0x3130, 0x318F, "HangulCompatibilityJamo"), // Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO |
| /* 3190; 319F; Kanbun */ |
| new UBInfo(0x3190, 0x319F, "Kanbun"), // Character.UnicodeBlock.KANBUN |
| /* 31A0; 31BF; Bopomofo Extended */ |
| new UBInfo(0x31A0, 0x31BF, "BopomofoExtended"), // Character.UnicodeBlock.BOPOMOFO_EXTENDED |
| /* 3200; 32FF; Enclosed CJK Letters and Months */ |
| new UBInfo(0x3200, 0x32FF, "EnclosedCJKLettersandMonths"), // Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS |
| /* 3300; 33FF; CJK Compatibility */ |
| new UBInfo(0x3300, 0x33FF, "CJKCompatibility"), // Character.UnicodeBlock.CJK_COMPATIBILITY |
| /* 3400; 4DB5; CJK Unified Ideographs Extension A */ |
| // BEGIN android-changed |
| // Modified this to reflect current Unicode tables (or maybe it was a typo) |
| new UBInfo(0x3400, 0x4DBF, "CJKUnifiedIdeographsExtensionA"), // Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A |
| // END android-changed |
| /* 4E00; 9FFF; CJK Unified Ideographs */ |
| new UBInfo(0x4E00, 0x9FFF, "CJKUnifiedIdeographs"), // Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS |
| /* A000; A48F; Yi Syllables */ |
| new UBInfo(0xA000, 0xA48F, "YiSyllables"), // Character.UnicodeBlock.YI_SYLLABLES |
| /* A490; A4CF; Yi Radicals */ |
| new UBInfo(0xA490, 0xA4CF, "YiRadicals"), // Character.UnicodeBlock.YI_RADICALS |
| /* AC00; D7A3; Hangul Syllables */ |
| // BEGIN android-changed |
| // Modified this to reflect current Unicode tables (or maybe it was a typo) |
| new UBInfo(0xAC00, 0xD7AF, "HangulSyllables"), // Character.UnicodeBlock.HANGUL_SYLLABLES |
| // END android-changed |
| /* D800; DB7F; High Surrogates */ |
| /* DB80; DBFF; High Private Use Surrogates */ |
| /* DC00; DFFF; Low Surrogates */ |
| /* E000; F8FF; Private Use */ |
| /* F900; FAFF; CJK Compatibility Ideographs */ |
| new UBInfo(0xF900, 0xFAFF, "CJKCompatibilityIdeographs"), // Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS |
| /* FB00; FB4F; Alphabetic Presentation Forms */ |
| new UBInfo(0xFB00, 0xFB4F, "AlphabeticPresentationForms"), // Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS |
| /* FB50; FDFF; Arabic Presentation Forms-A */ |
| new UBInfo(0xFB50, 0xFDFF, "ArabicPresentationForms-A"), // Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A |
| /* FE20; FE2F; Combining Half Marks */ |
| new UBInfo(0xFE20, 0xFE2F, "CombiningHalfMarks"), // Character.UnicodeBlock.COMBINING_HALF_MARKS |
| /* FE30; FE4F; CJK Compatibility Forms */ |
| new UBInfo(0xFE30, 0xFE4F, "CJKCompatibilityForms"), // Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS |
| /* FE50; FE6F; Small Form Variants */ |
| new UBInfo(0xFE50, 0xFE6F, "SmallFormVariants"), // Character.UnicodeBlock.SMALL_FORM_VARIANTS |
| /* FE70; FEFE; Arabic Presentation Forms-B */ |
| // new UBInfo (0xFE70,0xFEFE,"InArabicPresentationForms-B"), // |
| // Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B |
| /* FEFF; FEFF; Specials */ |
| // BEGIN android-changed |
| // Modified this to reflect current Unicode tables (or maybe it was a typo) |
| // FEFF is actually still Arabic Presentation Forms B |
| // new UBInfo(0xFEFF, 0xFEFF, "Specials"), // Character.UnicodeBlock.SPECIALS |
| // END android-changed |
| /* FF00; FFEF; Halfwidth and Fullwidth Forms */ |
| new UBInfo(0xFF00, 0xFFEF, "HalfwidthandFullwidthForms"), // Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS |
| /* FFF0; FFFD; Specials */ |
| // BEGIN android-changed |
| // Modified this to reflect current Unicode tables (or maybe it was a typo) |
| new UBInfo(0xFFF0, 0xFFFF, "Specials") // Character.UnicodeBlock.SPECIALS |
| // END android-changed |
| }; |
| } |
