/*
* Copyright (C) 2010 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.util;
import android.test.suitebuilder.annotation.SmallTest;
import android.test.suitebuilder.annotation.Suppress;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import junit.framework.TestCase;
public class PatternsTest extends TestCase {
// Tests for Patterns.TOP_LEVEL_DOMAIN
@SmallTest
public void testTldPattern() throws Exception {
boolean t;
t = Patterns.TOP_LEVEL_DOMAIN.matcher("com").matches();
assertTrue("Missed valid TLD", t);
// One of the new top level domain.
t = Patterns.TOP_LEVEL_DOMAIN.matcher("me").matches();
assertTrue("Missed valid TLD", t);
// One of the new top level test domain.
t = Patterns.TOP_LEVEL_DOMAIN.matcher("xn--0zwm56d").matches();
assertTrue("Missed valid TLD", t);
// One of the new top level unicode domain.
t = Patterns.TOP_LEVEL_DOMAIN.matcher("\uD55C\uAD6D").matches();
assertTrue("Missed valid TLD", t);
t = Patterns.TOP_LEVEL_DOMAIN.matcher("mem").matches();
assertFalse("Matched invalid TLD!", t);
t = Patterns.TOP_LEVEL_DOMAIN.matcher("xn").matches();
assertFalse("Matched invalid TLD!", t);
t = Patterns.TOP_LEVEL_DOMAIN.matcher("xer").matches();
assertFalse("Matched invalid TLD!", t);
}
// Tests for Patterns.IANA_TOP_LEVEL_DOMAINS
@SmallTest
public void testIanaTopLevelDomains_matchesValidTld() throws Exception {
Pattern pattern = Pattern.compile(Patterns.IANA_TOP_LEVEL_DOMAINS);
assertTrue("Should match 'com'", pattern.matcher("com").matches());
}
@SmallTest
public void testIanaTopLevelDomains_matchesValidNewTld() throws Exception {
Pattern pattern = Pattern.compile(Patterns.IANA_TOP_LEVEL_DOMAINS);
assertTrue("Should match 'me'", pattern.matcher("me").matches());
}
@SmallTest
public void testIanaTopLevelDomains_matchesPunycodeTld() throws Exception {
Pattern pattern = Pattern.compile(Patterns.IANA_TOP_LEVEL_DOMAINS);
assertTrue("Should match Punycode TLD", pattern.matcher("xn--qxam").matches());
}
@SmallTest
public void testIanaTopLevelDomains_matchesIriTLD() throws Exception {
Pattern pattern = Pattern.compile(Patterns.IANA_TOP_LEVEL_DOMAINS);
assertTrue("Should match IRI TLD", pattern.matcher("\uD55C\uAD6D").matches());
}
@SmallTest
public void testIanaTopLevelDomains_doesNotMatchWrongTld() throws Exception {
Pattern pattern = Pattern.compile(Patterns.IANA_TOP_LEVEL_DOMAINS);
assertFalse("Should not match 'mem'", pattern.matcher("mem").matches());
}
@SmallTest
public void testIanaTopLevelDomains_doesNotMatchWrongPunycodeTld() throws Exception {
Pattern pattern = Pattern.compile(Patterns.IANA_TOP_LEVEL_DOMAINS);
assertFalse("Should not match invalid Punycode TLD", pattern.matcher("xn").matches());
}
// Tests for Patterns.WEB_URL
@SmallTest
public void testWebUrl_matchesValidUrlWithSchemeAndHostname() throws Exception {
String url = "http://www.android.com";
assertTrue("Should match URL with scheme and hostname",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesValidUrlWithSchemeHostnameAndNewTld() throws Exception {
String url = "http://www.android.me";
assertTrue("Should match URL with scheme, hostname and new TLD",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesValidUrlWithHostnameAndNewTld() throws Exception {
String url = "android.me";
assertTrue("Should match URL with hostname and new TLD",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesChinesePunycodeUrlWithProtocol() throws Exception {
String url = "http://xn--fsqu00a.xn--0zwm56d";
assertTrue("Should match Chinese Punycode URL with protocol",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesChinesePunycodeUrlWithoutProtocol() throws Exception {
String url = "xn--fsqu00a.xn--0zwm56d";
assertTrue("Should match Chinese Punycode URL without protocol",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesArabicPunycodeUrlWithProtocol() throws Exception {
String url = "http://xn--4gbrim.xn----rmckbbajlc6dj7bxne2c.xn--wgbh1c/ar/default.aspx";
assertTrue("Should match arabic Punycode URL with protocol",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesArabicPunycodeUrlWithoutProtocol() throws Exception {
String url = "xn--4gbrim.xn----rmckbbajlc6dj7bxne2c.xn--wgbh1c/ar/default.aspx";
assertTrue("Should match Arabic Punycode URL without protocol",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesUrlWithUnicodeDomainNameWithProtocol() throws Exception {
String url = "http://\uD604\uAE08\uC601\uC218\uC99D.kr";
assertTrue("Should match URL with Unicode domain name",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesUrlWithUnicodeDomainNameWithoutProtocol() throws Exception {
String url = "\uD604\uAE08\uC601\uC218\uC99D.kr";
assertTrue("Should match URL without protocol and with Unicode domain name",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesUrlWithUnicodeTld() throws Exception {
String url = "\uB3C4\uBA54\uC778.\uD55C\uAD6D";
assertTrue("Should match URL with Unicode TLD",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesUrlWithUnicodePath() throws Exception {
String url = "http://brainstormtech.blogs.fortune.cnn.com/2010/03/11/" +
"top-five-moments-from-eric-schmidt\u2019s-talk-in-abu-dhabi/";
assertTrue("Should match URL with Unicode path",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_doesNotMatchValidUrlWithInvalidProtocol() throws Exception {
String url = "ftp://www.example.com";
assertFalse("Should not match URL with invalid protocol",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesValidUrlWithPort() throws Exception {
String url = "http://www.example.com:8080";
assertTrue("Should match URL with port", Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesUrlWithPortAndQuery() throws Exception {
String url = "http://www.example.com:8080/?foo=bar";
assertTrue("Should match URL with port and query",
Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesUrlWithTilde() throws Exception {
String url = "http://www.example.com:8080/~user/?foo=bar";
assertTrue("Should match URL with tilde", Patterns.WEB_URL.matcher(url).matches());
}
@SmallTest
public void testWebUrl_matchesProtocolCaseInsensitive() throws Exception {
String url = "hTtP://android.com";
assertTrue("Protocol matching should be case insensitive",
Patterns.WEB_URL.matcher(url).matches());
}
// Tests for Patterns.AUTOLINK_WEB_URL
@SmallTest
public void testAutoLinkWebUrl_matchesValidUrlWithSchemeAndHostname() throws Exception {
String url = "http://www.android.com";
assertTrue("Should match URL with scheme and hostname",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesValidUrlWithSchemeHostnameAndNewTld() throws Exception {
String url = "http://www.android.me";
assertTrue("Should match URL with scheme, hostname and new TLD",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesValidUrlWithHostnameAndNewTld() throws Exception {
String url = "android.me";
assertTrue("Should match URL with hostname and new TLD",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
url = "android.camera";
assertTrue("Should match URL with hostname and new TLD",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesChinesePunycodeUrlWithProtocol() throws Exception {
String url = "http://xn--fsqu00a.xn--0zwm56d";
assertTrue("Should match Chinese Punycode URL with protocol",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesChinesePunycodeUrlWithoutProtocol() throws Exception {
String url = "xn--fsqu00a.xn--0zwm56d";
assertTrue("Should match Chinese Punycode URL without protocol",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesArabicPunycodeUrlWithProtocol() throws Exception {
String url = "http://xn--4gbrim.xn--rmckbbajlc6dj7bxne2c.xn--wgbh1c/ar/default.aspx";
assertTrue("Should match Arabic Punycode URL with protocol",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesArabicPunycodeUrlWithoutProtocol() throws Exception {
String url = "xn--4gbrim.xn--rmckbbajlc6dj7bxne2c.xn--wgbh1c/ar/default.aspx";
assertTrue("Should match Arabic Punycode URL without protocol",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchPunycodeTldThatStartsWithDash() throws Exception {
String url = "http://xn--fsqu00a.-xn--0zwm56d";
assertFalse("Should not match Punycode TLD that starts with dash",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchPunycodeTldThatEndsWithDash() throws Exception {
String url = "http://xn--fsqu00a.xn--0zwm56d-";
assertFalse("Should not match Punycode TLD that ends with dash",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesUrlWithUnicodeDomainName() throws Exception {
String url = "http://\uD604\uAE08\uC601\uC218\uC99D.kr";
assertTrue("Should match URL with Unicode domain name",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
url = "\uD604\uAE08\uC601\uC218\uC99D.kr";
assertTrue("hould match URL without protocol and with Unicode domain name",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesUrlWithUnicodeTld() throws Exception {
String url = "\uB3C4\uBA54\uC778.\uD55C\uAD6D";
assertTrue("Should match URL with Unicode TLD",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesUrlWithUnicodePath() throws Exception {
String url = "http://brainstormtech.blogs.fortune.cnn.com/2010/03/11/" +
"top-five-moments-from-eric-schmidt\u2019s-talk-in-abu-dhabi/";
assertTrue("Should match URL with Unicode path",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchValidUrlWithInvalidProtocol() throws Exception {
String url = "ftp://www.example.com";
assertFalse("Should not match URL with invalid protocol",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesValidUrlWithPort() throws Exception {
String url = "http://www.example.com:8080";
assertTrue("Should match URL with port",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesUrlWithPortAndQuery() throws Exception {
String url = "http://www.example.com:8080/?foo=bar";
assertTrue("Should match URL with port and query",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesUrlWithTilde() throws Exception {
String url = "http://www.example.com:8080/~user/?foo=bar";
assertTrue("Should match URL with tilde",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesProtocolCaseInsensitive() throws Exception {
String url = "hTtP://android.com";
assertTrue("Protocol matching should be case insensitive",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesUrlStartingWithHttpAndDoesNotHaveTld() throws Exception {
String url = "http://android/#notld///a/n/d/r/o/i/d&p1=1&p2=2";
assertTrue("Should match URL without a TLD and starting with http ",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchUrlsWithoutProtocolAndWithUnknownTld()
throws Exception {
String url = "thank.you";
assertFalse("Should not match URL that does not start with a protocol and " +
"does not contain a known TLD",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchUrlWithInvalidRequestParameter() throws Exception {
String url = "http://android.com?p=value";
assertFalse("Should not match URL with invalid request parameter",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotPartiallyMatchUnknownProtocol() throws Exception {
String url = "ftp://foo.bar/baz";
assertFalse("Should not partially match URL with unknown protocol",
Patterns.AUTOLINK_WEB_URL.matcher(url).find());
}
@SmallTest
public void testAutoLinkWebUrl_matchesValidUrlWithEmoji() throws Exception {
String url = "Thank\u263A.com";
assertTrue("Should match URL with emoji",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchUrlsWithEmojiWithoutProtocolAndWithoutKnownTld()
throws Exception {
String url = "Thank\u263A.you";
assertFalse("Should not match URLs containing emoji and with unknown TLD",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchEmailAddress()
throws Exception {
String url = "android@android.com";
assertFalse("Should not match email address",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesDomainNameWithSurrogatePairs() throws Exception {
String url = "android\uD83C\uDF38.com";
assertTrue("Should match domain name with Unicode surrogate pairs",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesTldWithSurrogatePairs() throws Exception {
String url = "http://android.\uD83C\uDF38com";
assertTrue("Should match TLD with Unicode surrogate pairs",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_matchesPathWithSurrogatePairs() throws Exception {
String url = "http://android.com/path-with-\uD83C\uDF38?v=\uD83C\uDF38";
assertTrue("Should match path and query with Unicode surrogate pairs",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchUrlWithExcludedSurrogate() throws Exception {
String url = "http://android\uD83F\uDFFE.com";
assertFalse("Should not match URL with excluded Unicode surrogate pair",
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
@SmallTest
public void testAutoLinkWebUrl_doesNotMatchUnicodeSpaces() throws Exception {
String part1 = "http://and";
String part2 = "roid";
String[] emptySpaces = new String[]{
"\u00A0", // no-break space
"\u2000", // en quad
"\u2001", // em quad
"\u2002", // en space
"\u2003", // em space
"\u2004", // three-per-em space
"\u2005", // four-per-em space
"\u2006", // six-per-em space
"\u2007", // figure space
"\u2008", // punctuation space
"\u2009", // thin space
"\u200A", // hair space
"\u2028", // line separator
"\u2029", // paragraph separator
"\u202F", // narrow no-break space
"\u3000" // ideographic space
};
for (String emptySpace : emptySpaces) {
String url = part1 + emptySpace + part2;
assertFalse("Should not match empty space - code:" + emptySpace.codePointAt(0),
Patterns.AUTOLINK_WEB_URL.matcher(url).matches());
}
}
// Tests for Patterns.IP_ADDRESS
@SmallTest
public void testIpPattern() throws Exception {
boolean t;
t = Patterns.IP_ADDRESS.matcher("172.29.86.3").matches();
assertTrue("Valid IP", t);
t = Patterns.IP_ADDRESS.matcher("1234.4321.9.9").matches();
assertFalse("Invalid IP", t);
}
// Tests for Patterns.DOMAIN_NAME
@SmallTest
public void testDomain_matchesPunycodeTld() throws Exception {
String domain = "xn--fsqu00a.xn--0zwm56d";
assertTrue("Should match domain name in Punycode",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_doesNotMatchPunycodeThatStartsWithDash() throws Exception {
String domain = "xn--fsqu00a.-xn--0zwm56d";
assertFalse("Should not match Punycode TLD that starts with a dash",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_doesNotMatchPunycodeThatEndsWithDash() throws Exception {
String domain = "xn--fsqu00a.xn--0zwm56d-";
assertFalse("Should not match Punycode TLD that ends with a dash",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_doesNotMatchPunycodeLongerThanAllowed() throws Exception {
String tld = "xn--";
for(int i=0; i<=6; i++) {
tld += "0123456789";
}
String domain = "xn--fsqu00a." + tld;
assertFalse("Should not match Punycode TLD that is longer than 63 chars",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_matchesObsoleteTld() throws Exception {
String domain = "test.yu";
assertTrue("Should match domain names with obsolete TLD",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_matchesWithSubDomain() throws Exception {
String domain = "mail.example.com";
assertTrue("Should match domain names with subdomains",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_matchesWithoutSubDomain() throws Exception {
String domain = "android.me";
assertTrue("Should match domain names without subdomains",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_matchesUnicodeDomainNames() throws Exception {
String domain = "\uD604\uAE08\uC601\uC218\uC99D.kr";
assertTrue("Should match unicodedomain names",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_doesNotMatchInvalidDomain() throws Exception {
String domain = "__+&42.xer";
assertFalse("Should not match invalid domain name",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
@SmallTest
public void testDomain_matchesPunycodeArabicDomainName() throws Exception {
String domain = "xn--4gbrim.xn----rmckbbajlc6dj7bxne2c.xn--wgbh1c";
assertTrue("Should match Punycode Arabic domain name",
Patterns.DOMAIN_NAME.matcher(domain).matches());
}
// Tests for Patterns.AUTOLINK_EMAIL_ADDRESS
public void testAutoLinkEmailAddress_matchesShortValidEmail() throws Exception {
String email = "a@a.co";
assertTrue("Should match short valid email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesRegularEmail() throws Exception {
String email = "email@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesEmailWithMultipleSubdomains() throws Exception {
String email = "email@e.somelongdomainnameforandroid.abc.uk";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithDot() throws Exception {
String email = "e.mail@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithPlus() throws Exception {
String email = "e+mail@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithUnderscore() throws Exception {
String email = "e_mail@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithDash() throws Exception {
String email = "e-mail@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithApostrophe() throws Exception {
String email = "e'mail@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithDigits() throws Exception {
String email = "123@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesUnicodeLocalPart() throws Exception {
String email = "\uD604\uAE08\uC601\uC218\uC99D@android.kr";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithEmoji() throws Exception {
String email = "smiley\u263A@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartWithSurrogatePairs() throws Exception {
String email = "\uD83C\uDF38@android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesDomainWithDash() throws Exception {
String email = "email@an-droid.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesUnicodeDomain() throws Exception {
String email = "email@\uD604\uAE08\uC601\uC218\uC99D.kr";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesUnicodeLocalPartAndDomain() throws Exception {
String email = "\uD604\uAE08\uC601\uC218\uC99D@\uD604\uAE08\uC601\uC218\uC99D.kr";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesDomainWithEmoji() throws Exception {
String email = "smiley@\u263Aandroid.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesDomainWithSurrogatePairs() throws Exception {
String email = "email@\uD83C\uDF38android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartAndDomainWithSurrogatePairs()
throws Exception {
String email = "\uD83C\uDF38@\uD83C\uDF38android.com";
assertTrue("Should match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchStringWithoutAtSign() throws Exception {
String email = "android.com";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchPlainString() throws Exception {
String email = "email";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchStringWithMultipleAtSigns() throws Exception {
String email = "email@android@android.com";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchEmailWithoutTld() throws Exception {
String email = "email@android";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchLocalPartEndingWithDot() throws Exception {
String email = "email.@android.com";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchLocalPartStartingWithDot() throws Exception {
String email = ".email@android.com";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchDomainStartingWithDash() throws Exception {
String email = "email@-android.com";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchDomainWithConsecutiveDots() throws Exception {
String email = "email@android..com";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchEmailWithIpAsDomain() throws Exception {
String email = "email@127.0.0.1";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_doesNotMatchEmailWithInvalidTld() throws Exception {
String email = "email@android.c";
assertFalse("Should not match email: " + email,
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesLocalPartUpTo64Chars() throws Exception {
String localPart = "";
for (int i = 0; i < 64; i++) {
localPart += "a";
}
String email = localPart + "@android.com";
assertTrue("Should match local part of length: " + localPart.length(),
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
email = localPart + "a@android.com";
assertFalse("Should not match local part of length: " + localPart.length(),
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesSubdomainUpTo63Chars() throws Exception {
String subdomain = "";
for (int i = 0; i < 63; i++) {
subdomain += "a";
}
String email = "email@" + subdomain + ".com";
assertTrue("Should match subdomain of length: " + subdomain.length(),
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
subdomain += "a";
email = "email@" + subdomain + ".com";
assertFalse("Should not match local part of length: " + subdomain.length(),
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
public void testAutoLinkEmailAddress_matchesDomainUpTo255Chars() throws Exception {
String longDomain = "";
while (longDomain.length() <= 250) {
longDomain += "d.";
}
longDomain += "com";
assertEquals(255, longDomain.length());
String email = "a@" + longDomain;
assertTrue("Should match domain of length: " + longDomain.length(),
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
email = email + "m";
assertEquals(258, email.length());
assertFalse("Should not match domain of length: " + longDomain.length(),
Patterns.AUTOLINK_EMAIL_ADDRESS.matcher(email).matches());
}
// Tests for Patterns.PHONE
@SmallTest
public void testPhonePattern() throws Exception {
boolean t;
t = Patterns.PHONE.matcher("(919) 555-1212").matches();
assertTrue("Valid phone", t);
t = Patterns.PHONE.matcher("2334 9323/54321").matches();
assertFalse("Invalid phone", t);
String[] tests = {
"Me: 16505551212 this\n",
"Me: 6505551212 this\n",
"Me: 5551212 this\n",
"Me: 2211 this\n",
"Me: 112 this\n",
"Me: 1-650-555-1212 this\n",
"Me: (650) 555-1212 this\n",
"Me: +1 (650) 555-1212 this\n",
"Me: +1-650-555-1212 this\n",
"Me: 650-555-1212 this\n",
"Me: 555-1212 this\n",
"Me: 1.650.555.1212 this\n",
"Me: (650) 555.1212 this\n",
"Me: +1 (650) 555.1212 this\n",
"Me: +1.650.555.1212 this\n",
"Me: 650.555.1212 this\n",
"Me: 555.1212 this\n",
"Me: 1 650 555 1212 this\n",
"Me: (650) 555 1212 this\n",
"Me: +1 (650) 555 1212 this\n",
"Me: +1 650 555 1212 this\n",
"Me: 650 555 1212 this\n",
"Me: 555 1212 this\n",
};
for (String test : tests) {
Matcher m = Patterns.PHONE.matcher(test);
assertTrue("Valid phone " + test, m.find());
}
}
}