core/tests/coretests/src/android/util/PatternsTest.java

/*
 * 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());
    }

    //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.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());
        }
    }
}