import py

from rpython.jit.metainterp.test.support import LLJitMixin
from rpython.rlib.debug import debug_print
from rpython.rlib.jit import (JitDriver, dont_look_inside, we_are_jitted,
    promote_string, promote_unicode)
from rpython.rlib.rstring import StringBuilder, UnicodeBuilder


class StringTests:
    _str, _chr, _StringBuilder = str, chr, StringBuilder

    def test_eq_residual(self):
        _str = self._str
        jitdriver = JitDriver(greens = [], reds = ['n', 'i', 's'])
        global_s = _str("hello")
        def f(n, b, s):
            if b:
                s += _str("ello")
            else:
                s += _str("allo")
            i = 0
            while n > 0:
                jitdriver.can_enter_jit(s=s, n=n, i=i)
                jitdriver.jit_merge_point(s=s, n=n, i=i)
                n -= 1 + (s == global_s)
                i += 1
            return i
        res = self.meta_interp(f, [10, True, _str('h')], listops=True)
        assert res == 5
        self.check_resops(**{self.CALL: 1, self.CALL_PURE: 0})

    def test_eq_folded(self):
        _str = self._str
        jitdriver = JitDriver(greens = ['s'], reds = ['n', 'i'])
        global_s = _str("hello")
        def f(n, b, s):
            if b:
                s += _str("ello")
            else:
                s += _str("allo")
            i = 0
            while n > 0:
                jitdriver.can_enter_jit(s=s, n=n, i=i)
                jitdriver.jit_merge_point(s=s, n=n, i=i)
                n -= 1 + (s == global_s)
                i += 1
            return i
        res = self.meta_interp(f, [10, True, _str('h')], listops=True)
        assert res == 5
        self.check_resops(**{self.CALL: 0, self.CALL_PURE: 0})

    def test_newstr(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['n', 'm'])
        def f(n, m):
            while True:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                bytecode = _str('adlfkj') + _chr(n)
                res = bytecode[n]
                m -= 1
                if m < 0:
                    return ord(res)
        res = self.meta_interp(f, [6, 10])
        assert res == 6

    def test_char2string_pure(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['n'])
        @dont_look_inside
        def escape(x):
            pass
        def f(n):
            while n > 0:
                jitdriver.can_enter_jit(n=n)
                jitdriver.jit_merge_point(n=n)
                s = _chr(n)
                if not we_are_jitted():
                    s += s     # forces to be a string
                if n > 100:
                    escape(s)
                n -= 1
            return 42
        self.meta_interp(f, [6])
        self.check_resops(newstr=0, strsetitem=0, strlen=0,
                         newunicode=0, unicodesetitem=0, unicodelen=0)

    def test_char2string_escape(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['n', 'total'])
        @dont_look_inside
        def escape(x):
            return ord(x[0])
        def f(n):
            total = 0
            while n > 0:
                jitdriver.can_enter_jit(n=n, total=total)
                jitdriver.jit_merge_point(n=n, total=total)
                s = _chr(n)
                if not we_are_jitted():
                    s += s    # forces to be a string
                total += escape(s)
                n -= 1
            return total
        res = self.meta_interp(f, [6])
        assert res == 21

    def test_char2string2char(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['m', 'total'])
        def f(m):
            total = 0
            while m > 0:
                jitdriver.can_enter_jit(m=m, total=total)
                jitdriver.jit_merge_point(m=m, total=total)
                string = _chr(m)
                if m > 100:
                    string += string    # forces to be a string
                # read back the character
                c = string[0]
                total += ord(c)
                m -= 1
            return total
        res = self.meta_interp(f, [6])
        assert res == 21
        self.check_resops(newstr=0, strgetitem=0, strsetitem=0, strlen=0,
                         newunicode=0, unicodegetitem=0, unicodesetitem=0,
                         unicodelen=0)

    def test_strconcat_pure(self):
        _str = self._str
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        mylist = [_str("abc") + _str(i) for i in range(10)]
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = mylist[n] + mylist[m]
                if m > 100:
                    escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        self.check_resops(newstr=0, strsetitem=0,
                         newunicode=0, unicodesetitem=0,
                         call_i=0, call_pure_i=0, call_r=0, call_pure_r=0)

    def test_strconcat_escape_str_str(self):
        _str = self._str
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        mylist = [_str("somestr") + _str(i) for i in range(10)]
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = mylist[n] + mylist[m]
                escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        if _str is str:
            self.check_resops(call_pure_i=0, call_pure_r=0, copystrcontent=4,
                              strsetitem=0, call_n=2, newstr=2)
        else:
            self.check_resops(call_pure_i=0, call_pure_r=0,
                              unicodesetitem=0, call_n=2,
                              copyunicodecontent=4, newunicode=2)

    def test_strconcat_escape_str_char(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        mylist = [_str("somestr") + _str(i) for i in range(10)]
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = mylist[n] + _chr(m)
                escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        if _str is str:
            self.check_resops(call_pure_i=0, call_pure_r=0,
                              copystrcontent=2, strsetitem=2,
                              call_n=2, newstr=2)
        else:
            self.check_resops(call_pure_i=0, call_pure_r=0,
                              unicodesetitem=2, call_n=2,
                              copyunicodecontent=2, newunicode=2)

    def test_strconcat_escape_char_str(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        mylist = [_str("somestr") + _str(i) for i in range(10)]
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = _chr(n) + mylist[m]
                escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        if _str is str:
            self.check_resops(call_pure_i=0, call_pure_r=0, copystrcontent=2,
                              strsetitem=2, call_n=2, newstr=2)
        else:
            self.check_resops(call_pure_i=0, unicodesetitem=2,
                              call_n=2,
                              copyunicodecontent=2, newunicode=2)

    def test_strconcat_escape_char_char(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = _chr(n) + _chr(m)
                escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        if _str is str:
            self.check_resops(call_pure=0, copystrcontent=0,
                              strsetitem=4, call_n=2, newstr=2)
        else:
            self.check_resops(call_pure=0, unicodesetitem=4, call_n=2,
                              copyunicodecontent=0, newunicode=2)

    def test_strconcat_escape_str_char_str(self):
        _str, _chr = self._str, self._chr
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        mylist = [_str("somestr") + _str(i) for i in range(10)]
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = mylist[n] + _chr(n) + mylist[m]
                escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        if _str is str:
            self.check_resops(call_pure=0, copystrcontent=4, strsetitem=2,
                              call_n=2, newstr=2)
        else:
            self.check_resops(call_pure=0, unicodesetitem=2, call_n=2,
                              copyunicodecontent=4, newunicode=2)

    def test_strconcat_guard_fail(self):
        _str = self._str
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        mylist = [_str("abc") + _str(i) for i in range(12)]
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = mylist[n] + mylist[m]
                if m & 1:
                    escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 10])

    def test_strslice(self):
        _str = self._str
        longstring = _str("foobarbazetc")
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        def f(n, m):
            assert n >= 0
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = longstring[m:n]
                if m <= 5:
                    escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [10, 10])

    def test_streq_char(self):
        _str = self._str
        longstring = _str("?abcdefg")
        somechar = _str("?")
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        @dont_look_inside
        def escape(x):
            pass
        def f(n, m):
            assert n >= 0
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                s = longstring[:m]
                escape(s == somechar)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        self.check_resops(newunicode=0, newstr=0)

    def test_str_slice_len_surviving(self):
        _str = self._str
        longstring = _str("Unrolling Trouble")
        mydriver = JitDriver(reds = ['i', 'a', 'sa'], greens = [])
        def f(a):
            i = sa = a
            while i < len(longstring):
                mydriver.jit_merge_point(i=i, a=a, sa=sa)
                assert a >= 0 and i >= 0
                i = len(longstring[a:i+1])
                sa += i
            return sa
        assert self.meta_interp(f, [0]) == f(0)

    def test_virtual_strings_direct(self):
        _str = self._str
        fillers = _str("abcdefghijklmnopqrstuvwxyz")
        data = _str("ABCDEFGHIJKLMNOPQRSTUVWXYZ")

        mydriver = JitDriver(reds = ['line', 'noise', 'res'], greens = [])
        def f():
            line = data
            noise = fillers
            ratio = len(line) // len(noise)
            res = data[0:0]
            while line and noise:
                mydriver.jit_merge_point(line=line, noise=noise, res=res)
                if len(line) // len(noise) > ratio:
                    c, line = line[0], line[1:]
                else:
                    c, noise = noise[0], noise[1:]
                res += c
            return res + noise + line
        s1 = self.meta_interp(f, [])
        s2 = f()
        for c1, c2 in zip(s1.chars, s2):
            assert c1 == c2

    def test_virtual_strings_boxed(self):
        _str = self._str
        fillers = _str("abcdefghijklmnopqrstuvwxyz")
        data = _str("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
        class Str(object):
            def __init__(self, value):
                self.value = value
        mydriver = JitDriver(reds = ['ratio', 'line', 'noise', 'res'],
                             greens = [])
        def f():
            line = Str(data)
            noise = Str(fillers)
            ratio = len(line.value) // len(noise.value)
            res = Str(data[0:0])
            while line.value and noise.value:
                mydriver.jit_merge_point(line=line, noise=noise, res=res,
                                         ratio=ratio)
                if len(line.value) // len(noise.value) > ratio:
                    c, line = line.value[0], Str(line.value[1:])
                else:
                    c, noise = noise.value[0], Str(noise.value[1:])
                res = Str(res.value + c)
            return res.value + noise.value + line.value
        s1 = self.meta_interp(f, [])
        s2 = f()
        for c1, c2 in zip(s1.chars, s2):
            assert c1==c2

    def test_string_in_virtual_state(self):
        _str = self._str
        s1 = _str("a")
        s2 = _str("AA")
        mydriver = JitDriver(reds = ['i', 'n', 'sa'], greens = [])
        def f(n):
            sa = s1
            i = 0
            while i < n:
                mydriver.jit_merge_point(i=i, n=n, sa=sa)
                if i&4 == 0:
                    sa += s1
                else:
                    sa += s2
                i += 1
            return len(sa)
        assert self.meta_interp(f, [16]) == f(16)

    def test_loop_invariant_string_slice(self):
        _str = self._str
        mydriver = JitDriver(reds = ['i', 'n', 'sa', 's', 's1'], greens = [])
        def f(n, c):
            s = s1 = _str(c*10)
            sa = i = 0
            while i < n:
                mydriver.jit_merge_point(i=i, n=n, sa=sa, s=s, s1=s1)
                sa += len(s)
                if i < n/2:
                    s = s1[1:3]
                else:
                    s = s1[2:3]
                i += 1
            return sa
        assert self.meta_interp(f, [16, 'a']) == f(16, 'a')

    def test_loop_invariant_string_slice_boxed(self):
        class Str(object):
            def __init__(self, value):
                self.value = value
        _str = self._str
        mydriver = JitDriver(reds = ['i', 'n', 'sa', 's', 's1'], greens = [])
        def f(n, c):
            s = s1 = Str(_str(c*10))
            sa = i = 0
            while i < n:
                mydriver.jit_merge_point(i=i, n=n, sa=sa, s=s, s1=s1)
                sa += len(s.value)
                if i < n/2:
                    s = Str(s1.value[1:3])
                else:
                    s = Str(s1.value[2:3])
                i += 1
            return sa
        assert self.meta_interp(f, [16, 'a']) == f(16, 'a')

    def test_loop_invariant_string_slice_in_array(self):
        _str = self._str
        mydriver = JitDriver(reds = ['i', 'n', 'sa', 's', 's1'], greens = [])
        def f(n, c):
            s = s1 = [_str(c*10)]
            sa = i = 0
            while i < n:
                mydriver.jit_merge_point(i=i, n=n, sa=sa, s=s, s1=s1)
                sa += len(s[0])
                if i < n/2:
                    s = [s1[0][1:3]]
                else:
                    s = [s1[0][2:3]]
                i += 1
            return sa
        assert self.meta_interp(f, [16, 'a']) == f(16, 'a')

    def test_boxed_virtual_string_not_surviving(self):
        class StrBox(object):
            def __init__(self, val):
                self.val = val
        class IntBox(object):
            def __init__(self, val):
                self.val = val
        _str = self._str
        mydriver = JitDriver(reds = ['i', 'nt', 'sa'], greens = [])
        def f(c):
            nt = StrBox(_str(c*16))
            sa = StrBox(_str(''))
            i = IntBox(0)
            while i.val < len(nt.val):
                mydriver.jit_merge_point(i=i, nt=nt, sa=sa)
                sa = StrBox(sa.val + StrBox(nt.val[i.val]).val)
                i = IntBox(i.val + 1)
            return len(sa.val)
        assert self.meta_interp(f, ['a']) == f('a')

    def test_string_compare_quasiimmutable(self):
        class Sys(object):
            _immutable_fields_ = ["defaultencoding?"]
            def __init__(self, s):
                self.defaultencoding = s
        _str = self._str
        sys = Sys(_str('ascii'))
        mydriver = JitDriver(reds = ['n', 'sa'], greens = [])
        def f(n):
            sa = 0
            sys.defaultencoding = _str('ascii')
            while n:
                mydriver.jit_merge_point(n=n, sa=sa)
                if sys.defaultencoding == _str('ascii'):
                    sa += 1
                n -= 1
            sys.defaultencoding = _str('utf-8')
            return sa
        assert self.meta_interp(f, [8]) == f(8)
        self.check_resops({'jump': 1, 'int_is_true': 2, 'int_add': 2,
                           'guard_true': 2, 'guard_not_invalidated': 2,
                           'int_sub': 2})

    def test_promote_string(self):
        driver = JitDriver(greens = [], reds = ['n'])

        def f(n):
            while n < 21:
                driver.jit_merge_point(n=n)
                promote_string(str(n & 3))
                n += 1
            return 0

        self.meta_interp(f, [0])
        self.check_resops(call_r=2, call_i=5)

    def test_promote_unicode(self):
        driver = JitDriver(greens = [], reds = ['n'])

        def f(n):
            while n < 21:
                driver.jit_merge_point(n=n)
                promote_unicode(unicode(str(n % 3)))
                n += 1
            return 0

        self.meta_interp(f, [0])
        self.check_resops(call_r=4, call_i=5)

    def test_join_chars(self):
        jitdriver = JitDriver(reds=['a', 'b', 'c', 'i'], greens=[])
        _str = self._str

        def f(a, b, c):
            i = 0
            while i < 10:
                jitdriver.jit_merge_point(a=a, b=b, c=c, i=i)
                x = []
                if a:
                    x.append(_str("a"))
                if b:
                    x.append(_str("b"))
                if c:
                    x.append(_str("c"))
                i += len(_str("").join(x))
            return i
        res = self.meta_interp(f, [1, 1, 1])
        assert res == f(True, True, True)
        # The "".join should be unrolled, since the length of x is known since
        # it is virtual, ensure there are no calls to ll_join_chars, or
        # allocations.
        self.check_resops({'jump': 1, 'guard_true': 5, 'int_lt': 2,
                           'int_add': 2, 'int_is_true': 3})

    def test_virtual_copystringcontent(self):
        jitdriver = JitDriver(reds=['n', 'result'], greens=[])
        _str, _StringBuilder = self._str, self._StringBuilder

        def main(n):
            result = 0
            while n >= 0:
                jitdriver.jit_merge_point(n=n, result=result)
                b = _StringBuilder(6)
                b.append(_str("Hello!"))
                result += ord(b.build()[0])
                n -= 1
            return result
        res = self.meta_interp(main, [9], backendopt=True)
        assert res == main(9)

    def test_virtual_copystringcontent2(self):
        jitdriver = JitDriver(reds=['n', 'result'], greens=[])
        _str, _StringBuilder = self._str, self._StringBuilder

        def main(n):
            result = 0
            while n >= 0:
                jitdriver.jit_merge_point(n=n, result=result)
                b = _StringBuilder(6)
                b.append(_str("Hello!"))
                result += ord((b.build() + _str("xyz"))[0])
                n -= 1
            return result
        res = self.meta_interp(main, [9], backendopt=True)
        assert res == main(9)

    def test_bytearray(self):
        py.test.skip("implement it")

        def f(i):
            b = bytearray("abc")
            b[1] = i
            return b[1]

        res = self.interp_operations(f, [13])
        assert res == 13

    def test_stringbuilder_create(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                if sb.build() != u"":
                    raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops({'int_sub': 2, 'int_gt': 2, 'guard_true': 2,
                           'jump': 1})

    def test_stringbuilder_append_char(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append(u"a")
                sb.append(unichr(n))
                s = sb.build()
                if len(s) != 2: raise ValueError
                if s[0] != u"a": raise ValueError
                if s[1] != unichr(n): raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops({'int_sub': 2, 'int_gt': 2, 'guard_true': 2,
                           'jump': 1})

    def test_stringbuilder_append_1(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append(u"ab")
                s = sb.build()
                if len(s) != 2: raise ValueError
                if s[0] != u"a": raise ValueError
                if s[1] != u"b": raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops({'int_sub': 2, 'int_gt': 2, 'guard_true': 2,
                           'jump': 1})

    def test_stringbuilder_append_2(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append(u"abc")
                s = sb.build()
                if len(s) != 3: raise ValueError
                if s[0] != u"a": raise ValueError
                if s[1] != u"b": raise ValueError
                if s[2] != u"c": raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops({'int_sub': 2, 'int_gt': 2, 'guard_true': 2,
                           'jump': 1})

    def test_stringbuilder_append_empty(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append(u"")
                s = sb.build()
                if len(s) != 0: raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops({'int_sub': 2, 'int_gt': 2, 'guard_true': 2,
                           'jump': 1})

    def test_stringbuilder_append_len2_1(self):
        jitdriver = JitDriver(reds=['n', 'str1'], greens=[])
        def f(n):
            str1 = unicode(str(n))
            while n > 0:
                jitdriver.jit_merge_point(n=n, str1=str1)
                sb = UnicodeBuilder()
                sb.append(str1)
                sb.append(u"ab")
                s = sb.build()
                if len(s) != 4: raise ValueError
                if s[0] != u"1": raise ValueError
                if s[1] != u"0": raise ValueError
                if s[2] != u"a": raise ValueError
                if s[3] != u"b": raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops(call_n=4, call_r=2,
        # (ll_append_res0, ll_append_0_2, ll_build)
        # * 2 unroll
                          cond_call=0)

    def test_stringbuilder_append_len2_2(self):
        jitdriver = JitDriver(reds=['n', 'str1'], greens=[])
        def f(n):
            str1 = str(n)
            while n > 0:
                jitdriver.jit_merge_point(n=n, str1=str1)
                sb = StringBuilder(4)
                sb.append("a")
                sb.append(str1)
                s = sb.build()
                if len(s) != 3: raise ValueError
                if s[0] != "a": raise ValueError
                if s[1] != "1": raise ValueError
                if s[2] != "0": raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops(call_n=2, call_r=2,
        # (ll_append_res0, ll_build) * 2 unroll
                          cond_call=0)

    def test_stringbuilder_append_slice_1(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append_slice(u"abcdefghij", 1, n)
                sb.append_slice(u"abcdefghij", 0, n)
                s = sb.build()
                if len(s) != 2 * n - 1: raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops(call_n=4, call_r=2, cond_call=0,
                          copyunicodecontent=0)

    def test_stringbuilder_append_slice_2(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append_slice(u"fOo!", 1, 3)
                s = sb.build()
                if len(s) != 2: raise ValueError
                if s[0] != u"O": raise ValueError
                if s[1] != u"o": raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops({'int_sub': 2, 'int_gt': 2, 'guard_true': 2,
                           'jump': 1})

    def test_stringbuilder_append_multiple_char_1(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append_multiple_char(u"x", 5)
                s = sb.build()
                if len(s) != 5: raise ValueError
                if s[0] != u"x": raise ValueError
                if s[1] != u"x": raise ValueError
                if s[2] != u"x": raise ValueError
                if s[3] != u"x": raise ValueError
                if s[4] != u"x": raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops({'int_sub': 2, 'int_gt': 2, 'guard_true': 2,
                           'jump': 1})

    def test_stringbuilder_append_multiple_char_2(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = UnicodeBuilder()
                sb.append_multiple_char(u"x", 35)
                s = sb.build()
                if len(s) != 35: raise ValueError
                for c in s:
                    if c != u"x":
                        raise ValueError
                n -= 1
            return n
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0
        self.check_resops(call_n=2, call_r=2)
         # (_ll_append_multiple_char, build) * 2

    def test_stringbuilder_bug1(self):
        jitdriver = JitDriver(reds=['n', 's1'], greens=[])
        @dont_look_inside
        def escape(x):
            pass
        def f(n):
            s1 = unicode(str(n) * 16)
            while n > 0:
                jitdriver.jit_merge_point(n=n, s1=s1)
                sb = UnicodeBuilder(32)
                sb.append(s1)
                sb.append(u"\n\n")
                s = sb.build()
                if len(s) != 34: raise ValueError
                n -= 1
            return n
        f(10)
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0

    def test_stringbuilder_bug3(self):
        jitdriver = JitDriver(reds=['n'], greens=[])
        IN = ['a' * 37, 'b' * 38, '22', '1', '333']
        JOINED = ''.join(IN)
        def f(n):
            while n > 0:
                jitdriver.jit_merge_point(n=n)
                sb = StringBuilder(36)
                for s in IN:
                    sb.append(s)
                s = sb.build()
                if s != JOINED:
                    raise ValueError
                n -= 1
            return n
        f(10)
        res = self.meta_interp(f, [10], backendopt=True)
        assert res == 0

    def test_shrink_array(self):
        jitdriver = JitDriver(reds=['result', 'n'], greens=[])
        _str, _StringBuilder = self._str, self._StringBuilder

        def f(n):
            result = 0
            while n >= 0:
                jitdriver.jit_merge_point(n=n, result=result)
                b = _StringBuilder(20)
                b.append(_str("Testing!"))
                result += len(b.build())
                n -= 1
            return result

        res = self.meta_interp(f, [9], backendopt=True)
        assert res == f(9)
        self.check_resops({
            'jump': 1, 'guard_true': 2, 'int_ge': 2, 'int_add': 2, 'int_sub': 2
        })

    def test_compare_single_char_for_ordering(self):
        jitdriver = JitDriver(reds=['result', 'n'], greens=[])
        _str = self._str
        constant1 = _str("abcdefghij")

        def cmpstr(x, y):
            return x > _str(y)

        def f(n):
            cmpstr(_str("abc"), "def")  # force x and y to be annot as strings
            result = 0
            while n >= 0:
                jitdriver.jit_merge_point(n=n, result=result)
                c = constant1[n]
                result += cmpstr(c, "c")
                n -= 1
            return result

        res = self.meta_interp(f, [9])
        assert res == f(9)
        self.check_resops(newstr=0, newunicode=0, call=0)


class TestLLtype(StringTests, LLJitMixin):
    CALL = "call_i"
    CALL_PURE = "call_pure_i"


class TestLLtypeUnicode(TestLLtype):
    _str, _chr, _StringBuilder = unicode, unichr, UnicodeBuilder

    def test_str2unicode(self):
        _str = self._str
        jitdriver = JitDriver(greens = [], reds = ['m', 'n'])
        class Foo:
            pass
        @dont_look_inside
        def escape(x):
            assert x == _str("6y")
        def f(n, m):
            while m >= 0:
                jitdriver.can_enter_jit(m=m, n=n)
                jitdriver.jit_merge_point(m=m, n=n)
                foo = Foo()
                foo.y = chr(m)
                foo.y = "y"
                s = _str(str(n)) + _str(foo.y)
                escape(s)
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        # used to be 'call=4', but the call to ll_str2unicode in the
        # loop is not safe to remove; see 56eebe9dd813.  We can still
        # remove the call to ll_str, because that cannot raise anything
        # else than MemoryError.
        self.check_resops(unicodesetitem=2, newunicode=2, call_n=2,
                          call_r=3,
                          copyunicodecontent=2, unicodegetitem=0)

    def test_str2unicode_fold(self):
        _str = self._str
        jitdriver = JitDriver(greens = ['g'], reds = ['m'])
        @dont_look_inside
        def escape(x):
            # a plain "print" would call os.write() and release the gil
            debug_print(str(x))
        def f(g, m):
            g = str(g)
            while m >= 0:
                jitdriver.can_enter_jit(g=g, m=m)
                jitdriver.jit_merge_point(g=g, m=m)
                escape(_str(g))
                m -= 1
            return 42
        self.meta_interp(f, [6, 7])
        self.check_resops(call_pure=0, unicodesetitem=0, call_n=2,
                          newunicode=0, unicodegetitem=0,
                          copyunicodecontent=0)

    def test_string_interpolation(self):
        def f(x, y):
            return len('<%d %d>' % (x, y))
        res = self.interp_operations(f, [222, 3333])
        assert res == 10

    def test_string_interpolation_constants(self):
        jitdriver = JitDriver(greens=['x', 'y'], reds=['z'])
        def f(x, y):
            z = 0
            while z < 10:
                jitdriver.jit_merge_point(x=x, y=y, z=z)
                if len('<%d %d>' % (x, y)) != 10:
                    raise Exception
                z += 1
            return 0
        self.meta_interp(f, [222, 3333])
        self.check_simple_loop({'guard_true': 1, 'int_add': 1,
                                'int_lt': 1, 'jump': 1})

    def test_check_ascii(self):
        from rpython.rlib.rutf8 import check_ascii
        jitdriver = JitDriver(greens=['x', 'y'], reds=['z'])
        def f(x, y):
            z = 0
            while z < 10:
                jitdriver.jit_merge_point(x=x, y=y, z=z)
                if x > 0:
                    s = "abc"
                else:
                    s = "def"
                check_ascii(s)
                z += 1
            return 0
        self.meta_interp(f, [222, 3333])
        self.check_simple_loop(call_i=0)

    def test_string_hashing(self):
        def f(i):
            s = str(i)
            d = {s: s + s}
            return len(d[s])
        assert self.interp_operations(f, [222]) == 6

    def test_str_find(self):
        jitdriver = JitDriver(greens=['x'], reds=['z', 'res'])
        s1 = "aaaaaaef"
        s2 = "aaaaaaaaaaaaaaaaaaaaeebbbbbbbbbbbbbbbbbbef"

        @dont_look_inside
        def pick(x):
            if x > 0:
                return s1
            else:
                return s2

        @dont_look_inside
        def pick_s(z):
            if z < 5:
                return "e"
            return "ef"

        def f(x):
            z = 0
            res = 0
            while z < 10:
                jitdriver.jit_merge_point(x=x, res=res, z=z)
                s = pick(x)
                if x & 1:
                    index = s.find(pick_s(x))
                else:
                    index = s.rfind(pick_s(x))
                if index < 0:
                    return -1001
                if index >= len(s):  # no guard
                    return -106
                res += ord(s[index])
                z += 1
            return res
        res = self.meta_interp(f, [1], backendopt=True)
        assert res == f(1)
        # guard_true(len(search_string) <= 1)
        # guard_false(len(search_string) == 0)
        # guard_false(res >= 0)
        # guard_true(z < 10)
        self.check_simple_loop(guard_true=2, guard_false=2)

        res = self.meta_interp(f, [10], backendopt=True)
        assert res == f(10)
        # guard_false(len(search_string) <= 1), guard_false(res >= 0)
        self.check_simple_loop(guard_false=2)