/*
 *  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 java.io.Serializable;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import libcore.junit.junit3.TestCaseWithRules;
import libcore.junit.util.SwitchTargetSdkVersionRule;
import libcore.junit.util.SwitchTargetSdkVersionRule.TargetSdkVersion;
import org.apache.harmony.testframework.serialization.SerializationTest;
import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;

import org.junit.Rule;
import org.junit.rules.TestRule;

import static java.util.Arrays.asList;

public class PatternTest extends TestCaseWithRules {
    @Rule
    public TestRule switchTargetSdkVersionRule = SwitchTargetSdkVersionRule.getInstance();

    String[] testPatterns = {
            "(a|b)*abb",
            "(1*2*3*4*)*567",
            "(a|b|c|d)*aab",
            "(1|2|3|4|5|6|7|8|9|0)(1|2|3|4|5|6|7|8|9|0)*",
            "(abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ)*",
            "(a|b)*(a|b)*A(a|b)*lice.*",
            "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(a|b|c|d|e|f|g|h|"
                    + "i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)*(1|2|3|4|5|6|7|8|9|0)*|while|for|struct|if|do",
// BEGIN Android-changed
// We don't have canonical equivalence.
//            "x(?c)y", "x(?cc)y"
//            "x(?:c)y"
// END Android-changed

    };

    String[] testPatternsAlt = {
            /*
             * According to JavaDoc 2 and 3 oct digit sequences like \\o70\\o347
             * should be OK, but test is failed for them
             */
            "[ab]\\b\\\\o5\\xF9\\u1E7B\\t\\n\\f\\r\\a\\e[yz]",
            "^\\p{Lower}*\\p{Upper}*\\p{ASCII}?\\p{Alpha}?\\p{Digit}*\\p{Alnum}\\p{Punct}\\p{Graph}\\p{Print}\\p{Blank}\\p{Cntrl}\\p{XDigit}\\p{Space}",
            "$\\p{javaLowerCase}\\p{javaUpperCase}\\p{javaWhitespace}\\p{javaMirrored}",
            "\\p{InGreek}\\p{Lu}\\p{Sc}\\P{InGreek}[\\p{L}&&[^\\p{Lu}]]" };

    String[] wrongTestPatterns = { "\\o9A", "\\p{Lawer}", "\\xG0" };

    final static int[] flagsSet = { Pattern.CASE_INSENSITIVE,
            Pattern.MULTILINE, Pattern.DOTALL, Pattern.UNICODE_CASE
            /* , Pattern.CANON_EQ */ };

    /*
     * Based on RI implenetation documents. Need to check this set regarding
     * actual implementation.
     */
    final static int[] wrongFlagsSet = { 256, 512, 1024 };

    final static int DEFAULT_FLAGS = 0;

    public void testMatcher() {
        // some very simple test
        Pattern p = Pattern.compile("a");
        assertNotNull(p.matcher("bcde"));
        assertNotSame(p.matcher("a"), p.matcher("a"));
    }

    public void testSplitCharSequenceBug6193() {
        // splitting CharSequence which ends with pattern
        assertEquals(",,".split(",", 3).length, 3);
        assertEquals(",,".split(",", 4).length, 3);
    }

    public void testSplitCharSequenceBug5391() {
        assertEquals(Pattern.compile("o").split("boo:and:foo", 5).length, 5);
        assertEquals(Pattern.compile("b").split("ab", -1).length, 2);
    }

    public void testSplitCharSequence() {
        Pattern pat = Pattern.compile("x");
        String[] s;

        s = pat.split("zxx:zzz:zxx", 10);
        assertEquals(s.length, 5);
        s = pat.split("zxx:zzz:zxx", 3);
        assertEquals(s.length, 3);
        s = pat.split("zxx:zzz:zxx", -1);
        assertEquals(s.length, 5);
        s = pat.split("zxx:zzz:zxx", 0);
        assertEquals(s.length, 3);

        pat = Pattern.compile("b");
        s = pat.split("abccbadfebb");
        assertEquals(s.length, 3);
        s = pat.split("");
        assertEquals(s.length, 1);

        pat = Pattern.compile("");
        s = pat.split("");
        assertEquals(s.length, 1);
        s = pat.split("abccbadfe");
        assertEquals(s.length, 9);
    }

    public void testBug6544() {
        String s = "";
        String[] arr = s.split(":");
        assertEquals(arr.length, 1);
    }

    public void testSplitCharSequenceNegativeLimit() {
        // negative limit
        Pattern pat = Pattern.compile("b");
        String[] s;

        s = pat.split("abccbadfebb", -1);
        assertEquals(s.length, 5);
        s = pat.split("", -1);
        assertEquals(s.length, 1);
        pat = Pattern.compile("");
        s = pat.split("", -1);
        assertEquals(s.length, 1);
        s = pat.split("abccbadfe", -1);
        assertEquals(s.length, 10);
    }

    public void testSplitCharSequenceZeroLimit() {
        String[] s;
        Pattern pat = Pattern.compile("b");

        s = pat.split("abccbadfebb", 0);
        assertEquals(s.length, 3);
        s = pat.split("", 0);
        assertEquals(s.length, 1);
        pat = Pattern.compile("");
        s = pat.split("", 0);
        assertEquals(s.length, 1);
        s = pat.split("abccbadfe", 0);
        assertEquals(s.length, 9);
    }

    public void testSplitCharSequencePositiveLimitCase1() {
        String[] s;
        Pattern pat = Pattern.compile("b");

        s = pat.split("abccbadfebb", 12);
        assertEquals(s.length, 5);
        s = pat.split("", 6);
        assertEquals(s.length, 1);
        pat = Pattern.compile("");
        s = pat.split("", 11);
        assertEquals(s.length, 1);
        s = pat.split("abccbadfe", 15);
        assertEquals(s.length, 10);
    }

    public void testSplitCharSequencePositiveLimitCase2() {
        String[] s;
        Pattern pat = Pattern.compile("b");

        s = pat.split("abccbadfebb", 5);
        assertEquals(s.length, 5);
        s = pat.split("", 1);
        assertEquals(s.length, 1);
        pat = Pattern.compile("");
        s = pat.split("", 1);
        assertEquals(s.length, 1);
        s = pat.split("abccbadfe", 10);
        assertEquals(s.length, 10);
    }

    public void testSplitCharSequencePositiveLimitCase3() {
        Pattern pat = Pattern.compile("b");
        String[] s;

        s = pat.split("abccbadfebb", 3);
        assertEquals(s.length, 3);
        pat = Pattern.compile("");
        s = pat.split("abccbadfe", 5);
        assertEquals(s.length, 5);
    }

    public void testSplitOnEmptyPattern_apiCurrent() {
        assertEquals(asList("t", "e", "s", "t"), asList("test".split("")));
        assertEquals(asList(""), asList("".split("")));
        assertEquals(asList(""), asList(Pattern.compile("").split("")));
        assertEquals(asList(""), asList("".split("", -1)));
    }

    @TargetSdkVersion(28)
    public void testSplitOnEmptyPattern_api28() {
        assertEquals(asList("", "t", "e", "s", "t"), asList("test".split("")));
        assertEquals(asList(""), asList("".split("")));
        assertEquals(asList(""), asList(Pattern.compile("").split("")));
        assertEquals(asList(""), asList("".split("", -1)));
    }

    /**
     * Tests that a match at the beginning of the input string only produces
     * a "" if the match is positive-width.
     */
    public void testMatchBeginningOfInputSequence_apiCurrent() {
        // Positive-width match at the beginning of the input.
        assertEquals(asList("", "", "rdv", "rk"), asList("aardvark".split("a")));
        assertEquals(asList("", "anana"), asList("banana".split("b")));
        // Zero-width match at the beginning of the input
        assertEquals(asList("a", "ardv", "ark"), asList("aardvark".split("(?=a)")));
        assertEquals(asList("banana"), asList("banana".split("(?=b)")));

        // For comparison, matches in the middle of the input never yield an empty substring:
        assertEquals(asList("aar", "vark"), asList("aardvark".split("d")));
        assertEquals(asList("aar", "dvark"), asList("aardvark".split("(?=d)")));
    }

    @TargetSdkVersion(28)
    public void testMatchBeginningOfInputSequence_api28() {
        // Positive-width match at the beginning of the input.
        assertEquals(asList("", "", "rdv", "rk"), asList("aardvark".split("a")));
        assertEquals(asList("", "anana"), asList("banana".split("b")));
        // Zero-width match at the beginning of the input
        assertEquals(asList("", "a", "ardv", "ark"), asList("aardvark".split("(?=a)")));
        assertEquals(asList("banana"), asList("banana".split("(?=b)")));

        // For comparison, matches in the middle of the input never yield an empty substring:
        assertEquals(asList("aar", "vark"), asList("aardvark".split("d")));
        assertEquals(asList("aar", "dvark"), asList("aardvark".split("(?=d)")));
    }

    public void testPattern() {
        /* Positive assertion test. */
        for (String aPattern : testPatterns) {
            Pattern p = Pattern.compile(aPattern);
            try {
                assertTrue(p.pattern().equals(aPattern));
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }
    }

    public void testCompile_Valid() {
        for (String aPattern : testPatterns) {
            try {
                Pattern p = Pattern.compile(aPattern);
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }

        for (String aPattern : testPatternsAlt) {
            try {
                Pattern p = Pattern.compile(aPattern);
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }
    }

    public void testCompile_WrongPatternsFail() {
        for (String aPattern : wrongTestPatterns) {
            try {
                Pattern p = Pattern.compile(aPattern);
                fail("PatternSyntaxException is expected");
            } catch (PatternSyntaxException pse) {
                /* OKAY */
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }
    }

    public void testFlagsCase1() {
        String baseString = "((?i)|b)a";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testFlagsCase2() {
        String baseString = "(?i)a|b";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase3() {
        String baseString = "(?i)a|b";
        String testString = "B";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase4() {
        String baseString = "c|(?i)a|b";
        String testString = "B";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase5() {
        String baseString = "(?i)a|(?s)b";
        String testString = "B";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase6() {
        String baseString = "(?i)a|(?-i)b";
        String testString = "B";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testFlagsCase7() {
        String baseString = "(?i)a|(?-i)c|b";
        String testString = "B";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testFlagsCase8() {
       String  baseString = "(?i)a|(?-i)c|(?i)b";
       String  testString = "B";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase9() {
        String baseString = "(?i)a|(?-i)b";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase10() {
        String baseString = "((?i))a";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testFlagsCase11() {
        String baseString = "|(?i)|a";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase12() {
        String baseString = "(?i)((?s)a.)";
        String testString = "A\n";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase13() {
        String baseString = "(?i)((?-i)a)";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testFlagsCase14() {
        String baseString = "(?i)(?s:a.)";
        String testString = "A\n";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase15() {
        String baseString = "(?i)fgh(?s:aa)";
        String testString = "fghAA";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase16() {
        String baseString = "(?i)((?-i))a";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase17() {
        String baseString = "abc(?i)d";
        String testString = "ABCD";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testFlagsCase18() {
        String baseString = "abc(?i)d";
        String testString = "abcD";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase19() {
        String baseString = "a(?i)a(?-i)a(?i)a(?-i)a";
        String testString = "aAaAa";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testFlagsCase20() {
        String baseString = "a(?i)a(?-i)a(?i)a(?-i)a";
        String testString = "aAAAa";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

// BEGIN Android-removed
// The flags() method should only return those flags that were explicitly
// passed during the compilation. The JDK also accepts the ones implicitly
// contained in the pattern, but ICU doesn't do this.
//
//    public void testFlagsMethod() {
//        String baseString;
//        Pattern pat;
//
//        /*
//         * These tests are for compatibility with RI only. Logically we have to
//         * return only flags specified during the compilation. For example
//         * pat.flags() == 0 when we compile Pattern pat =
//         * Pattern.compile("(?i)abc(?-i)"); but the whole expression is compiled
//         * in a case insensitive manner. So there is little sense to do calls to
//         * flags() now.
//         */
//        baseString = "(?-i)";
//        pat = Pattern.compile(baseString);
//
//        baseString = "(?idmsux)abc(?-i)vg(?-dmu)";
//        pat = Pattern.compile(baseString);
//        assertEquals(pat.flags(), Pattern.DOTALL | Pattern.COMMENTS);
//
//        baseString = "(?idmsux)abc|(?-i)vg|(?-dmu)";
//        pat = Pattern.compile(baseString);
//        assertEquals(pat.flags(), Pattern.DOTALL | Pattern.COMMENTS);
//
//        baseString = "(?is)a((?x)b.)";
//        pat = Pattern.compile(baseString);
//        assertEquals(pat.flags(), Pattern.DOTALL | Pattern.CASE_INSENSITIVE);
//
//        baseString = "(?i)a((?-i))";
//        pat = Pattern.compile(baseString);
//        assertEquals(pat.flags(), Pattern.CASE_INSENSITIVE);
//
//        baseString = "((?i)a)";
//        pat = Pattern.compile(baseString);
//        assertEquals(pat.flags(), 0);
//
//        pat = Pattern.compile("(?is)abc");
//        assertEquals(pat.flags(), Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
//    }
//END Android-removed

    /*
     * Check default flags when they are not specified in pattern. Based on RI
     * since could not find that info
     */
    public void testFlagsCompileDefault() {
        for (String pat : testPatternsAlt) {
            try {
                Pattern p = Pattern.compile(pat);
                assertEquals(p.flags(), DEFAULT_FLAGS);
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }
    }

    /*
     * Check that flags specified during compile are set properly This is a
     * simple implementation that does not use flags combinations. Need to
     * improve.
     */
    public void testFlagsCompileValid() {
        for (String pat : testPatternsAlt) {
            for (int flags : flagsSet) {
                try {
                    Pattern p = Pattern.compile(pat, flags);
                    assertEquals(p.flags(), flags);
                } catch (Exception e) {
                    fail("Unexpected exception: " + e);
                }
            }
        }
    }

    public void testCompileStringInt() {
        /*
         * these tests are needed to verify that appropriate exceptions are
         * thrown
         */
        String pattern = "b)a";
        try {
            Pattern.compile(pattern);
            fail("Expected a PatternSyntaxException when compiling pattern: "
                    + pattern);
        } catch (PatternSyntaxException e) {
            // pass
        }
        pattern = "bcde)a";
        try {
            Pattern.compile(pattern);
            fail("Expected a PatternSyntaxException when compiling pattern: "
                    + pattern);
        } catch (PatternSyntaxException e) {
            // pass
        }
        pattern = "bbg())a";
        try {
            Pattern pat = Pattern.compile(pattern);
            fail("Expected a PatternSyntaxException when compiling pattern: "
                    + pattern);
        } catch (PatternSyntaxException e) {
            // pass
        }

        pattern = "cdb(?i))a";
        try {
            Pattern pat = Pattern.compile(pattern);
            fail("Expected a PatternSyntaxException when compiling pattern: "
                    + pattern);
        } catch (PatternSyntaxException e) {
            // pass
        }

        /*
         * This pattern should compile - HARMONY-2127
         * icu4c doesn't support canonical equivalence.
         */
//        pattern = "x(?c)y";
//        Pattern.compile(pattern);

        /*
         * this pattern doesn't match any string, but should be compiled anyway
         */
        pattern = "(b\\1)a";
        Pattern.compile(pattern);
    }

    /*
     * Class under test for Pattern compile(String)
     */
    public void testQuantCompileNeg() {
        String[] patterns = { "5{,2}", "{5asd", "{hgdhg", "{5,hjkh", "{,5hdsh",
                "{5,3shdfkjh}" };
        for (String element : patterns) {
            try {
                Pattern.compile(element);
                fail("PatternSyntaxException was expected, but compilation succeeds");
            } catch (PatternSyntaxException pse) {
                continue;
            }
        }
        // Regression for HARMONY-1365
// BEGIN Android-changed
// Original regex contained some illegal stuff. Changed it slightly,
// while maintaining the wicked character of this "mother of all
// regexes".
//        String pattern = "(?![^\\<C\\f\\0146\\0270\\}&&[|\\02-\\x3E\\}|X-\\|]]{7,}+)[|\\\\\\x98\\<\\?\\u4FCFr\\,\\0025\\}\\004|\\0025-\\052\061]|(?<![|\\01-\\u829E])|(?<!\\p{Alpha})|^|(?-s:[^\\x15\\\\\\x24F\\a\\,\\a\\u97D8[\\x38\\a[\\0224-\\0306[^\\0020-\\u6A57]]]]??)(?uxix:[^|\\{\\[\\0367\\t\\e\\x8C\\{\\[\\074c\\]V[|b\\fu\\r\\0175\\<\\07f\\066s[^D-\\x5D]]])(?xx:^{5,}+)(?uuu)(?=^\\D)|(?!\\G)(?>\\G*?)(?![^|\\]\\070\\ne\\{\\t\\[\\053\\?\\\\\\x51\\a\\075\\0023-\\[&&[|\\022-\\xEA\\00-\\u41C2&&[^|a-\\xCC&&[^\\037\\uECB3\\u3D9A\\x31\\|\\<b\\0206\\uF2EC\\01m\\,\\ak\\a\\03&&\\p{Punct}]]]])(?-dxs:[|\\06-\\07|\\e-\\x63&&[|Tp\\u18A3\\00\\|\\xE4\\05\\061\\015\\0116C|\\r\\{\\}\\006\\xEA\\0367\\xC4\\01\\0042\\0267\\xBB\\01T\\}\\0100\\?[|\\[-\\u459B|\\x23\\x91\\rF\\0376[|\\?-\\x94\\0113-\\\\\\s]]]]{6}?)(?<=[^\\t-\\x42H\\04\\f\\03\\0172\\?i\\u97B6\\e\\f\\uDAC2])(?=\\B*+)(?>[^\\016\\r\\{\\,\\uA29D\\034\\02[\\02-\\[|\\t\\056\\uF599\\x62\\e\\<\\032\\uF0AC\\0026\\0205Q\\|\\\\\\06\\0164[|\\057-\\u7A98&&[\\061-g|\\|\\0276\\n\\042\\011\\e\\xE8\\x64B\\04\\u6D0EDW^\\p{Lower}]]]]?)(?<=[^\\n\\\\\\t\\u8E13\\,\\0114\\u656E\\xA5\\]&&[\\03-\\026|\\uF39D\\01\\{i\\u3BC2\\u14FE]])(?<=[^|\\uAE62\\054H\\|\\}&&^\\p{Space}])(?sxx)(?<=[\\f\\006\\a\\r\\xB4]*+)|(?x-xd:^{5}+)()";
        String pattern = "(?![^\\<C\\f\\0146\\0270\\}&&[|\\02-\\x3E\\}|X-\\|]]{7,}+)[|\\\\\\x98\\<\\?\\u4FCFr\\,\\0025\\}\\004|\\0025-\\052\061]|(?<![|\\01-\\u829E])|(?<!\\p{Alpha})|^|(?-s:[^\\x15\\\\\\x24F\\a\\,\\a\\u97D8[\\x38\\a[\\0224-\\0306[^\\0020-\\u6A57]]]]??)(?uxix:[^|\\{\\[\\0367\\t\\e\\x8C\\{\\[\\074c\\]V[|b\\fu\\r\\0175\\<\\07f\\066s[^D-\\x5D]]])(?xx:^{5,}+)(?uuu)(?=^\\D)|(?!\\G)(?>\\.*?)(?![^|\\]\\070\\ne\\{\\t\\[\\053\\?\\\\\\x51\\a\\075\\0023-\\[&&[|\\022-\\xEA\\00-\\u41C2&&[^|a-\\xCC&&[^\\037\\uECB3\\u3D9A\\x31\\|\\<b\\0206\\uF2EC\\01m\\,\\ak\\a\\03&&\\p{Punct}]]]])(?-dxs:[|\\06-\\07|\\e-\\x63&&[|Tp\\u18A3\\00\\|\\xE4\\05\\061\\015\\0116C|\\r\\{\\}\\006\\xEA\\0367\\xC4\\01\\0042\\0267\\xBB\\01T\\}\\0100\\?[|\\[-\\u459B|\\x23\\x91\\rF\\0376[|\\?-\\x94\\0113-\\\\\\s]]]]{6}?)(?<=[^\\t-\\x42H\\04\\f\\03\\0172\\?i\\u97B6\\e\\f\\uDAC2])(?=\\.*+)(?>[^\\016\\r\\{\\,\\uA29D\\034\\02[\\02-\\[|\\t\\056\\uF599\\x62\\e\\<\\032\\uF0AC\\0026\\0205Q\\|\\\\\\06\\0164[|\\057-\\u7A98&&[\\061-g|\\|\\0276\\n\\042\\011\\e\\xE8\\x64B\\04\\u6D0EDW^\\p{Lower}]]]]?)(?<=[^\\n\\\\\\t\\u8E13\\,\\0114\\u656E\\xA5\\]&&[\\03-\\026|\\uF39D\\01\\{i\\u3BC2\\u14FE]])(?<=[^|\\uAE62\\054H\\|\\}&&^\\p{Space}])(?sxx)(?<=[\\f\\006\\a\\r\\xB4]{1,5})|(?x-xd:^{5}+)()";
// END Android-changed
        assertNotNull(Pattern.compile(pattern));
    }

    public void testQuantCompilePos() {
        String[] patterns = {/* "(abc){1,3}", */"abc{2,}", "abc{5}" };
        for (String element : patterns) {
            Pattern.compile(element);
        }
    }

    public void testQuantComposition() {
        String pattern = "(a{1,3})aab";
        java.util.regex.Pattern pat = java.util.regex.Pattern.compile(pattern);
        java.util.regex.Matcher mat = pat.matcher("aaab");
        mat.matches();
        mat.start(1);
        mat.group(1);
    }

    public void testMatches() {
        String[][] posSeq = {
                { "abb", "ababb", "abababbababb", "abababbababbabababbbbbabb" },
                { "213567", "12324567", "1234567", "213213567",
                        "21312312312567", "444444567" },
                { "abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab" },
                { "213234567", "3458", "0987654", "7689546432", "0398576",
                        "98432", "5" },
                {
                        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
                        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" },
                { "ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa",
                        "abbbAbbbliceaaa", "Alice" },
                { "a123", "bnxnvgds156", "for", "while", "if", "struct" },
                { "xy" }, { "xy" }, { "xcy" }

        };

        for (int i = 0; i < testPatterns.length; i++) {
            for (int j = 0; j < posSeq[i].length; j++) {
                assertTrue("Incorrect match: " + testPatterns[i] + " vs "
                        + posSeq[i][j], Pattern.matches(testPatterns[i],
                        posSeq[i][j]));
            }
        }
    }

    public void testMatchesException() {
        /* Negative assertion test. */
        for (String aPattern : wrongTestPatterns) {
            try {
                Pattern.matches(aPattern, "Foo");
                fail("PatternSyntaxException is expected");
            } catch (PatternSyntaxException pse) {
                /* OKAY */
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }
    }

    public void testTimeZoneIssue() {
        Pattern p = Pattern.compile("GMT(\\+|\\-)(\\d+)(:(\\d+))?");
        Matcher m = p.matcher("GMT-9:45");
        assertTrue(m.matches());
        assertEquals("-", m.group(1));
        assertEquals("9", m.group(2));
        assertEquals(":45", m.group(3));
        assertEquals("45", m.group(4));
    }

// BEGIN Android-changed
// Removed one pattern that is buggy on the JDK. We don't want to duplicate that.
    public void testCompileRanges() {
        String[] correctTestPatterns = { "[^]*abb]*", /* "[^a-d[^m-p]]*abb", */
                "[a-d\\d]*abb", "[abc]*abb", "[a-e&&[de]]*abb", "[^abc]*abb",
                "[a-e&&[^de]]*abb", "[a-z&&[^m-p]]*abb", "[a-d[m-p]]*abb",
                "[a-zA-Z]*abb", "[+*?]*abb", "[^+*?]*abb" };

        String[] inputSecuence = { "kkkk", /* "admpabb", */ "abcabcd124654abb",
                "abcabccbacababb", "dededededededeedabb", "gfdhfghgdfghabb",
                "accabacbcbaabb", "acbvfgtyabb", "adbcacdbmopabcoabb",
                "jhfkjhaSDFGHJkdfhHNJMjkhfabb", "+*??+*abb", "sdfghjkabb" };

        Pattern pat;

        for (int i = 0; i < correctTestPatterns.length; i++) {
            assertTrue("pattern: " + correctTestPatterns[i] + " input: "
                    + inputSecuence[i], Pattern.matches(correctTestPatterns[i],
                    inputSecuence[i]));

        }

        String[] wrongInputSecuence = { "]", /* "admpkk", */  "abcabcd124k654abb",
                "abwcabccbacababb", "abababdeababdeabb", "abcabcacbacbabb",
                "acdcbecbaabb", "acbotyabb", "adbcaecdbmopabcoabb",
                "jhfkjhaSDFGHJk;dfhHNJMjkhfabb", "+*?a?+*abb", "sdf+ghjkabb" };

        for (int i = 0; i < correctTestPatterns.length; i++) {
            assertFalse("pattern: " + correctTestPatterns[i] + " input: "
                    + wrongInputSecuence[i], Pattern.matches(
                    correctTestPatterns[i], wrongInputSecuence[i]));

        }
    }

    public void testRangesSpecialCases() {
        String neg_patterns[] = { "[a-&&[b-c]]", "[a-\\w]", "[b-a]", "[]" };

        for (String element : neg_patterns) {
            try {
                Pattern.compile(element);
                fail("PatternSyntaxException was expected: " + element);
            } catch (PatternSyntaxException pse) {
            }
        }

        String pos_patterns[] = { "[-]+", "----", "[a-]+", "a-a-a-a-aa--",
                "[\\w-a]+", "123-2312--aaa-213", "[a-]]+", "-]]]]]]]]]]]]]]]" };

        for (int i = 0; i < pos_patterns.length; i++) {
            String pat = pos_patterns[i++];
            String inp = pos_patterns[i];
            assertTrue("pattern: " + pat + " input: " + inp, Pattern.matches(
                    pat, inp));
        }
    }
 // END Android-changed

    public void testZeroSymbols() {
        assertTrue(Pattern.matches("[\0]*abb", "\0\0\0\0\0\0abb"));
    }

    public void testEscapes() {
        Pattern pat = Pattern.compile("\\Q{]()*?");
        Matcher mat = pat.matcher("{]()*?");

        assertTrue(mat.matches());
    }

    public void test_bug_181() {
        Pattern.compile("[\\t-\\r]");
    }

    // https://code.google.com/p/android/issues/detail?id=40103
    public void test_bug_40103() {
        Pattern.compile("(?<!abc {1,100}|def {1,100}|ghi {1,100})jkl");

        // Looks like harmony had a similar "Bug187"...
        Pattern.compile("|(?idmsux-idmsux)|(?idmsux-idmsux)|[^|\\[-\\0274|\\,-\\\\[^|W\\}\\nq\\x65\\002\\xFE\\05\\06\\00\\x66\\x47i\\,\\xF2\\=\\06\\u0EA4\\x9B\\x3C\\f\\|\\{\\xE5\\05\\r\\u944A\\xCA\\e|\\x19\\04\\x07\\04\\u607B\\023\\0073\\x91Tr\\0150\\x83]]?(?idmsux-idmsux:\\p{Alpha}{7}?)||(?<=[^\\uEC47\\01\\02\\u3421\\a\\f\\a\\013q\\035w\\e])(?<=\\p{Punct}{0,}?)(?=^\\p{Lower})(?!\\b{8,14})(?<![|\\00-\\0146[^|\\04\\01\\04\\060\\f\\u224DO\\x1A\\xC4\\00\\02\\0315\\0351\\u84A8\\xCBt\\xCC\\06|\\0141\\00\\=\\e\\f\\x6B\\0026Tb\\040\\x76xJ&&[\\\\-\\]\\05\\07\\02\\u2DAF\\t\\x9C\\e\\0023\\02\\,X\\e|\\u6058flY\\u954C]]]{5}?)(?<=\\p{Sc}{8}+)[^|\\026-\\u89BA|o\\u6277\\t\\07\\x50&&\\p{Punct}]{8,14}+((?<=^\\p{Punct})|(?idmsux-idmsux)||(?>[\\x3E-\\]])|(?idmsux-idmsux:\\p{Punct})|(?<![\\0111\\0371\\xDF\\u6A49\\07\\u2A4D\\00\\0212\\02Xd-\\xED[^\\a-\\0061|\\0257\\04\\f\\[\\0266\\043\\03\\x2D\\042&&[^\\f-\\]&&\\s]]])|(?>[|\\n\\042\\uB09F\\06\\u0F2B\\uC96D\\x89\\uC166\\xAA|\\04-\\][^|\\a\\|\\rx\\04\\uA770\\n\\02\\t\\052\\056\\0274\\|\\=\\07\\e|\\00-\\x1D&&[^\\005\\uB15B\\uCDAC\\n\\x74\\0103\\0147\\uD91B\\n\\062G\\u9B4B\\077\\}\\0324&&[^\\0302\\,\\0221\\04\\u6D16\\04xy\\uD193\\[\\061\\06\\045\\x0F|\\e\\xBB\\f\\u1B52\\023\\u3AD2\\033\\007\\022\\}\\x66\\uA63FJ-\\0304]]]]{0,0})||(?<![^|\\0154U\\u0877\\03\\fy\\n\\|\\0147\\07-\\=[|q\\u69BE\\0243\\rp\\053\\02\\x33I\\u5E39\\u9C40\\052-\\xBC[|\\0064-\\?|\\uFC0C\\x30\\0060\\x45\\\\\\02\\?p\\xD8\\0155\\07\\0367\\04\\uF07B\\000J[^|\\0051-\\{|\\u9E4E\\u7328\\]\\u6AB8\\06\\x71\\a\\]\\e\\|KN\\u06AA\\0000\\063\\u2523&&[\\005\\0277\\x41U\\034\\}R\\u14C7\\u4767\\x09\\n\\054Ev\\0144\\<\\f\\,Q-\\xE4]]]]]{3}+)|(?>^+)|(?![^|\\|\\nJ\\t\\<\\04E\\\\\\t\\01\\\\\\02\\|\\=\\}\\xF3\\uBEC2\\032K\\014\\uCC5F\\072q\\|\\0153\\xD9\\0322\\uC6C8[^\\t\\0342\\x34\\x91\\06\\{\\xF1\\a\\u1710\\?\\xE7\\uC106\\02pF\\<&&[^|\\]\\064\\u381D\\u50CF\\eO&&[^|\\06\\x2F\\04\\045\\032\\u8536W\\0377\\0017|\\x06\\uE5FA\\05\\xD4\\020\\04c\\xFC\\02H\\x0A\\r]]]]+?)(?idmsux-idmsux)|(?<![|\\r-\\,&&[I\\t\\r\\0201\\xDB\\e&&[^|\\02\\06\\00\\<\\a\\u7952\\064\\051\\073\\x41\\?n\\040\\0053\\031&&[\\x15-\\|]]]]{8,11}?)(?![^|\\<-\\uA74B\\xFA\\u7CD2\\024\\07n\\<\\x6A\\0042\\uE4FF\\r\\u896B\\[\\=\\042Y&&^\\p{ASCII}]++)|(?<![R-\\|&&[\\a\\0120A\\u6145\\<\\050-d[|\\e-\\uA07C|\\016-\\u80D9]]]{1,}+)|(?idmsux-idmsux)|(?idmsux-idmsux)|(?idmsux-idmsux:\\B{6,}?)|(?<=\\D{5,8}?)|(?>[\\{-\\0207|\\06-\\0276\\p{XDigit}])(?idmsux-idmsux:[^|\\x52\\0012\\]u\\xAD\\0051f\\0142\\\\l\\|\\050\\05\\f\\t\\u7B91\\r\\u7763\\{|h\\0104\\a\\f\\0234\\u2D4F&&^\\P{InGreek}]))");
    }

    public void test_bug_4472() {
        // HARMONY-4472
        Pattern.compile("a*.+");
    }

    public void test_bug_5858() {
        // HARMONY-5858
        Pattern.compile("\\u6211", Pattern.LITERAL);
    }

    public void testOrphanQuantifiers() {
        try {
            Pattern.compile("+++++");
            fail("PatternSyntaxException expected");
        } catch (PatternSyntaxException pse) {
        }
    }

    public void testOrphanQuantifiers2() {
        try {
            Pattern pat = Pattern.compile("\\d+*");
            fail("PatternSyntaxException expected");
        } catch (PatternSyntaxException pse) {
        }
    }

    public void testBug197() {
        Object[] vals = { ":", new Integer(2),
                new String[] { "boo", "and:foo" }, ":", new Integer(5),
                new String[] { "boo", "and", "foo" }, ":", new Integer(-2),
                new String[] { "boo", "and", "foo" }, ":", new Integer(3),
                new String[] { "boo", "and", "foo" }, ":", new Integer(1),
                new String[] { "boo:and:foo" }, "o", new Integer(5),
                new String[] { "b", "", ":and:f", "", "" }, "o",
                new Integer(4), new String[] { "b", "", ":and:f", "o" }, "o",
                new Integer(-2), new String[] { "b", "", ":and:f", "", "" },
                "o", new Integer(0), new String[] { "b", "", ":and:f" } };

        for (int i = 0; i < vals.length / 3;) {
            String[] res = Pattern.compile(vals[i++].toString()).split(
                    "boo:and:foo", ((Integer) vals[i++]).intValue());
            String[] expectedRes = (String[]) vals[i++];

            assertEquals(expectedRes.length, res.length);

            for (int j = 0; j < expectedRes.length; j++) {
                assertEquals(expectedRes[j], res[j]);
            }
        }
    }

    public void testURIPatterns() {
        String URI_REGEXP_STR = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?";
        String SCHEME_REGEXP_STR = "^[a-zA-Z]{1}[\\w+-.]+$";
        String REL_URI_REGEXP_STR = "^(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?";
        String IPV6_REGEXP_STR = "^[0-9a-fA-F\\:\\.]+(\\%\\w+)?$";
        String IPV6_REGEXP_STR2 = "^\\[[0-9a-fA-F\\:\\.]+(\\%\\w+)?\\]$";
        String IPV4_REGEXP_STR = "^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$";
        String HOSTNAME_REGEXP_STR = "\\w+[\\w\\-\\.]*";

        Pattern.compile(URI_REGEXP_STR);
        Pattern.compile(REL_URI_REGEXP_STR);
        Pattern.compile(SCHEME_REGEXP_STR);
        Pattern.compile(IPV4_REGEXP_STR);
        Pattern.compile(IPV6_REGEXP_STR);
        Pattern.compile(IPV6_REGEXP_STR2);
        Pattern.compile(HOSTNAME_REGEXP_STR);
    }

    public void testFindBoundaryCases1() {
        Pattern pat = Pattern.compile(".*\n");
        Matcher mat = pat.matcher("a\n");

        mat.find();
        assertEquals("a\n", mat.group());
    }

    public void testFindBoundaryCases2() {
        Pattern pat = Pattern.compile(".*A");
        Matcher mat = pat.matcher("aAa");

        mat.find();
        assertEquals("aA", mat.group());
    }

    public void testFindBoundaryCases3() {
        Pattern pat = Pattern.compile(".*A");
        Matcher mat = pat.matcher("a\naA\n");

        mat.find();
        assertEquals("aA", mat.group());
    }

    public void testFindBoundaryCases4() {
        Pattern pat = Pattern.compile("A.*");
        Matcher mat = pat.matcher("A\n");

        mat.find();
        assertEquals("A", mat.group());
    }

    public void testFindBoundaryCases5() {
        Pattern pat = Pattern.compile(".*A.*");
        Matcher mat = pat.matcher("\nA\naaa\nA\naaAaa\naaaA\n");
        // Matcher mat = pat.matcher("\nA\n");
        String[] res = { "A", "A", "aaAaa", "aaaA" };
        int k = 0;
        for (; mat.find(); k++) {
            assertEquals(res[k], mat.group());
        }
    }

    public void testFindBoundaryCases6() {
        String[] res = { "", "a", "", "" };
        Pattern pat = Pattern.compile(".*");
        Matcher mat = pat.matcher("\na\n");
        int k = 0;
        for (; mat.find(); k++) {
            assertEquals(res[k], mat.group());
        }
        assertEquals(4, k);
    }

    public void testBackReferences() {
        Pattern pat = Pattern.compile("(\\((\\w*):(.*):(\\2)\\))");
        Matcher mat = pat.matcher("(start1: word :start1)(start2: word :start2)");
        int k = 1;
        for (; mat.find(); k++) {
            assertEquals("start" + k, mat.group(2));
            assertEquals(" word ", mat.group(3));
            assertEquals("start" + k, mat.group(4));
        }

        assertEquals(3, k);
        pat = Pattern.compile(".*(.)\\1");
        mat = pat.matcher("saa");
        assertTrue(mat.matches());
    }

    public void testNewLine() {
        Pattern pat = Pattern.compile("(^$)*\n", Pattern.MULTILINE);
        Matcher mat = pat.matcher("\r\n\n");
        int counter = 0;
        while (mat.find()) {
            counter++;
        }
        assertEquals(2, counter);
    }

    public void testFindGreedy() {
        Pattern pat = Pattern.compile(".*aaa", Pattern.DOTALL);
        Matcher mat = pat.matcher("aaaa\naaa\naaaaaa");
        mat.matches();
        assertEquals(15, mat.end());
    }

    public void testSerialization() throws Exception {
        Pattern pat = Pattern.compile("a*bc");
        SerializableAssert comparator = new SerializableAssert() {
            public void assertDeserialized(Serializable initial,
                    Serializable deserialized) {
                assertEquals(((Pattern) initial).toString(),
                        ((Pattern) deserialized).toString());
            }
        };
        SerializationTest.verifyGolden(this, pat, comparator);
        SerializationTest.verifySelf(pat, comparator);
    }

    public void testSOLQuant() {
        Pattern pat = Pattern.compile("$*", Pattern.MULTILINE);
        Matcher mat = pat.matcher("\n\n");
        int counter = 0;
        while (mat.find()) {
            counter++;
        }

        assertEquals(3, counter);
    }

    public void testIllegalEscape() {
        try {
            Pattern.compile("\\y");
            fail("PatternSyntaxException expected");
        } catch (PatternSyntaxException pse) {
        }
    }

    public void testEmptyFamily() {
        Pattern.compile("\\p{Lower}");
    }

    public void testCapture_Flags() {
        Pattern pat = Pattern.compile("(?i)b*(?-i)a*");
        assertTrue(pat.matcher("bBbBaaaa").matches());
        assertFalse(pat.matcher("bBbBAaAa").matches());
    }

    public void testCapture_NonCaptGroups() {
        Pattern pat = Pattern.compile("(?i:b*)a*");
        assertTrue(pat.matcher("bBbBaaaa").matches());
        assertFalse(pat.matcher("bBbBAaAa").matches());
    }

    public void testCapture() {
        Pattern pat = Pattern
                // 1 2 3 4 5 6 7 8 9 10 11
                .compile(
                        "(?:-|(-?\\d+\\d\\d\\d))?(?:-|-(\\d\\d))?(?:-|-(\\d\\d))?(T)?(?:(\\d\\d):(\\d\\d):(\\d\\d)(\\.\\d+)?)?(?:(?:((?:\\+|\\-)\\d\\d):(\\d\\d))|(Z))?");
        Matcher mat = pat.matcher("-1234-21-31T41:51:61.789+71:81");
        assertTrue(mat.matches());
        assertEquals("-1234", mat.group(1));
        assertEquals("21", mat.group(2));
        assertEquals("31", mat.group(3));
        assertEquals("T", mat.group(4));
        assertEquals("41", mat.group(5));
        assertEquals("51", mat.group(6));
        assertEquals("61", mat.group(7));
        assertEquals(".789", mat.group(8));
        assertEquals("+71", mat.group(9));
        assertEquals("81", mat.group(10));
    }

    public void testCapture_PositiveLookahead() {
        Pattern pat = Pattern.compile(".*\\.(?=log$).*$");
        assertTrue(pat.matcher("a.b.c.log").matches());
        assertFalse(pat.matcher("a.b.c.log.").matches());
    }

    public void testCapture_NegativeLookahead() {
        Pattern pat = Pattern.compile(".*\\.(?!log$).*$");
        assertFalse(pat.matcher("abc.log").matches());
        assertTrue(pat.matcher("abc.logg").matches());
    }

    public void testCapture_PositiveLookbehind() {
        Pattern pat = Pattern.compile(".*(?<=abc)\\.log$");
        assertFalse(pat.matcher("cde.log").matches());
        assertTrue(pat.matcher("abc.log").matches());
    }

    public void testCapture_NegativeLookbehind() {
        Pattern pat = Pattern.compile(".*(?<!abc)\\.log$");
        assertTrue(pat.matcher("cde.log").matches());
        assertFalse(pat.matcher("abc.log").matches());
    }

    public void testCapture_AtomicGroupCase1() {
        Pattern pat = Pattern.compile("(?>a*)abb");
        assertFalse(pat.matcher("aaabb").matches());
    }

    public void testCapture_AtomicGroupCase2() {
        Pattern pat = Pattern.compile("(?>a*)bb");
        assertTrue(pat.matcher("aaabb").matches());
    }

    public void testCapture_AtomicGroupCase3() {
        Pattern pat = Pattern.compile("(?>a|aa)aabb");
        assertTrue(pat.matcher("aaabb").matches());
    }

    public void testCapture_AtomicGroupCase4() {
        Pattern pat = Pattern.compile("(?>aa|a)aabb");
        assertFalse(pat.matcher("aaabb").matches());

// BEGIN Android-removed
// Questionable constructs that ICU doesn't support.
//        // quantifiers over look ahead
//        pat = Pattern.compile(".*(?<=abc)*\\.log$");
//        assertTrue(pat.matcher("cde.log").matches());
//        pat = Pattern.compile(".*(?<=abc)+\\.log$");
//        assertFalse(pat.matcher("cde.log").matches());
// END Android-removed

    }

    public void testCorrectReplacementBackreferencedJointSet() {
        Pattern.compile("ab(a)*\\1");
        Pattern.compile("abc(cd)fg");
        Pattern.compile("aba*cd");
        Pattern.compile("ab(a)*+cd");
        Pattern.compile("ab(a)*?cd");
        Pattern.compile("ab(a)+cd");
        Pattern.compile(".*(.)\\1");
        Pattern.compile("ab((a)|c|d)e");
        Pattern.compile("abc((a(b))cd)");
        Pattern.compile("ab(a)++cd");
        Pattern.compile("ab(a)?(c)d");
        Pattern.compile("ab(a)?+cd");
        Pattern.compile("ab(a)??cd");
        Pattern.compile("ab(a)??cd");
        Pattern.compile("ab(a){1,3}?(c)d");
    }

    public void testCompilePatternWithTerminatorMark() {
        Pattern pat = Pattern.compile("a\u0000\u0000cd");
        Matcher mat = pat.matcher("a\u0000\u0000cd");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase1() {
        String baseString = "|a|bc";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("");

        assertTrue(mat.matches());
    }

    public void testAlternationsCase2() {
        String baseString = "a||bc";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase3() {
        String baseString = "a|bc|";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase4() {
        String baseString = "a|b|";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase5() {
        String baseString = "a(|b|cd)e";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("ae");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase6() {
        String baseString = "a(b||cd)e";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("ae");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase7() {
        String baseString = "a(b|cd|)e";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("ae");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase8() {
        String baseString = "a(b|c|)e";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("ae");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase9() {
        String baseString = "a(|)e";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("ae");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase10() {
        String baseString = "|";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase11() {
        String baseString = "a(?:|)e";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("ae");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase12() {
        String baseString = "a||||bc";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("");
        assertTrue(mat.matches());
    }

    public void testAlternationsCase13() {
        String baseString = "(?i-is)|a";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher("a");
        assertTrue(mat.matches());
    }

    public void testMatchWithGroups14() {
        String baseString = "jwkerhjwehrkwjehrkwjhrwkjehrjwkehrjkwhrkwehrkwhrkwrhwkhrwkjehr";
        String pattern = ".*(..).*\\1.*";
        assertTrue(Pattern.compile(pattern).matcher(baseString).matches());
    }

    public void testMatchWithGroups15() {
        String baseString = "saa";
        String pattern = ".*(.)\\1";
        assertTrue(Pattern.compile(pattern).matcher(baseString).matches());
        assertTrue(Pattern.compile(pattern).matcher(baseString).find());
    }

    public void testSplitEmptyCharSequence() {
        String s = "";
        String[] arr = s.split(":");

        assertEquals(arr.length, 1);
    }

    public void testSplitEndsWithPattern() {
        assertEquals(",,".split(",", 3).length, 3);
        assertEquals(",,".split(",", 4).length, 3);

        assertEquals(Pattern.compile("o").split("boo:and:foo", 5).length, 5);
        assertEquals(Pattern.compile("b").split("ab", -1).length, 2);
    }

    public void testCaseInsensitiveFlag() {
        assertTrue(Pattern.matches("(?i-:AbC)", "ABC"));
    }

    public void testEmptyGroupsCase1() {
        Pattern pat = Pattern.compile("ab(?>)cda");
        Matcher mat = pat.matcher("abcda");

        assertTrue(mat.matches());
    }

    public void testEmptyGroupsCase2() {
        Pattern pat = Pattern.compile("ab()");
        Matcher mat = pat.matcher("ab");

        assertTrue(mat.matches());
    }

    public void testEmptyGroupsCase3() {
        Pattern pat = Pattern.compile("abc(?:)(..)");
        Matcher mat = pat.matcher("abcgf");

        assertTrue(mat.matches());
    }

    public void testEmbeddedFlagsCase1() {
        String baseString = "(?i)((?s)a)";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);

        assertTrue(mat.matches());
    }

    public void testEmbeddedFlagsCase2() {
        String baseString = "(?x)(?i)(?s)(?d)a";
        String testString = "A";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);

        assertTrue(mat.matches());
    }

    public void testEmbeddedFlagsCase3() {
        String baseString = "(?x)(?i)(?s)(?d)a.";
        String testString = "a\n";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testEmbeddedFlagsCase4() {
        String baseString = "abc(?x:(?i)(?s)(?d)a.)";
        String testString = "abcA\n";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testEmbeddedFlagsCase5() {
        String baseString = "abc((?x)d)(?i)(?s)a";
        String testString = "abcdA";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testAltWithFlags() {
        Pattern.compile("|(?i-xi)|()");
    }

    public void testRestoreFlagsAfterGroup() {
        String baseString = "abc((?x)d)   a";
        String testString = "abcd   a";
        Pattern pat = Pattern.compile(baseString);
        Matcher mat = pat.matcher(testString);

        assertTrue(mat.matches());
    }

    /*
     * Verify if the Pattern support the following character classes:
     * \p{javaLowerCase} \p{javaUpperCase} \p{javaWhitespace} \p{javaMirrored}
     */
    public void testCompileCharacterClass() {
        // Regression for HARMONY-606, 696
        Pattern pattern = Pattern.compile("\\p{javaLowerCase}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaUpperCase}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaWhitespace}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaMirrored}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaDefined}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaDigit}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaIdentifierIgnorable}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaISOControl}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaJavaIdentifierPart}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaJavaIdentifierStart}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaLetter}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaLetterOrDigit}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaSpaceChar}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaTitleCase}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaUnicodeIdentifierPart}");
        assertNotNull(pattern);

        pattern = Pattern.compile("\\p{javaUnicodeIdentifierStart}");
        assertNotNull(pattern);
    }

    public void testRangesWithSurrogatesSupplementaryCase1() {
        String patString = "[abc\uD8D2]";
        String testString = "\uD8D2";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testRangesWithSurrogatesSupplementaryCase2() {
        String patString = "[abc\uD8D2]";
        String testString = "a";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testRangesWithSurrogatesSupplementaryCase3() {
        String patString = "[abc\uD8D2]";
        String testString = "ef\uD8D2\uDD71gh";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    public void testRangesWithSurrogatesSupplementaryCase4() {
        String patString = "[abc\uD8D2]";
        String testString = "ef\uD8D2gh";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testRangesWithSurrogatesSupplementaryCase5() {
        String patString = "[abc\uD8D3&&[c\uD8D3]]";
        String testString = "c";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testRangesWithSurrogatesSupplementaryCase6() {
        String patString = "[abc\uD8D3&&[c\uD8D3]]";
        String testString = "a";;
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testRangesWithSurrogatesSupplementaryCase7() {
        String patString = "[abc\uD8D3&&[c\uD8D3]]";
        String testString = "ef\uD8D3\uDD71gh";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    public void testRangesWithSurrogatesSupplementaryCase8() {
        String patString = "[abc\uD8D3&&[c\uD8D3]]";
        String testString = "ef\uD8D3gh";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testRangesWithSurrogatesSupplementaryCase9() {
        String patString = "[abc\uD8D3\uDBEE\uDF0C&&[c\uD8D3\uDBEE\uDF0C]]";
        String testString = "c";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testRangesWithSurrogatesSupplementaryCase10() {
        String patString = "[abc\uD8D3\uDBEE\uDF0C&&[c\uD8D3\uDBEE\uDF0C]]";
        String testString = "\uDBEE\uDF0C";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testRangesWithSurrogatesSupplementaryCase11() {
        String patString = "[abc\uD8D3\uDBEE\uDF0C&&[c\uD8D3\uDBEE\uDF0C]]";
        String testString = "ef\uD8D3\uDD71gh";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    public void testRangesWithSurrogatesSupplementaryCase12() {
        String patString = "[abc\uD8D3\uDBEE\uDF0C&&[c\uD8D3\uDBEE\uDF0C]]";
        String testString = "ef\uD8D3gh";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testRangesWithSurrogatesSupplementaryCase13() {
        String patString = "[abc\uDBFC]\uDDC2cd";
        String testString = "\uDBFC\uDDC2cd";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testRangesWithSurrogatesSupplementaryCase14() {
        String patString = "[abc\uDBFC]\uDDC2cd";
        String testString = "a\uDDC2cd";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testSequencesWithSurrogatesSupplementaryCase1() {
        String patString = "abcd\uD8D3";
        String testString = "abcd\uD8D3\uDFFC";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
// BEGIN Android-changed
// This one really doesn't make sense, as the above is a corrupt surrogate.
// Even if it's matched by the JDK, it's more of a bug than of a behavior one
// might want to duplicate.
//        assertFalse(mat.find());
// END Android-changed
    }


    public void testSequencesWithSurrogatesSupplementaryCase2() {
        String patString = "abcd\uD8D3";
        String testString = "abcd\uD8D3abc";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testSequencesWithSurrogatesSupplementaryCase3() {
        String patString = "ab\uDBEFcd";
        String testString = "ab\uDBEFcd";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testSequencesWithSurrogatesSupplementaryCase4() {
        String patString = "\uDFFCabcd";
        String testString = "\uD8D3\uDFFCabcd";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    public void testSequencesWithSurrogatesSupplementaryCase5() {
        String patString = "\uDFFCabcd";
        String testString = "abc\uDFFCabcdecd";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testSequencesWithSurrogatesSupplementaryCase6String () {
        String patString = "\uD8D3\uDFFCabcd";
        String testString = "abc\uD8D3\uD8D3\uDFFCabcd";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase1() {
        String patString = "[123\\D]";
        String testString = "a";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase2() {
        String patString = "[123\\D]";
        String testString = "5";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase3() {
        String patString = "[123\\D]";
        String testString = "3";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase4() {
        // low surrogate
        String patString = "[123\\D]";
        String testString = "\uDFC4";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase5() {
        // high surrogate
        String patString = "[123\\D]";
        String testString = "\uDADA";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase6() {
        String patString = "[123\\D]";
        String testString = "\uDADA\uDFC4";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase7() {
        String patString = "[123[^\\p{javaDigit}]]";
        String testString = "a";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase8() {
        String patString = "[123[^\\p{javaDigit}]]";
        String testString = "5";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase9() {
        String patString = "[123[^\\p{javaDigit}]]";
        String testString = "3";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase10() {
        // low surrogate
        String patString = "[123[^\\p{javaDigit}]]";
        String testString = "\uDFC4";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase11() {
        // high surrogate
        String patString = "[123[^\\p{javaDigit}]]";
        String testString = "\uDADA";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase12() {
        String patString = "[123[^\\p{javaDigit}]]";
        String testString = "\uDADA\uDFC4";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase13() {
        // surrogate characters
        String patString = "\\p{Cs}";
        String testString = "\uD916\uDE27";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        /*
         * see http://www.unicode.org/reports/tr18/#Supplementary_Characters we
         * have to treat text as code points not code units. \\p{Cs} matches any
         * surrogate character but here testString is a one code point
         * consisting of two code units (two surrogate characters) so we find
         * nothing
         */
        // assertFalse(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase14() {
        // swap low and high surrogates
        String patString = "\\p{Cs}";
        String testString = "\uDE27\uD916";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase15() {
        String patString = "[\uD916\uDE271\uD91623&&[^\\p{Cs}]]";
        String testString = "1";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase16() {
        String patString = "[\uD916\uDE271\uD91623&&[^\\p{Cs}]]";
        String testString = "\uD916";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase17() {
        String patString = "[\uD916\uDE271\uD91623&&[^\\p{Cs}]]";
        String testString = "\uD916\uDE27";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.find());
    }

    public void testPredefinedClassesWithSurrogatesSupplementaryCase18() {
        // \uD9A0\uDE8E=\u7828E
        // \u78281=\uD9A0\uDE81
        String patString = "[a-\uD9A0\uDE8E]";
        String testString = "\uD9A0\uDE81";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testDotConstructionWithSurrogatesSupplementaryCase1() {
        String patString = ".";
        String testString = "\uD9A0\uDE81";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testDotConstructionWithSurrogatesSupplementaryCase2() {
        String patString = ".";
        String testString = "\uDE81";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testDotConstructionWithSurrogatesSupplementaryCase3() {
        String patString = ".";
        String testString = "\uD9A0";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testDotConstructionWithSurrogatesSupplementaryCase4() {
        String patString = ".";
        String testString = "\n";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testDotConstructionWithSurrogatesSupplementaryCase5() {
        String patString = ".*\uDE81";
        String testString = "\uD9A0\uDE81\uD9A0\uDE81\uD9A0\uDE81";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testDotConstructionWithSurrogatesSupplementaryCase6() {
        String patString = ".*\uDE81";
        String testString = "\uD9A0\uDE81\uD9A0\uDE81\uDE81";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testDotConstructionWithSurrogatesSupplementaryCase7() {
        String patString = ".*";
        String testString = "\uD9A0\uDE81\n\uD9A0\uDE81\uD9A0\n\uDE81";
        Pattern pat = Pattern.compile(patString, Pattern.DOTALL);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void test_quoteLjava_lang_String() {
        for (String aPattern : testPatterns) {
            Pattern p = Pattern.compile(aPattern);
            try {
                assertEquals("quote was wrong for plain text", "\\Qtest\\E", p
                        .quote("test"));
                assertEquals("quote was wrong for text with quote sign",
                        "\\Q\\Qtest\\E", p.quote("\\Qtest"));
                assertEquals("quote was wrong for quotted text",
                        "\\Q\\Qtest\\E\\\\E\\Q\\E", p.quote("\\Qtest\\E"));
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }
    }

    public void test_matcherLjava_lang_StringLjava_lang_CharSequence() {
        String[][] posSeq = {
                { "abb", "ababb", "abababbababb", "abababbababbabababbbbbabb" },
                { "213567", "12324567", "1234567", "213213567",
                        "21312312312567", "444444567" },
                { "abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab" },
                { "213234567", "3458", "0987654", "7689546432", "0398576",
                        "98432", "5" },
                {
                        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
                        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" },
                { "ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa",
                        "abbbAbbbliceaaa", "Alice" },
                { "a123", "bnxnvgds156", "for", "while", "if", "struct" },
                { "xy" }, { "xy" }, { "xcy" }

        };

        for (int i = 0; i < testPatterns.length; i++) {
            for (int j = 0; j < posSeq[i].length; j++) {
                assertTrue("Incorrect match: " + testPatterns[i] + " vs "
                        + posSeq[i][j], Pattern.compile(testPatterns[i])
                        .matcher(posSeq[i][j]).matches());
            }
        }
    }

    public void testQuantifiersWithSurrogatesSupplementary() {
        String patString = "\uD9A0\uDE81*abc";
        String testString = "\uD9A0\uDE81\uD9A0\uDE81abc";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());

        patString = "\uD9A0\uDE81*abc";
        testString = "abc";
        pat = Pattern.compile(patString);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testAlternationsWithSurrogatesSupplementary() {
        String patString = "\uDE81|\uD9A0\uDE81|\uD9A0";
        String testString = "\uD9A0";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());

        patString = "\uDE81|\uD9A0\uDE81|\uD9A0";
        testString = "\uDE81";
        pat = Pattern.compile(patString);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        patString = "\uDE81|\uD9A0\uDE81|\uD9A0";
        testString = "\uD9A0\uDE81";
        pat = Pattern.compile(patString);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        patString = "\uDE81|\uD9A0\uDE81|\uD9A0";
        testString = "\uDE81\uD9A0";
        pat = Pattern.compile(patString);
        mat = pat.matcher(testString);
        assertFalse(mat.matches());
    }

    public void testGroupsWithSurrogatesSupplementary() {
        //this pattern matches nothing
        String patString = "(\uD9A0)\uDE81";
        String testString = "\uD9A0\uDE81";
        Pattern pat = Pattern.compile(patString);
        Matcher mat = pat.matcher(testString);
        assertFalse(mat.matches());

        patString = "(\uD9A0)";
        testString = "\uD9A0\uDE81";
        pat = Pattern.compile(patString, Pattern.DOTALL);
        mat = pat.matcher(testString);
        assertFalse(mat.find());
    }

    /*
     * Regression test for HARMONY-688
     */
    public void testUnicodeCategoryWithSurrogatesSupplementary() {
        Pattern p = Pattern.compile("\\p{javaLowerCase}");
        Matcher matcher = p.matcher("\uD801\uDC28");
        assertTrue(matcher.find());
    }

    public void testSplitEmpty() {

        Pattern pat = Pattern.compile("");
        String[] s = pat.split("", -1);

        assertEquals(1, s.length);
        assertEquals("", s[0]);
    }

    public void testToString() {
        for (int i = 0; i < testPatterns.length; i++) {
            Pattern p = Pattern.compile(testPatterns[i]);
            assertEquals(testPatterns[i], p.toString());
        }
    }

    // http://code.google.com/p/android/issues/detail?id=19308
    public void test_hitEnd() {
        Pattern p = Pattern.compile("^2(2[4-9]|3\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$");
        Matcher m = p.matcher("224..");
        boolean isPartialMatch = !m.matches() && m.hitEnd();
        assertFalse(isPartialMatch);
    }

    public void testCommentsInPattern() {
        Pattern p = Pattern.compile("ab# this is a comment\ncd", Pattern.COMMENTS);
        assertTrue(p.matcher("abcd").matches());
    }

    public void testCompileNonCaptGroup() {
        // icu4c doesn't support CANON_EQ.
        Pattern.compile("(?:)"/*, Pattern.CANON_EQ*/);
        Pattern.compile("(?:)", /*Pattern.CANON_EQ |*/ Pattern.DOTALL);
        Pattern.compile("(?:)", /*Pattern.CANON_EQ |*/ Pattern.CASE_INSENSITIVE);
        Pattern.compile("(?:)", /*Pattern.CANON_EQ |*/ Pattern.COMMENTS | Pattern.UNIX_LINES);
    }

    public void testFlagsMethod() {
        // icu4c doesn't count inline flags that span the entire regex as being global flags.
        // Android just returns those flags actually passed to Pattern.compile.
        if (true) {
            return;
        }

        String baseString;
        Pattern pat;

        // These tests are for compatibility with RI only. Logically we have to
        // return only flags specified during the compilation. For example
        // pat.flags() == 0 when we compile Pattern pat =
        // Pattern.compile("(?i)abc(?-i)"); but the whole expression is compiled
        // in a case insensitive manner. So there is little sense to do calls to
        // flags() now.
        baseString = "(?-i)";
        pat = Pattern.compile(baseString);

        baseString = "(?idmsux)abc(?-i)vg(?-dmu)";
        pat = Pattern.compile(baseString);
        assertEquals(pat.flags(), Pattern.DOTALL | Pattern.COMMENTS);

        baseString = "(?idmsux)abc|(?-i)vg|(?-dmu)";
        pat = Pattern.compile(baseString);
        assertEquals(pat.flags(), Pattern.DOTALL | Pattern.COMMENTS);

        baseString = "(?is)a((?x)b.)";
        pat = Pattern.compile(baseString);
        assertEquals(pat.flags(), Pattern.DOTALL | Pattern.CASE_INSENSITIVE);

        baseString = "(?i)a((?-i))";
        pat = Pattern.compile(baseString);
        assertEquals(pat.flags(), Pattern.CASE_INSENSITIVE);

        baseString = "((?i)a)";
        pat = Pattern.compile(baseString);
        assertEquals(pat.flags(), 0);

        pat = Pattern.compile("(?is)abc");
        assertEquals(pat.flags(), Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
    }

    public void testCanonEqFlag() {
        // icu4c doesn't support CANON_EQ.
        if (true) {
            return;
        }

        // for decompositions see
        // http://www.unicode.org/Public/4.0-Update/UnicodeData-4.0.0.txt
        // http://www.unicode.org/reports/tr15/#Decomposition
        String baseString;
        String testString;
        Pattern pat;
        Matcher mat;

        baseString = "ab(a*)\\1";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);

        baseString = "a(abcdf)d";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);

        baseString = "aabcdfd";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);

        // \u01E0 -> \u0226\u0304 ->\u0041\u0307\u0304
        // \u00CC -> \u0049\u0300

        baseString = "\u01E0\u00CCcdb(ac)";
        testString = "\u0226\u0304\u0049\u0300cdbac";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\u01E0cdb(a\u00CCc)";
        testString = "\u0041\u0307\u0304cdba\u0049\u0300c";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "a\u00CC";
        testString = "a\u0049\u0300";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\u0226\u0304cdb(ac\u0049\u0300)";
        testString = "\u01E0cdbac\u00CC";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "cdb(?:\u0041\u0307\u0304\u00CC)";
        testString = "cdb\u0226\u0304\u0049\u0300";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\u01E0[a-c]\u0049\u0300cdb(ac)";
        testString = "\u01E0b\u00CCcdbac";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\u01E0|\u00CCcdb(ac)";
        testString = "\u0041\u0307\u0304";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\u00CC?cdb(ac)*(\u01E0)*[a-c]";
        testString = "cdb\u0041\u0307\u0304b";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "a\u0300";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher("a\u00E0a");
        assertTrue(mat.find());

        baseString = "\u7B20\uF9F8abc";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher("\uF9F8\uF9F8abc");
        assertTrue(mat.matches());

        // \u01F9 -> \u006E\u0300
        // \u00C3 -> \u0041\u0303

        baseString = "cdb(?:\u00C3\u006E\u0300)";
        testString = "cdb\u0041\u0303\u01F9";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        // \u014C -> \u004F\u0304
        // \u0163 -> \u0074\u0327

        baseString = "cdb(?:\u0163\u004F\u0304)";
        testString = "cdb\u0074\u0327\u014C";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        // \u00E1->a\u0301
        // canonical ordering takes place \u0301\u0327 -> \u0327\u0301

        baseString = "c\u0327\u0301";
        testString = "c\u0301\u0327";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        /*
        Hangul decompositions
        */
        // \uD4DB->\u1111\u1171\u11B6
        // \uD21E->\u1110\u116D\u11B5
        // \uD264->\u1110\u1170
        // not Hangul:\u0453->\u0433\u0301
        baseString = "a\uD4DB\u1111\u1171\u11B6\uD264";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);

        baseString = "\u0453c\uD4DB";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);

        baseString = "a\u1110\u116D\u11B5b\uD21Ebc";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);

        baseString = "\uD4DB\uD21E\u1110\u1170cdb(ac)";
        testString = "\u1111\u1171\u11B6\u1110\u116D\u11B5\uD264cdbac";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\uD4DB\uD264cdb(a\uD21Ec)";
        testString = "\u1111\u1171\u11B6\u1110\u1170cdba\u1110\u116D\u11B5c";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "a\uD4DB";
        testString = "a\u1111\u1171\u11B6";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "a\uD21E";
        testString = "a\u1110\u116D\u11B5";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\u1111\u1171\u11B6cdb(ac\u1110\u116D\u11B5)";
        testString = "\uD4DBcdbac\uD21E";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "cdb(?:\u1111\u1171\u11B6\uD21E)";
        testString = "cdb\uD4DB\u1110\u116D\u11B5";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\uD4DB[a-c]\u1110\u116D\u11B5cdb(ac)";
        testString = "\uD4DBb\uD21Ecdbac";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\uD4DB|\u00CCcdb(ac)";
        testString = "\u1111\u1171\u11B6";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\uD4DB|\u00CCcdb(ac)";
        testString = "\u1111\u1171";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertFalse(mat.matches());

        baseString = "\u00CC?cdb(ac)*(\uD4DB)*[a-c]";
        testString = "cdb\u1111\u1171\u11B6b";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        baseString = "\uD4DB";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher("a\u1111\u1171\u11B6a");
        assertTrue(mat.find());

        baseString = "\u1111";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher("bcda\uD4DBr");
        assertFalse(mat.find());
    }

    public void testIndexesCanonicalEq() {
        // icu4c doesn't support CANON_EQ.
        if (true) {
            return;
        }

        String baseString;
        String testString;
        Pattern pat;
        Matcher mat;

        baseString = "\uD4DB";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher("bcda\u1111\u1171\u11B6awr");
        assertTrue(mat.find());
        assertEquals(mat.start(), 4);
        assertEquals(mat.end(), 7);

        baseString = "\uD4DB\u1111\u1171\u11B6";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher("bcda\u1111\u1171\u11B6\uD4DBawr");
        assertTrue(mat.find());
        assertEquals(mat.start(), 4);
        assertEquals(mat.end(), 8);

        baseString = "\uD4DB\uD21E\u1110\u1170";
        testString = "abcabc\u1111\u1171\u11B6\u1110\u116D\u11B5\uD264cdbac";
        pat = Pattern.compile(baseString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.find());
        assertEquals(mat.start(), 6);
        assertEquals(mat.end(), 13);
    }

    public void testCanonEqFlagWithSupplementaryCharacters() {
        // icu4c doesn't support CANON_EQ.
        if (true) {
            return;
        }

        /*
        \u1D1BF->\u1D1BB\u1D16F->\u1D1B9\u1D165\u1D16F in UTF32
        \uD834\uDDBF->\uD834\uDDBB\uD834\uDD6F
        ->\uD834\uDDB9\uD834\uDD65\uD834\uDD6F in UTF16
        */
        String patString = "abc\uD834\uDDBFef";
        String testString = "abc\uD834\uDDB9\uD834\uDD65\uD834\uDD6Fef";
        Pattern pat = Pattern.compile(patString, Pattern.CANON_EQ);
        Matcher mat = pat.matcher(testString);
        assertTrue(mat.matches());

        testString = "abc\uD834\uDDBB\uD834\uDD6Fef";
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        patString = "abc\uD834\uDDBB\uD834\uDD6Fef";
        testString = "abc\uD834\uDDBFef";
        pat = Pattern.compile(patString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        testString = "abc\uD834\uDDB9\uD834\uDD65\uD834\uDD6Fef";
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        patString = "abc\uD834\uDDB9\uD834\uDD65\uD834\uDD6Fef";
        testString = "abc\uD834\uDDBFef";
        pat = Pattern.compile(patString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        testString = "abc\uD834\uDDBB\uD834\uDD6Fef";
        mat = pat.matcher(testString);
        assertTrue(mat.matches());

        // Test supplementary characters with no decomposition
        patString = "a\uD9A0\uDE8Ebc\uD834\uDDBB\uD834\uDD6Fe\uDE8Ef";
        testString = "a\uD9A0\uDE8Ebc\uD834\uDDBFe\uDE8Ef";
        pat = Pattern.compile(patString, Pattern.CANON_EQ);
        mat = pat.matcher(testString);
        assertTrue(mat.matches());
    }

    public void testAsPredicate() {
        String[][] posSeq = {
                { "abb", "ababb", "abababbababb", "abababbababbabababbbbbabb" },
                { "213567", "12324567", "1234567", "213213567",
                        "21312312312567", "444444567" },
                { "abcdaab", "aab", "abaab", "cdaab", "acbdadcbaab" },
                { "213234567", "3458", "0987654", "7689546432", "0398576",
                        "98432", "5" },
                {
                        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
                        "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                                + "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" },
                { "ababbaAabababblice", "ababbaAliceababab", "ababbAabliceaaa",
                        "abbbAbbbliceaaa", "Alice" },
                { "a123", "bnxnvgds156", "for", "while", "if", "struct" },
                { "xy" }, { "xy" }, { "xcy" }
        };

        for (int i = 0; i < testPatterns.length; i++) {
            Pattern p = Pattern.compile(testPatterns[i]);
            for (int j = 0; j < posSeq[i].length; j++) {
                assertTrue(p.asPredicate().test(posSeq[i][j]));
            }
        }
    }

    public void testSplitAsStream() {
        Pattern pat;
        String[] s;

        pat = Pattern.compile("b");
        s = pat.splitAsStream("abccbadfebb").toArray(String[]::new);
        assertEquals(s.length, 3);

        pat = Pattern.compile("b");
        s = pat.splitAsStream("").toArray(String[]::new);
        assertEquals(s.length, 0);

        pat = Pattern.compile("");
        s = pat.splitAsStream("").toArray(String[]::new);
        assertEquals(s.length, 0);

        pat = Pattern.compile("");
        s = pat.splitAsStream("abccbadfe").toArray(String[]::new);
        assertEquals(s.length, 9);
    }
}
