Cython 3.2.0__cp39-abi3-win32.whl

Cython/Compiler/Tests/TestCode.py

@@ -0,0 +1,144 @@
+import textwrap
+from unittest import TestCase
+
+from .. import Naming
+from ..Code import _indent_chunk, UtilityCode, process_utility_ccode
+
+class TestIndent(TestCase):
+    def _test_indentations(self, chunk, expected):
+        for indentation in range(16):
+            expected_indented = textwrap.indent(expected, ' ' * indentation)
+            for line in expected_indented.splitlines():
+                # Validate before the comparison that empty lines got stripped also by textwrap.indent().
+                self.assertTrue(line == '' or line.strip(), repr(line))
+
+            with self.subTest(indentation=indentation):
+                result = _indent_chunk(chunk, indentation_length=indentation)
+                self.assertEqual(expected_indented, result)
+
+    def test_indent_empty(self):
+        self._test_indentations('', '')
+
+    def test_indent_empty_lines(self):
+        self._test_indentations('\n', '\n')
+        self._test_indentations('\n'*2, '\n'*2)
+        self._test_indentations('\n'*3, '\n'*3)
+        self._test_indentations(' \n'*2, '\n'*2)
+        self._test_indentations('\n  \n \n    \n', '\n'*4)
+
+    def test_indent_one_line(self):
+        self._test_indentations('abc', 'abc')
+
+    def test_indent_chunk(self):
+        chunk = """
+            x = 1
+            if x == 2:
+                print("False")
+            else:
+                print("True")
+        """
+        expected = """
+x = 1
+if x == 2:
+    print("False")
+else:
+    print("True")
+"""
+        self._test_indentations(chunk, expected)
+
+    def test_indent_empty_line(self):
+        chunk = """
+            x = 1
+
+            if x == 2:
+                print("False")
+            else:
+                print("True")
+        """
+        expected = """
+x = 1
+
+if x == 2:
+    print("False")
+else:
+    print("True")
+"""
+        self._test_indentations(chunk, expected)
+
+    def test_indent_empty_line_unclean(self):
+        lines = """
+            x = 1
+
+            if x == 2:
+                print("False")
+            else:
+                print("True")
+        """.splitlines(keepends=True)
+        lines[2] = '            \n'
+        chunk = ''.join(lines)
+        expected = """
+x = 1
+
+if x == 2:
+    print("False")
+else:
+    print("True")
+"""
+        self._test_indentations(chunk, expected)
+
+
+class TestUtilityCodeProcessing(TestCase):
+    def _process(self, code):
+        utility_code = UtilityCode()
+        formatted_code, is_module_specific = process_utility_ccode(utility_code, None, code)
+        self.assertFalse(is_module_specific)  # cannot currently test this case
+        return formatted_code
+
+    def assert_formatted_code(self, code: str, expected: str, dedent=False):
+        if dedent:
+            expected = textwrap.dedent(expected)
+        expected = expected.strip() + '\n\n'
+        formatted = self._process(code)
+        self.assertEqual(formatted, expected)
+
+    def test_format_cstring(self):
+        self.assert_formatted_code('''
+        Some Text and a CSTRING("""
+        spanning "multiple" 'lines'.
+        Really.
+        """);   # end of C string
+        ''',
+        expected=r'''
+        Some Text and a "\n"
+        "        spanning \042multiple\042 'lines'.\n"
+        "        Really.\n"
+        "        \n"
+        ;   # end of C string
+        ''',
+        dedent=True)
+
+    def test_cglobal(self):
+        self.assert_formatted_code("""
+        CGLOBAL(name)
+        NAMED_CGLOBAL(empty_tuple)
+        """,
+        expected=f"""
+        {Naming.modulestateglobal_cname}->name
+        {Naming.modulestateglobal_cname}->{Naming.empty_tuple}
+        """)
+
+    def test_empty_builtin(self):
+        self.assert_formatted_code("""
+        EMPTY(tuple)EMPTY(bytes)
+        EMPTY(tuple);EMPTY(bytes)
+        EMPTY(unicode)
+        EMPTY(bytes)
+        EMPTY(tuple)
+        """,
+        expected=f"""
+        {Naming.modulestateglobal_cname}->{Naming.empty_tuple}{Naming.modulestateglobal_cname}->{Naming.empty_bytes}
+        {Naming.modulestateglobal_cname}->{Naming.empty_tuple};{Naming.modulestateglobal_cname}->{Naming.empty_bytes}
+        {Naming.modulestateglobal_cname}->{Naming.empty_unicode}
+        {Naming.modulestateglobal_cname}->{Naming.empty_bytes}
+        {Naming.modulestateglobal_cname}->{Naming.empty_tuple}
+        """)

