/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed 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 android.core;
import android.test.suitebuilder.annotation.SmallTest;
import android.text.util.Regex;
import junit.framework.TestCase;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Tests basic functionality of Pattern and Matcher classes.
*/
public class RegexTest extends TestCase {
@SmallTest
public void testMatches() throws Exception {
/* Tests class Matcher */
Pattern p = Pattern.compile("bcd");
Matcher m = p.matcher("bcd");
assertTrue("Should match.", m.matches());
/* Pattern in the middle */
p = Pattern.compile("bcd");
m = p.matcher("abcdefg");
assertFalse("Should not match.", m.matches());
/* Pattern at the head */
m = p.matcher("bcdefg");
assertFalse("Should not match.", m.matches());
/* Pattern at the tail */
m = p.matcher("abcd");
assertFalse("Should not match.", m.matches());
/* Make sure matches() doesn't change after calls to find() */
p = Pattern.compile(".*");
m = p.matcher("abc");
assertTrue(m.matches());
assertTrue(m.find());
assertTrue(m.matches());
p = Pattern.compile(".");
m = p.matcher("abc");
assertFalse(m.matches());
assertTrue(m.find());
assertFalse(m.matches());
/* Make sure matches() agrees after a reset() */
m.reset("z");
assertTrue(m.matches());
m.reset("xyz");
assertFalse(m.matches());
/* Tests class Pattern */
assertFalse("Erroneously matched partial string. " +
"See http://b/issue?id=754601", Pattern.matches("er", "xer"));
assertFalse("Erroneously matched partial string. " +
"See http://b/issue?id=754601", Pattern.matches("xe", "xer"));
assertTrue("Generic regex should match.",
Pattern.matches(".*", "bcd"));
assertTrue("Grouped regex should match.",
Pattern.matches("(b(c(d)))", "bcd"));
assertTrue("Grouped regex should match.",
Pattern.matches("(b)(c)(d)", "bcd"));
}
@SmallTest
public void testGroupCount() throws Exception {
Pattern p = Pattern.compile(
"\\b(?:\\+?1)?"
+ "(?:[ -\\.])?"
+ "\\(?(\\d{3})?\\)?"
+ "(?:[ -\\.\\/])?"
+ "(\\d{3})"
+ "(?:[ -\\.])?"
+ "(\\d{4})\\b"
);
Matcher m = p.matcher("1 (919) 555-1212");
assertEquals("groupCount is incorrect, see http://b/issue?id=759412",
3, m.groupCount());
}
@SmallTest
public void testGroups() throws Exception {
Pattern p = Pattern.compile("(b)([c|d])(z*)");
Matcher m = p.matcher("abcdefg");
/* Must call find() first, otherwise group*() are undefined. */
assertTrue(m.find());
assertEquals(3, m.groupCount());
assertEquals("bc", m.group(0));
assertEquals("b", m.group(1));
assertEquals("c", m.group(2));
assertEquals("", m.group(3));
}
@SmallTest
public void testFind() throws Exception {
Pattern p = Pattern.compile(".");
Matcher m = p.matcher("abc");
assertTrue(m.find());
assertEquals("a", m.group(0));
assertTrue(m.find());
assertEquals("b", m.group(0));
assertTrue(m.find());
assertEquals("c", m.group(0));
assertFalse(m.find());
}
@SmallTest
public void testReplaceAll() throws Exception {
// Begins with non-matching text, ends with matching text
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("fooaabfooaabfooabfoob");
String r = m.replaceAll("-");
assertEquals("foo-foo-foo-foo-", r);
// Begins with matching text, ends with non-matching text
p = Pattern.compile("a*b");
m = p.matcher("aabfooaabfooabfoobfoo");
r = m.replaceAll("-");
assertEquals("-foo-foo-foo-foo", r);
}
@SmallTest
public void testReplaceFirst() throws Exception {
// Begins with non-matching text, ends with matching text
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("fooaabfooaabfooabfoob");
String r = m.replaceFirst("-");
assertEquals("foo-fooaabfooabfoob", r);
// Begins with matching text, ends with non-matching text
p = Pattern.compile("a*b");
m = p.matcher("aabfooaabfooabfoobfoo");
r = m.replaceFirst("-");
assertEquals("-fooaabfooabfoobfoo", r);
}
@SmallTest
public void testSplit() throws Exception {
Pattern p = Pattern.compile(":");
String[] strings;
strings = p.split("boo:and:foo");
assertEquals(3, strings.length);
assertEquals("boo", strings[0]);
assertEquals("and", strings[1]);
assertEquals("foo", strings[2]);
strings = p.split("boo:and:foo", 2);
assertEquals(2, strings.length);
assertEquals("boo", strings[0]);
assertEquals("and:foo", strings[1]);
strings = p.split("boo:and:foo", 5);
assertEquals(3, strings.length);
assertEquals("boo", strings[0]);
assertEquals("and", strings[1]);
assertEquals("foo", strings[2]);
strings = p.split("boo:and:foo", -2);
assertEquals(3, strings.length);
assertEquals("boo", strings[0]);
assertEquals("and", strings[1]);
assertEquals("foo", strings[2]);
p = Pattern.compile("o");
strings = p.split("boo:and:foo");
assertEquals(3, strings.length);
assertEquals("b", strings[0]);
assertEquals("", strings[1]);
assertEquals(":and:f", strings[2]);
strings = p.split("boo:and:foo", 5);
assertEquals(5, strings.length);
assertEquals("b", strings[0]);
assertEquals("", strings[1]);
assertEquals(":and:f", strings[2]);
assertEquals("", strings[3]);
assertEquals("", strings[4]);
strings = p.split("boo:and:foo", -2);
assertEquals(5, strings.length);
assertEquals("b", strings[0]);
assertEquals("", strings[1]);
assertEquals(":and:f", strings[2]);
assertEquals("", strings[3]);
assertEquals("", strings[4]);
strings = p.split("boo:and:foo", 0);
assertEquals(3, strings.length);
assertEquals("b", strings[0]);
assertEquals("", strings[1]);
assertEquals(":and:f", strings[2]);
}
// -------------------------------------------------------------------
// Regression test for #1172774: Bug in Regex.java
// Regression test for #1216887: Regular expression match is very slow
public static final Pattern TOP_LEVEL_DOMAIN_PATTERN = Pattern.compile(
"((aero|arpa|asia|a[cdefgilmnoqrstuwxz])"
+ "|(biz|b[abdefghijmnorstvwyz])"
+ "|(cat|com|coop|c[acdfghiklmnoruvxyz])"
+ "|d[ejkmoz]"
+ "|(edu|e[cegrstu])"
+ "|f[ijkmor]"
+ "|(gov|g[abdefghilmnpqrstuwy])"
+ "|h[kmnrtu]"
+ "|(info|int|i[delmnoqrst])"
+ "|(jobs|j[emop])"
+ "|k[eghimnrwyz]"
+ "|l[abcikrstuvy]"
+ "|(mil|mobi|museum|m[acdghklmnopqrstuvwxyz])"
+ "|(name|net|n[acefgilopruz])"
+ "|(org|om)"
+ "|(pro|p[aefghklmnrstwy])"
+ "|qa"
+ "|r[eouw]"
+ "|s[abcdeghijklmnortuvyz]"
+ "|(tel|travel|t[cdfghjklmnoprtvwz])"
+ "|u[agkmsyz]"
+ "|v[aceginu]"
+ "|w[fs]"
+ "|y[etu]"
+ "|z[amw])");
public static final Pattern EMAIL_ADDRESS_PATTERN = Pattern.compile(
"[\\+a-zA-Z0-9\\.\\_\\%\\-]+\\@"
+ "(("
+ "[a-zA-Z0-9]\\.|"
+ "([a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9]\\.)+)"
+ TOP_LEVEL_DOMAIN_PATTERN
+ ")");
@SmallTest
public void testMonsterRegexCorrectness() {
assertTrue(EMAIL_ADDRESS_PATTERN.matcher("a+b@gmail.com").matches());
}
@SmallTest
public void testMonsterRegexPerformance() {
android.util.Log.e("RegexTest", "RegEx performance test started.");
long t0 = System.currentTimeMillis();
Matcher m = EMAIL_ADDRESS_PATTERN.matcher("donot repeate@RC8jjjjjjjjjjjjjjj");
assertFalse(m.find());
long t1 = System.currentTimeMillis();
android.util.Log.e("RegexTest", "RegEx performance test finished, " +
"took " + (t1 - t0) + " ms.");
}
//
// -------------------------------------------------------------------
}
|
