cimport cython

def f(a,b):

    """

    >>> f(1,[1,2,3])

    True

    >>> f(5,[1,2,3])

    False

    >>> f(2,(1,2,3))

    True

    """

    cdef object result = a in b

    return result

def g(a,b):

    """

    >>> g(1,[1,2,3])

    1

    >>> g(5,[1,2,3])

    0

    >>> g(2,(1,2,3))

    1

    """

    cdef int result = a in b

    return result

def h(b):

    """

    >>> h([1,2,3,4])

    True

    >>> h([1,3,4])

    False

    """

    cdef object result = 2 in b

    return result

def j(b):

    """

    >>> j([1,2,3,4])

    1

    >>> j([1,3,4])

    0

    """

    cdef int result = 2 in b

    return result

@cython.test_fail_if_path_exists("//SwitchStatNode")

def k(a):

    """

    >>> k(1)

    1

    >>> k(5)

    0

    """

    cdef int result = a in [1,2,3,4]

    return result

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def m_list(int a):

    """

    >>> m_list(2)

    1

    >>> m_list(5)

    0

    """

    cdef int result = a in [1,2,3,4]

    return result

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def m_tuple(int a):

    """

    >>> m_tuple(2)

    1

    >>> m_tuple(5)

    0

    """

    cdef int result = a in (1,2,3,4)

    return result

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def m_set(int a):

    """

    >>> m_set(2)

    1

    >>> m_set(5)

    0

    """

    cdef int result = a in {1,2,3,4}

    return result

cdef bytes bytes_string = b'ab\0cde\0f\0g'

py_bytes_string = bytes_string

@cython.test_assert_path_exists("//PrimaryCmpNode")

@cython.test_fail_if_path_exists("//SwitchStatNode", "//BoolBinopNode")

def m_bytes(char a, bytes bytes_string):

    """

    >>> m_bytes(ord('f'), py_bytes_string)

    1

    >>> m_bytes(ord('X'), py_bytes_string)

    0

    >>> 'f'.encode('ASCII') in None    # doctest: +ELLIPSIS

    Traceback (most recent call last):

    TypeError: ...iterable...

    >>> m_bytes(ord('f'), None)

    Traceback (most recent call last):

    TypeError: argument of type 'NoneType' is not iterable

    """

    cdef int result = a in bytes_string

    return result

@cython.test_assert_path_exists("//PrimaryCmpNode")

@cython.test_fail_if_path_exists("//SwitchStatNode", "//BoolBinopNode")

def m_bytes_unsigned(unsigned char a, bytes bytes_string):

    """

    >>> m_bytes(ord('f'), py_bytes_string)

    1

    >>> m_bytes(ord('X'), py_bytes_string)

    0

    >>> 'f'.encode('ASCII') in None    # doctest: +ELLIPSIS

    Traceback (most recent call last):

    TypeError: ...iterable...

    >>> m_bytes(ord('f'), None)

    Traceback (most recent call last):

    TypeError: argument of type 'NoneType' is not iterable

    """

    cdef int result = a in bytes_string

    return result

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def m_bytes_literal(char a):

    """

    >>> m_bytes_literal(ord('f'))

    1

    >>> m_bytes_literal(ord('X'))

    0

    """

    cdef int result = a in b'ab\0cde\0f\0g'

    return result

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def m_bytes_literal_unsigned(unsigned char a):

    """

    >>> m_bytes_literal(ord('f'))

    1

    >>> m_bytes_literal(ord('X'))

    0

    """

    cdef int result = a in b'ab\0cde\0f\0g'

    return result

cdef unicode unicode_string = u'abc\0defg\u1234\uF8D2'

py_unicode_string = unicode_string

@cython.test_assert_path_exists("//PrimaryCmpNode")

@cython.test_fail_if_path_exists("//SwitchStatNode", "//BoolBinopNode")

