cimport cython

bytes_abc = b'abc'
bytes_ABC = b'ABC'
bytes_abc_null = b'a\0b\0c'
bytes_ABC_null = b'A\0B\0C'

unicode_abc = u'abc'
unicode_ABC = u'ABC'
unicode_abc_null = u'a\0b\0c'
unicode_ABC_null = u'A\0B\0C'


def for_in_bytes(bytes s):
    """
    >>> for_in_bytes(bytes_abc)
    'X'
    >>> for_in_bytes(bytes_ABC)
    'C'
    >>> for_in_bytes(bytes_abc_null)
    'X'
    >>> for_in_bytes(bytes_ABC_null)
    'C'
    """
    for c in s:
        # Py2/Py3
        if c == b'C' or c == c'C':
            return 'C'
    else:
        return 'X'

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_char_in_bytes(bytes s):
    """
    >>> for_char_in_bytes(bytes_abc)
    'X'
    >>> for_char_in_bytes(bytes_ABC)
    'C'
    >>> for_char_in_bytes(bytes_abc_null)
    'X'
    >>> for_char_in_bytes(bytes_ABC_null)
    'C'
    """
    cdef char c
    for c in s:
        if c == b'C':
            return 'C'
    else:
        return 'X'

#### Py2 and Py3 behave differently here: Py2->bytes, Py3->integer
##
## @cython.test_assert_path_exists("//ForFromStatNode")
## @cython.test_fail_if_path_exists("//ForInStatNode")
## def for_obj_in_bytes_slice(bytes s):
##     """
##     >>> for_obj_in_bytes_slice(bytes_abc)
##     'X'
##     >>> for_obj_in_bytes_slice(bytes_ABC)
##     'B'
##     >>> for_obj_in_bytes_slice(bytes_abc_null)
##     'X'
##     >>> for_obj_in_bytes_slice(bytes_ABC_null)
##     'B'
##     """
##     for c in s[1:-1]:
##         if c == b'B':
##             return 'B'
##     else:
##         return 'X'

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_char_in_bytes_slice(bytes s):
    """
    >>> for_char_in_bytes_slice(bytes_abc)
    'X'
    >>> for_char_in_bytes_slice(bytes_ABC)
    'B'
    >>> for_char_in_bytes_slice(bytes_abc_null)
    'X'
    >>> for_char_in_bytes_slice(bytes_ABC_null)
    'B'
    """
    cdef char c
    for c in s[1:-1]:
        if c == c'B':
            return 'B'
    else:
        return 'X'

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_char_in_enumerate_bytes(bytes s):
    """
    >>> for_char_in_enumerate_bytes(bytes_abc)
    'X'
    >>> for_char_in_enumerate_bytes(bytes_ABC)
    2
    >>> for_char_in_enumerate_bytes(bytes_abc_null)
    'X'
    >>> for_char_in_enumerate_bytes(bytes_ABC_null)
    4
    """
    cdef char c
    cdef Py_ssize_t i
    for i, c in enumerate(s):
        if c == b'C':
            return i
    else:
        return 'X'

#### Py2 and Py3 behave differently here: Py2->bytes, Py3->integer
##
## @cython.test_assert_path_exists("//ForFromStatNode")
## @cython.test_fail_if_path_exists("//ForInStatNode")
## def for_pyvar_in_char_ptr(char* c_string):
##     """
##     >>> for_pyvar_in_char_ptr( (bytes_abc+bytes_ABC) * 2 )
##     [True, True, True, False, False, False, True, True, True, False]
##     >>> for_pyvar_in_char_ptr( bytes_abc_null * 2 )
##     [True, False, True, False, True, True, False, True, False, True]
##     """
##     in_test = []
##     cdef object c
##     for c in c_string[:10]:
##         in_test.append( c in b'abc' )
##     return in_test

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_char_in_char_ptr(char* c_string):
    """
    >>> for_char_in_char_ptr( (bytes_abc+bytes_ABC) * 2 )
    [True, True, True, False, False, False, True, True, True, False]
    >>> for_char_in_char_ptr( bytes_abc_null * 2 )
    [True, False, True, False, True, True, False, True, False, True]
    """
    in_test = []
    cdef char c
    for c in c_string[:10]:
        in_test.append( c in b'abc' )
    return in_test

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_pyunicode_in_unicode(unicode s):
    """
    >>> for_pyunicode_in_unicode(unicode_abc)
    'X'
    >>> for_pyunicode_in_unicode(unicode_ABC)
    'C'
    >>> for_pyunicode_in_unicode(unicode_abc_null)
    'X'
    >>> for_pyunicode_in_unicode(unicode_ABC_null)
    'C'
    """
    cdef Py_UNICODE c
    for c in s:
        if c == u'C':
            return 'C'
    else:
        return 'X'

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_pyunicode_in_enumerate_unicode(unicode s):
    """
    >>> for_pyunicode_in_enumerate_unicode(unicode_abc)
    'X'
    >>> for_pyunicode_in_enumerate_unicode(unicode_ABC)
    2
    >>> for_pyunicode_in_enumerate_unicode(unicode_abc_null)
    'X'
    >>> for_pyunicode_in_enumerate_unicode(unicode_ABC_null)
    4
    """
    cdef Py_UNICODE c
    cdef Py_ssize_t i
    for i, c in enumerate(s):
        if c == u'C':
            return i
    else:
        return 'X'

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_pyucs4_in_unicode(unicode s):
    """
    >>> for_pyucs4_in_unicode(unicode_abc)
    'X'
    >>> for_pyucs4_in_unicode(unicode_ABC)
    'C'
    >>> for_pyucs4_in_unicode(unicode_abc_null)
    'X'
    >>> for_pyucs4_in_unicode(unicode_ABC_null)
    'C'
    """
    cdef Py_UCS4 c
    for c in s:
        if c == u'C':
            return 'C'
    else:
        return 'X'

@cython.test_assert_path_exists("//ForFromStatNode")
@cython.test_fail_if_path_exists("//ForInStatNode")
def for_pyucs4_in_enumerate_unicode(unicode s):
    """
    >>> for_pyucs4_in_enumerate_unicode(unicode_abc)
    'X'
    >>> for_pyucs4_in_enumerate_unicode(unicode_ABC)
    2
    >>> for_pyucs4_in_enumerate_unicode(unicode_abc_null)
    'X'
    >>> for_pyucs4_in_enumerate_unicode(unicode_ABC_null)
    4
    """
    cdef Py_UCS4 c
    cdef Py_ssize_t i
    for i, c in enumerate(s):
        if c == u'C':
            return i
    else:
        return 'X'