Cython/Compiler/Tests/TestFlowControl.py

@@ -0,0 +1,65 @@
+from copy import deepcopy
+from unittest import TestCase
+
+from Cython.Compiler.FlowControl import (
+    NameAssignment, StaticAssignment, Argument, NameDeletion)
+
+
+class FakeType:
+    is_pyobject = True
+
+
+class FakeNode:
+    pos = ('filename.pyx', 1, 2)
+    cf_state = None
+    type = FakeType()
+
+    def infer_type(self, scope):
+        return self.type
+
+
+class FakeEntry:
+    type = FakeType()
+
+
+class TestGraph(TestCase):
+    def test_deepcopy(self):
+        lhs, rhs = FakeNode(), FakeNode()
+        entry = FakeEntry()
+        entry.pos = lhs.pos
+
+        name_ass = NameAssignment(lhs, rhs, entry)
+        ass = deepcopy(name_ass)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, name_ass.pos)
+        self.assertFalse(ass.is_arg)
+        self.assertFalse(ass.is_deletion)
+
+        static_ass = StaticAssignment(entry)
+        ass = deepcopy(static_ass)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, static_ass.pos)
+        self.assertFalse(ass.is_arg)
+        self.assertFalse(ass.is_deletion)
+
+        arg_ass = Argument(lhs, rhs, entry)
+        ass = deepcopy(arg_ass)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, arg_ass.pos)
+        self.assertTrue(ass.is_arg)
+        self.assertFalse(ass.is_deletion)
+
+        name_del = NameDeletion(lhs, entry)
+        ass = deepcopy(name_del)
+        self.assertTrue(ass.lhs)
+        self.assertTrue(ass.rhs)
+        self.assertTrue(ass.entry)
+        self.assertEqual(ass.pos, name_del.pos)
+        self.assertFalse(ass.is_arg)
+        self.assertTrue(ass.is_deletion)

Cython/Compiler/Tests/TestGrammar.py