def m_unicode(Py_UNICODE a, unicode unicode_string):

    """

    >>> m_unicode(ord('f'), py_unicode_string)

    1

    >>> m_unicode(ord('X'), py_unicode_string)

    0

    >>> m_unicode(ord(py_klingon_character), py_unicode_string)

    1

    >>> 'f' in None   # doctest: +ELLIPSIS

    Traceback (most recent call last):

    TypeError: ...iterable...

    >>> m_unicode(ord('f'), None)

    Traceback (most recent call last):

    TypeError: argument of type 'NoneType' is not iterable

    """

    cdef int result = a in unicode_string

    return result

cdef unicode klingon_character = u'\uF8D2'

py_klingon_character = klingon_character

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def m_unicode_literal(Py_UNICODE a):

    """

    >>> m_unicode_literal(ord('f'))

    1

    >>> m_unicode_literal(ord('X'))

    0

    >>> m_unicode_literal(ord(py_klingon_character))

    1

    """

    cdef int result = a in u'abc\0defg\u1234\uF8D2'

    return result

cdef unicode wide_unicode_character = u'\U0010FEDC'

py_wide_unicode_character = wide_unicode_character

wide_unicode_character_surrogate1 = 0xDBFF

wide_unicode_character_surrogate2 = 0xDEDC

@cython.test_fail_if_path_exists("//SwitchStatNode")

@cython.test_assert_path_exists("//PrimaryCmpNode")

def m_wide_unicode_literal(Py_UCS4 a):

    """

    >>> m_unicode_literal(ord('f'))

    1

    >>> m_unicode_literal(ord('X'))

    0

    >>> import sys

    >>> if sys.maxunicode == 65535:

    ...     m_wide_unicode_literal(wide_unicode_character_surrogate1)

    ...     m_wide_unicode_literal(wide_unicode_character_surrogate2)

    ... else:

    ...     m_wide_unicode_literal(ord(py_wide_unicode_character))

    ...     1

    1

    1

    """

    cdef int result = a in u'abc\0defg\u1234\uF8D2\U0010FEDC'

    return result

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def conditional_int(int a):

    """

    >>> conditional_int(1)

    1

    >>> conditional_int(0)

    2

    >>> conditional_int(5)

    2

    """

    return 1 if a in (1,2,3,4) else 2

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def conditional_object(int a):

    """

    >>> conditional_object(1)

    1

    >>> conditional_object(0)

    '2'

    >>> conditional_object(5)

    '2'

    """

    return 1 if a in (1,2,3,4) else '2'

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def conditional_bytes(char a):

    """

    >>> conditional_bytes(ord('a'))

    1

    >>> conditional_bytes(ord('X'))

    '2'

    >>> conditional_bytes(0)

    '2'

    """

    return 1 if a in b'abc' else '2'

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def conditional_unicode(Py_UNICODE a):

    """

    >>> conditional_unicode(ord('a'))

    1

    >>> conditional_unicode(ord('X'))

    '2'

    >>> conditional_unicode(0)

    '2'

    """

    return 1 if a in u'abc' else '2'

@cython.test_assert_path_exists("//SwitchStatNode")

@cython.test_fail_if_path_exists("//BoolBinopNode", "//PrimaryCmpNode")

def conditional_none(int a):

    """

    >>> conditional_none(1)

    >>> conditional_none(0)

    1

    >>> conditional_none(5)

    1

    """

    return None if a in {1,2,3,4} else 1

@cython.test_assert_path_exists(

    "//BoolBinopNode",

    "//BoolBinopNode//PrimaryCmpNode"

)

@cython.test_fail_if_path_exists("//ListNode")

def n(a):

    """

    >>> n('d *')

    1

    >>> n('xxx')

    0

    """

    cdef int result = a.lower() in [u'a *',u'b *',u'c *',u'd *']

    return result

def p(a):

    """

    >>> p(1)

    0

    >>> p('a')

    1

    """

    cdef dict d = {u'a': 1, u'b': 2}

    cdef int result = a in d

    return result

