def test_not_literal(self):
     r = get_code(r"[^a]")
     assert rsre_core.match(r, "A")
     assert not rsre_core.match(r, "a")
     r = get_code(r"[^a]+$")
     assert rsre_core.match(r, "Bx123")
     assert not rsre_core.match(r, "--a--")

 def test_lookbehind(self):
     r = get_code(r"([a-z]*)(?<=de)")
     assert rsre_core.match(r, "ade")
     res = rsre_core.match(r, "adefg")
     assert res is not None and res.get_mark(1) == 3
     assert not rsre_core.match(r, "abc")
     assert not rsre_core.match(r, "X")
     assert not rsre_core.match(r, "eX")

 def test_not_literal_ignore(self):
     r = get_code(r"(?i)[^a]")
     assert rsre_core.match(r, "G")
     assert not rsre_core.match(r, "a")
     assert not rsre_core.match(r, "A")
     r = get_code(r"(?i)[^a]+$")
     assert rsre_core.match(r, "Gx123")
     assert not rsre_core.match(r, "--A--")

 def test_group_branch(self):
     r_code5 = get_code(r'<abc>(ab|c)</abc>')
     res = rsre_core.match(r_code5, '<abc>ab</abc>def')
     assert (res.get_mark(0), res.get_mark(1)) == (5, 7)
     res = rsre_core.match(r_code5, '<abc>c</abc>def')
     assert (res.get_mark(0), res.get_mark(1)) == (5, 6)
     res = rsre_core.match(r_code5, '<abc>de</abc>def')
     assert res is None

 def test_group_branch_max_until(self):
     r_code6 = get_code(r'<abc>(ab|c)*a</abc>')
     res = rsre_core.match(r_code6, '<abc>ccabcccaba</abc>def')
     assert (res.get_mark(0), res.get_mark(1)) == (12, 14)
     r_code7 = get_code(r'<abc>((ab)|(c))*a</abc>')
     res = rsre_core.match(r_code7, '<abc>ccabcccaba</abc>def')
     assert (res.get_mark(0), res.get_mark(1)) == (12, 14)
     assert (res.get_mark(2), res.get_mark(3)) == (12, 14)
     assert (res.get_mark(4), res.get_mark(5)) == (11, 12)

 def test_min_until_0_65535(self):
     r_code2 = get_code(r'<abc>(?:xy)*?xy</abc>')
     res = rsre_core.match(r_code2, '<abc></abc>def')
     assert res is None
     res = rsre_core.match(r_code2, '<abc>xy</abc>def')
     assert res is not None
     res = rsre_core.match(r_code2, '<abc>xyxyxy</abc>def')
     assert res is not None
     res = rsre_core.match(r_code2, '<abc>' + 'xy'*1000 + '</abc>def')
     assert res is not None

 def test_groupref_exists(self):
     r = get_code(r"((a)|(b))c(?(2)d)$")
     assert not rsre_core.match(r, "ac")
     assert     rsre_core.match(r, "acd")
     assert     rsre_core.match(r, "bc")
     assert not rsre_core.match(r, "bcd")
     #
     r = get_code(r"((a)|(b))c(?(2)d|e)$")
     assert not rsre_core.match(r, "ac")
     assert     rsre_core.match(r, "acd")
     assert not rsre_core.match(r, "ace")
     assert not rsre_core.match(r, "bc")
     assert not rsre_core.match(r, "bcd")
     assert     rsre_core.match(r, "bce")

 def test_empty_maxuntil(self):
     r_code, r = get_code_and_re(r'(a?)+y')
     assert r.match('y')
     res = rsre_core.match(r_code, 'y')
     assert res
     #
     r_code, r = get_code_and_re(r'(a?){4,6}y')
     assert r.match('y')
     res = rsre_core.match(r_code, 'y')
     assert res
     #
     r_code, r = get_code_and_re(r'(a?)*y')
     assert r.match('y')
     res = rsre_core.match(r_code, 'y')
     assert res

 def test_empty_minuntil(self):
     r_code, r = get_code_and_re(r'(a?)+?y')
     #assert not r.match('z') -- CPython bug (at least 2.5) eats all memory
     res = rsre_core.match(r_code, 'z')
     assert not res
     #
     r_code, r = get_code_and_re(r'(a?){4,6}?y')
     assert not r.match('z')
     res = rsre_core.match(r_code, 'z')
     assert not res
     #
     r_code, r = get_code_and_re(r'(a?)*?y')
     #assert not r.match('z') -- CPython bug (at least 2.5) eats all memory
     res = rsre_core.match(r_code, 'z')
     assert not res

 def test_min_until_3_5(self):
     r_code2, r = get_code_and_re(r'<abc>(?:xy){3,5}?xy</abc>')
     for i in range(8):
         s = '<abc>' + 'xy'*i + '</abc>defdefdefdefdef'
         assert (r.match(s) is not None) is (3 <= i-1 <= 5)
         res = rsre_core.match(r_code2, s)
         assert (res is not None) is (3 <= i-1 <= 5)