@@ -0,0 +1,202 @@
+# mode: run
+# tag: syntax
+
+"""
+Uses TreeFragment to test invalid syntax.
+"""
+
+
+import ast
+import textwrap
+
+from ...TestUtils import CythonTest
+from .. import ExprNodes
+from ..Errors import CompileError
+
+# Copied from CPython's test_grammar.py
+VALID_UNDERSCORE_LITERALS = [
+    '0_0_0',
+    '4_2',
+    '1_0000_0000',
+    '0b1001_0100',
+    '0xffff_ffff',
+    '0o5_7_7',
+    '1_00_00.5',
+    '1_00_00.5j',
+    '1_00_00.5e5',
+    '1_00_00j',
+    '1_00_00e5_1',
+    '1e1_0',
+    '.1_4',
+    '.1_4e1',
+    '0b_0',
+    '0x_f',
+    '0o_5',
+    '1_00_00j',
+    '1_00_00.5j',
+    '1_00_00e5_1j',
+    '.1_4j',
+    '(1_2.5+3_3j)',
+    '(.5_6j)',
+]
+
+# Copied from CPython's test_grammar.py
+INVALID_UNDERSCORE_LITERALS = [
+    # Trailing underscores:
+    '0_',
+    '42_',
+    '1.4j_',
+    '0x_',
+    '0b1_',
+    '0xf_',
+    '0o5_',
+    '0 if 1_Else 1',
+    # Underscores in the base selector:
+    '0_b0',
+    '0_xf',
+    '0_o5',
+    # Old-style octal, still disallowed:
+    # FIXME: still need to support PY_VERSION_HEX < 3
+    '0_7',
+    '09_99',
+    # Multiple consecutive underscores:
+    '4_______2',
+    '0.1__4',
+    '0.1__4j',
+    '0b1001__0100',
+    '0xffff__ffff',
+    '0x___',
+    '0o5__77',
+    '1e1__0',
+    '1e1__0j',
+    # Underscore right before a dot:
+    '1_.4',
+    '1_.4j',
+    # Underscore right after a dot:
+    '1._4',
+    '1._4j',
+    '._5',
+    '._5j',
+    # Underscore right after a sign:
+    '1.0e+_1',
+    '1.0e+_1j',
+    # Underscore right before j:
+    '1.4_j',
+    '1.4e5_j',
+    # Underscore right before e:
+    '1_e1',
+    '1.4_e1',
+    '1.4_e1j',
+    # Underscore right after e:
+    '1e_1',
+    '1.4e_1',
+    '1.4e_1j',
+    # Complex cases with parens:
+    '(1+1.5_j_)',
+    '(1+1.5_j)',
+    # Whitespace in literals
+    '1_ 2',
+    '1 _2',
+    '1_2.2_ 1',
+    '1_2.2 _1',
+    '1_2e _1',
+    '1_2e2 _1',
+    '1_2e 2_1',
+]
+
+
+INVALID_ELLIPSIS = [
+    (". . .", 2, 0),
+    (". ..", 2, 0),
+    (".. .", 2, 0),
+    (". ...", 2, 0),
+    (". ... .", 2, 0),
+    (".. ... .", 2, 0),
+    (". ... ..", 2, 0),
+    ("""
+    (
+        .
+        ..
+    )
+    """, 3, 4),
+    ("""
+    [
+        ..
+        .,
+        None
+    ]
+    """, 3, 4),
+    ("""
+    {
+        None,
+        .
+        .
+
+        .
+    }
+    """, 4, 4)
+]
+
+
+class TestGrammar(CythonTest):
+
+    def test_invalid_number_literals(self):
+        for literal in INVALID_UNDERSCORE_LITERALS:
+            for expression in ['%s', '1 + %s', '%s + 1', '2 * %s', '%s * 2']:
+                code = 'x = ' + expression % literal
+                try:
+                    self.fragment('''\
+                    # cython: language_level=3
+                    ''' + code)
+                except CompileError as exc:
+                    assert code in [s.strip() for s in str(exc).splitlines()], str(exc)
+                else:
+                    assert False, "Invalid Cython code '%s' failed to raise an exception" % code
+
+    def test_valid_number_literals(self):
+        for literal in VALID_UNDERSCORE_LITERALS:
+            for i, expression in enumerate(['%s', '1 + %s', '%s + 1', '2 * %s', '%s * 2']):
+                code = 'x = ' + expression % literal
+                node = self.fragment('''\
+                    # cython: language_level=3
+                    ''' + code).root
+                assert node is not None
+
+                literal_node = node.stats[0].rhs  # StatListNode([SingleAssignmentNode('x', expr)])
+                if i > 0:
+                    # Add/MulNode() -> literal is first or second operand
+                    literal_node = literal_node.operand2 if i % 2 else literal_node.operand1
+                if 'j' in literal or 'J' in literal:
+                    if '+' in literal:
+                        # FIXME: tighten this test
+                        assert isinstance(literal_node, ExprNodes.AddNode), (literal, literal_node)
+                    else:
+                        assert isinstance(literal_node, ExprNodes.ImagNode), (literal, literal_node)
+                elif '.' in literal or 'e' in literal or 'E' in literal and not ('0x' in literal or '0X' in literal):
+                    assert isinstance(literal_node, ExprNodes.FloatNode), (literal, literal_node)
+                else:
+                    assert isinstance(literal_node, ExprNodes.IntNode), (literal, literal_node)
+
+    def test_invalid_ellipsis(self):
+        ERR = ":{0}:{1}: Expected an identifier or literal"
+        for code, line, col in INVALID_ELLIPSIS:
+            try:
+                ast.parse(textwrap.dedent(code))
+            except SyntaxError as exc:
+                assert True
+            else:
+                assert False, "Invalid Python code '%s' failed to raise an exception" % code
+
+            try:
+                self.fragment('''\
+                # cython: language_level=3
+                ''' + code)
+            except CompileError as exc:
+                assert ERR.format(line, col) in str(exc), str(exc)
+            else:
+                assert False, "Invalid Cython code '%s' failed to raise an exception" % code
+
+
+if __name__ == "__main__":
+    import unittest
+    unittest.main()