def q(a):

    """

    >>> q(1)

    Traceback (most recent call last):

    TypeError: 'NoneType' object is not iterable

        >>> l = [1,2,3,4]

    >>> l2 = [l[1:],l[:-1],l]

    >>> 2 in l in l2

    True

    """

    cdef dict d = None

    cdef int result = a in d # should fail with a TypeError

    return result

def r(a):

    """

    >>> r(2)

    1

    """

    cdef object l = [1,2,3,4]

    cdef object l2 = [l[1:],l[:-1],l]

    cdef int result = a in l in l2

    return result

def s(a):

    """

    >>> s(2)

    1

    """

    cdef int result = a in [1,2,3,4] in [[1,2,3],[2,3,4],[1,2,3,4]]

    return result

#@cython.test_assert_path_exists("//ReturnStatNode//BoolNode")

#@cython.test_fail_if_path_exists("//SwitchStatNode")

def constant_empty_sequence(a):

    """

    >>> constant_empty_sequence(1)

    False

    >>> constant_empty_sequence(5)

    False

    """

    return a in ()

@cython.test_fail_if_path_exists("//ReturnStatNode//BoolNode")

@cython.test_assert_path_exists("//PrimaryCmpNode")

def constant_empty_sequence_side_effect(a):

    """

    >>> l =[]

    >>> def a():

    ...     l.append(1)

    ...     return 1

    >>> constant_empty_sequence_side_effect(a)

    False

    >>> l

    [1]

    """

    return a() in ()

def test_error_non_iterable(x):

    """

    >>> test_error_non_iterable(1)   # doctest: +ELLIPSIS

    Traceback (most recent call last):

    TypeError: ...iterable...

    """

    return x in 42

def test_error_non_iterable_cascaded(x):

    """

    >>> test_error_non_iterable_cascaded(1)   # doctest: +ELLIPSIS

    Traceback (most recent call last):

    TypeError: ...iterable...

    """

    return 1 == x in 42

def test_inop_cascaded(x):

    """

    >>> test_inop_cascaded(1)

    False

    >>> test_inop_cascaded(2)

    True

    >>> test_inop_cascaded(3)

    False

    """

    return 1 != x in [2]

### The following tests are copied from CPython's test_grammar.py.

### They look stupid, but the nice thing about them is that Cython

### treats '1' as a C integer constant that triggers Python object

### coercion for the 'in' operator here, whereas the left side of

### the cascade can be evaluated entirely in C space.

def test_inop_cascaded_one():

    """

    >>> test_inop_cascaded_one()

    False

    """

    return 1 < 1 > 1 == 1 >= 1 <= 1 != 1 in 1 not in 1 is 1 is not 1

def test_inop_cascaded_int_orig(int x):

    """

    >>> test_inop_cascaded_int_orig(1)

    False

    """

    return 1 < 1 > 1 == 1 >= 1 <= 1 != x in 1 not in 1 is 1 is not 1

def test_inop_cascaded_one_err():

    """

    >>> test_inop_cascaded_one_err()   # doctest: +ELLIPSIS

    Traceback (most recent call last):

    TypeError:... itera...

    """

    return 1 == 1 >= 1 <= 1 in 1 not in 1 is 1 is not 1

def test_inop_cascaded_int_orig_err(int x):

    """

    >>> test_inop_cascaded_int_orig_err(1)   # doctest: +ELLIPSIS

    Traceback (most recent call last):

    TypeError:... itera...

    """

    return 1 == 1 >= 1 <= 1 == x in 1 not in 1 is 1 is not 1

###

def test_inop_cascaded_int(int x):

    """

    >>> test_inop_cascaded_int(1)

    False

    >>> test_inop_cascaded_int(2)

    True

    >>> test_inop_cascaded_int(3)

    False

    """

    return 1 != x in [1,2]