def run_external(t, use_search):
    from pypy.rlib.rsre.test.re_tests import SUCCEED, FAIL, SYNTAX_ERROR
    pattern, s, outcome = t[:3]
    if len(t) == 5:
        repl, expected = t[3:5]
    else:
        assert len(t) == 3
    print 'trying:', t
    try:
        obj = get_code(pattern)
    except re.error:
        if outcome == SYNTAX_ERROR:
            return  # Expected a syntax error
        raise
    if outcome == SYNTAX_ERROR:
        raise Exception("this should have been a syntax error")
    #
    if use_search:
        result = rsre_core.search(obj, s)
    else:
        # Emulate a poor man's search() with repeated match()s
        for i in range(len(s)+1):
            result = rsre_core.match(obj, s, start=i)
            if result:
                break
    #
    if outcome == FAIL:
        if result is not None:
            raise Exception("succeeded incorrectly")
    elif outcome == SUCCEED:
        if result is None:
            raise Exception("failed incorrectly")
        # Matched, as expected, so now we compute the
        # result string and compare it to our expected result.
        start, end = result.span(0)
        vardict={'found': result.group(0),
                 'groups': result.group(),
                 }#'flags': result.re.flags}
        for i in range(1, 100):
            try:
                gi = result.group(i)
                # Special hack because else the string concat fails:
                if gi is None:
                    gi = "None"
            except IndexError:
                gi = "Error"
            vardict['g%d' % i] = gi
        #for i in result.re.groupindex.keys():
        #    try:
        #        gi = result.group(i)
        #        if gi is None:
        #            gi = "None"
        #    except IndexError:
        #        gi = "Error"
        #    vardict[i] = gi
        repl = eval(repl, vardict)
        if repl != expected:
            raise Exception("grouping error: %r should be %r" % (repl,
                                                                 expected))

 def test_minuntil_lastmark_restore(self):
     r_code9, r9 = get_code_and_re(r'(x|yz)+?(y)??c')
     match = r9.match('xyzxc')
     assert match.span(1) == (3, 4)
     assert match.span(2) == (-1, -1)
     res = rsre_core.match(r_code9, 'xyzxc')
     assert (res.get_mark(0), res.get_mark(1)) == (3, 4)
     assert (res.get_mark(2), res.get_mark(3)) == (-1, -1)

 def test_minuntil_bug(self):
     r_code9, r9 = get_code_and_re(r'((x|yz)+?(y)??c)*')
     match = r9.match('xycxyzxc')
     assert match.span(2) == (6, 7)
     #assert match.span(3) == (1, 2) --- bug of CPython
     res = rsre_core.match(r_code9, 'xycxyzxc')
     assert (res.get_mark(2), res.get_mark(3)) == (6, 7)
     assert (res.get_mark(4), res.get_mark(5)) == (1, 2)

 def test_assert_not_group(self):
     r = get_code(r"abc(?!(de)f)(.)")
     res = rsre_core.match(r, "abcdeFghi")
     assert res is not None
     assert res.span(2) == (3, 4)
     # this I definitely classify as Horrendously Implementation Dependent.
     # CPython answers (3, 5).
     assert res.span(1) == (-1, -1)

 def test_groupref_ignore(self):
     r = get_code(r"(?i)(xx+)\1+$")     # match non-prime numbers of x
     assert not rsre_core.match(r, "xX")
     assert not rsre_core.match(r, "xxX")
     assert     rsre_core.match(r, "Xxxx")
     assert not rsre_core.match(r, "xxxXx")
     assert     rsre_core.match(r, "xXxxxx")
     assert not rsre_core.match(r, "xxxXxxx")
     assert     rsre_core.match(r, "xxxxxxXx")
     assert     rsre_core.match(r, "xxxXxxxxx")

 def test_groupref(self):
     r = get_code(r"(xx+)\1+$")     # match non-prime numbers of x
     assert not rsre_core.match(r, "xx")
     assert not rsre_core.match(r, "xxx")
     assert     rsre_core.match(r, "xxxx")
     assert not rsre_core.match(r, "xxxxx")
     assert     rsre_core.match(r, "xxxxxx")
     assert not rsre_core.match(r, "xxxxxxx")
     assert     rsre_core.match(r, "xxxxxxxx")
     assert     rsre_core.match(r, "xxxxxxxxx")

def entrypoint1(r, string, repeat):
    r = array2list(r)
    string = hlstr(string)
    match = None
    for i in range(repeat):
        match = rsre_core.match(r, string)
    if match is None:
        return -1
    else:
        return match.match_end

 def test_group_branch_repeat_complex_case(self):
     r_code8, r8 = get_code_and_re(r'<abc>((a)|(b))*</abc>')
     match = r8.match('<abc>ab</abc>')
     assert match.span(1) == (6, 7)
     assert match.span(3) == (6, 7)
     assert match.span(2) == (5, 6)
     res = rsre_core.match(r_code8, '<abc>ab</abc>')
     assert (res.get_mark(0), res.get_mark(1)) == (6, 7)
     assert (res.get_mark(4), res.get_mark(5)) == (6, 7)
     assert (res.get_mark(2), res.get_mark(3)) == (5, 6)

 def test_group_7(self):
     r_code7, r7 = get_code_and_re(r'<abc>((a)?(b))*</abc>')
     match = r7.match('<abc>bbbabbbb</abc>')
     assert match.span(1) == (12, 13)
     assert match.span(3) == (12, 13)
     assert match.span(2) == (8, 9)
     res = rsre_core.match(r_code7, '<abc>bbbabbbb</abc>')
     assert (res.get_mark(0), res.get_mark(1)) == (12, 13)
     assert (res.get_mark(4), res.get_mark(5)) == (12, 13)
     assert (res.get_mark(2), res.get_mark(3)) == (8, 9)

 def test_match_end(self):
     r = get_code("ab")
     assert     rsre_core.match(r, "abc")
     assert     rsre_core.match(r, "abc", end=333)
     assert     rsre_core.match(r, "abc", end=3)
     assert     rsre_core.match(r, "abc", end=2)
     assert not rsre_core.match(r, "abc", end=1)
     assert not rsre_core.match(r, "abc", end=0)
     assert not rsre_core.match(r, "abc", end=-1)