Cython/Compiler/Tests/TestMemView.py

@@ -0,0 +1,71 @@
+from Cython.TestUtils import CythonTest
+import Cython.Compiler.Errors as Errors
+from Cython.Compiler.Nodes import *
+from Cython.Compiler.ParseTreeTransforms import *
+from Cython.Compiler.Buffer import *
+
+
+class TestMemviewParsing(CythonTest):
+
+    def parse(self, s):
+        return self.should_not_fail(lambda: self.fragment(s)).root
+
+    def not_parseable(self, expected_error, s):
+        e = self.should_fail(lambda: self.fragment(s),  Errors.CompileError)
+        self.assertEqual(expected_error, e.message_only)
+
+    def test_default_1dim(self):
+        self.parse("cdef int[:] x")
+        self.parse("cdef short int[:] x")
+
+    def test_default_ndim(self):
+        self.parse("cdef int[:,:,:,:,:] x")
+        self.parse("cdef unsigned long int[:,:,:,:,:] x")
+        self.parse("cdef unsigned int[:,:,:,:,:] x")
+
+    def test_zero_offset(self):
+        self.parse("cdef long double[0:] x")
+        self.parse("cdef int[0:] x")
+
+    def test_zero_offset_ndim(self):
+        self.parse("cdef int[0:,0:,0:,0:] x")
+
+    def test_def_arg(self):
+        self.parse("def foo(int[:,:] x): pass")
+
+    def test_cdef_arg(self):
+        self.parse("cdef foo(int[:,:] x): pass")
+
+    def test_general_slice(self):
+        self.parse('cdef float[::ptr, ::direct & contig, 0::full & strided] x')
+
+    def test_non_slice_memview(self):
+        self.not_parseable("An axis specification in memoryview declaration does not have a ':'.",
+                "cdef double[:foo, bar] x")
+        self.not_parseable("An axis specification in memoryview declaration does not have a ':'.",
+                "cdef double[0:foo, bar] x")
+
+    def test_basic(self):
+        t = self.parse("cdef int[:] x")
+        memv_node = t.stats[0].base_type
+        self.assertTrue(isinstance(memv_node, MemoryViewSliceTypeNode))
+
+    # we also test other similar declarations (buffers, anonymous C arrays)
+    # since the parsing has to distinguish between them.
+
+    def disable_test_no_buf_arg(self):  # TODO
+        self.not_parseable("Expected ']'",
+                "cdef extern foo(object[int, ndim=2])")
+
+    def disable_test_parse_sizeof(self):  # TODO
+        self.parse("sizeof(int[NN])")
+        self.parse("sizeof(int[])")
+        self.parse("sizeof(int[][NN])")
+        self.not_parseable("Expected an identifier or literal",
+                "sizeof(int[:NN])")
+        self.not_parseable("Expected ']'",
+                "sizeof(foo[dtype=bar]")
+
+if __name__ == '__main__':
+    import unittest
+    unittest.main()