Restoring authorship annotation for Anton Samokhvalov <[email protected]>. Commit 2 of 2.

1 files changed, 281 insertions, 281 deletions

diff --git a/contrib/tools/cython/Cython/Compiler/Tests/TestParseTreeTransforms.py b/contrib/tools/cython/Cython/Compiler/Tests/TestParseTreeTransforms.py
index 1249c8db07e..234b45db5b5 100644
--- a/contrib/tools/cython/Cython/Compiler/Tests/TestParseTreeTransforms.py
+++ b/contrib/tools/cython/Cython/Compiler/Tests/TestParseTreeTransforms.py
@@ -1,282 +1,282 @@
-import os 
- 
-from Cython.TestUtils import TransformTest 
-from Cython.Compiler.ParseTreeTransforms import * 
-from Cython.Compiler.Nodes import * 
-from Cython.Compiler import Main, Symtab 
- 
- 
-class TestNormalizeTree(TransformTest): 
-    def test_parserbehaviour_is_what_we_coded_for(self): 
-        t = self.fragment(u"if x: y").root 
-        self.assertLines(u""" 
-(root): StatListNode 
-  stats[0]: IfStatNode 
-    if_clauses[0]: IfClauseNode 
-      condition: NameNode 
-      body: ExprStatNode 
-        expr: NameNode 
-""", self.treetypes(t)) 
- 
-    def test_wrap_singlestat(self): 
-        t = self.run_pipeline([NormalizeTree(None)], u"if x: y") 
-        self.assertLines(u""" 
-(root): StatListNode 
-  stats[0]: IfStatNode 
-    if_clauses[0]: IfClauseNode 
-      condition: NameNode 
-      body: StatListNode 
-        stats[0]: ExprStatNode 
-          expr: NameNode 
-""", self.treetypes(t)) 
- 
-    def test_wrap_multistat(self): 
-        t = self.run_pipeline([NormalizeTree(None)], u""" 
-            if z: 
-                x 
-                y 
-        """) 
-        self.assertLines(u""" 
-(root): StatListNode 
-  stats[0]: IfStatNode 
-    if_clauses[0]: IfClauseNode 
-      condition: NameNode 
-      body: StatListNode 
-        stats[0]: ExprStatNode 
-          expr: NameNode 
-        stats[1]: ExprStatNode 
-          expr: NameNode 
-""", self.treetypes(t)) 
- 
-    def test_statinexpr(self): 
-        t = self.run_pipeline([NormalizeTree(None)], u""" 
-            a, b = x, y 
-        """) 
-        self.assertLines(u""" 
-(root): StatListNode 
-  stats[0]: SingleAssignmentNode 
-    lhs: TupleNode 
-      args[0]: NameNode 
-      args[1]: NameNode 
-    rhs: TupleNode 
-      args[0]: NameNode 
-      args[1]: NameNode 
-""", self.treetypes(t)) 
- 
-    def test_wrap_offagain(self): 
-        t = self.run_pipeline([NormalizeTree(None)], u""" 
-            x 
-            y 
-            if z: 
-                x 
-        """) 
-        self.assertLines(u""" 
-(root): StatListNode 
-  stats[0]: ExprStatNode 
-    expr: NameNode 
-  stats[1]: ExprStatNode 
-    expr: NameNode 
-  stats[2]: IfStatNode 
-    if_clauses[0]: IfClauseNode 
-      condition: NameNode 
-      body: StatListNode 
-        stats[0]: ExprStatNode 
-          expr: NameNode 
-""", self.treetypes(t)) 
- 
- 
-    def test_pass_eliminated(self): 
-        t = self.run_pipeline([NormalizeTree(None)], u"pass") 
+import os
+
+from Cython.TestUtils import TransformTest
+from Cython.Compiler.ParseTreeTransforms import *
+from Cython.Compiler.Nodes import *
+from Cython.Compiler import Main, Symtab
+
+
+class TestNormalizeTree(TransformTest):
+    def test_parserbehaviour_is_what_we_coded_for(self):
+        t = self.fragment(u"if x: y").root
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: ExprStatNode
+        expr: NameNode
+""", self.treetypes(t))
+
+    def test_wrap_singlestat(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"if x: y")
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: StatListNode
+        stats[0]: ExprStatNode
+          expr: NameNode
+""", self.treetypes(t))
+
+    def test_wrap_multistat(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"""
+            if z:
+                x
+                y
+        """)
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: StatListNode
+        stats[0]: ExprStatNode
+          expr: NameNode
+        stats[1]: ExprStatNode
+          expr: NameNode
+""", self.treetypes(t))
+
+    def test_statinexpr(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"""
+            a, b = x, y
+        """)
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: SingleAssignmentNode
+    lhs: TupleNode
+      args[0]: NameNode
+      args[1]: NameNode
+    rhs: TupleNode
+      args[0]: NameNode
+      args[1]: NameNode
+""", self.treetypes(t))
+
+    def test_wrap_offagain(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"""
+            x
+            y
+            if z:
+                x
+        """)
+        self.assertLines(u"""
+(root): StatListNode
+  stats[0]: ExprStatNode
+    expr: NameNode
+  stats[1]: ExprStatNode
+    expr: NameNode
+  stats[2]: IfStatNode
+    if_clauses[0]: IfClauseNode
+      condition: NameNode
+      body: StatListNode
+        stats[0]: ExprStatNode
+          expr: NameNode
+""", self.treetypes(t))
+
+
+    def test_pass_eliminated(self):
+        t = self.run_pipeline([NormalizeTree(None)], u"pass")
         self.assertTrue(len(t.stats) == 0)
- 
-class TestWithTransform(object): # (TransformTest): # Disabled! 
- 
-    def test_simplified(self): 
-        t = self.run_pipeline([WithTransform(None)], u""" 
-        with x: 
-            y = z ** 3 
-        """) 
- 
-        self.assertCode(u""" 
- 
-        $0_0 = x 
-        $0_2 = $0_0.__exit__ 
-        $0_0.__enter__() 
-        $0_1 = True 
-        try: 
-            try: 
-                $1_0 = None 
-                y = z ** 3 
-            except: 
-                $0_1 = False 
-                if (not $0_2($1_0)): 
-                    raise 
-        finally: 
-            if $0_1: 
-                $0_2(None, None, None) 
- 
-        """, t) 
- 
-    def test_basic(self): 
-        t = self.run_pipeline([WithTransform(None)], u""" 
-        with x as y: 
-            y = z ** 3 
-        """) 
-        self.assertCode(u""" 
- 
-        $0_0 = x 
-        $0_2 = $0_0.__exit__ 
-        $0_3 = $0_0.__enter__() 
-        $0_1 = True 
-        try: 
-            try: 
-                $1_0 = None 
-                y = $0_3 
-                y = z ** 3 
-            except: 
-                $0_1 = False 
-                if (not $0_2($1_0)): 
-                    raise 
-        finally: 
-            if $0_1: 
-                $0_2(None, None, None) 
- 
-        """, t) 
- 
- 
-class TestInterpretCompilerDirectives(TransformTest): 
-    """ 
-    This class tests the parallel directives AST-rewriting and importing. 
-    """ 
- 
-    # Test the parallel directives (c)importing 
- 
-    import_code = u""" 
-        cimport cython.parallel 
-        cimport cython.parallel as par 
-        from cython cimport parallel as par2 
-        from cython cimport parallel 
- 
-        from cython.parallel cimport threadid as tid 
-        from cython.parallel cimport threadavailable as tavail 
-        from cython.parallel cimport prange 
-    """ 
- 
-    expected_directives_dict = { 
-        u'cython.parallel': u'cython.parallel', 
-        u'par': u'cython.parallel', 
-        u'par2': u'cython.parallel', 
-        u'parallel': u'cython.parallel', 
- 
-        u"tid": u"cython.parallel.threadid", 
-        u"tavail": u"cython.parallel.threadavailable", 
-        u"prange": u"cython.parallel.prange", 
-    } 
- 
- 
-    def setUp(self): 
-        super(TestInterpretCompilerDirectives, self).setUp() 
- 
-        compilation_options = Main.CompilationOptions(Main.default_options) 
-        ctx = compilation_options.create_context() 
- 
-        transform = InterpretCompilerDirectives(ctx, ctx.compiler_directives) 
-        transform.module_scope = Symtab.ModuleScope('__main__', None, ctx) 
-        self.pipeline = [transform] 
- 
-        self.debug_exception_on_error = DebugFlags.debug_exception_on_error 
- 
-    def tearDown(self): 
-        DebugFlags.debug_exception_on_error = self.debug_exception_on_error 
- 
-    def test_parallel_directives_cimports(self): 
-        self.run_pipeline(self.pipeline, self.import_code) 
-        parallel_directives = self.pipeline[0].parallel_directives 
-        self.assertEqual(parallel_directives, self.expected_directives_dict) 
- 
-    def test_parallel_directives_imports(self): 
-        self.run_pipeline(self.pipeline, 
-                          self.import_code.replace(u'cimport', u'import')) 
-        parallel_directives = self.pipeline[0].parallel_directives 
-        self.assertEqual(parallel_directives, self.expected_directives_dict) 
- 
- 
-# TODO: Re-enable once they're more robust. 
-if False: 
-    from Cython.Debugger import DebugWriter 
-    from Cython.Debugger.Tests.TestLibCython import DebuggerTestCase 
-else: 
-    # skip test, don't let it inherit unittest.TestCase 
-    DebuggerTestCase = object 
- 
- 
-class TestDebugTransform(DebuggerTestCase): 
- 
-    def elem_hasattrs(self, elem, attrs): 
-        return all(attr in elem.attrib for attr in attrs) 
- 
-    def test_debug_info(self): 
-        try: 
-            assert os.path.exists(self.debug_dest) 
- 
-            t = DebugWriter.etree.parse(self.debug_dest) 
-            # the xpath of the standard ElementTree is primitive, don't use 
-            # anything fancy 
-            L = list(t.find('/Module/Globals')) 
-            assert L 
-            xml_globals = dict((e.attrib['name'], e.attrib['type']) for e in L) 
-            self.assertEqual(len(L), len(xml_globals)) 
- 
-            L = list(t.find('/Module/Functions')) 
-            assert L 
-            xml_funcs = dict((e.attrib['qualified_name'], e) for e in L) 
-            self.assertEqual(len(L), len(xml_funcs)) 
- 
-            # test globals 
-            self.assertEqual('CObject', xml_globals.get('c_var')) 
-            self.assertEqual('PythonObject', xml_globals.get('python_var')) 
- 
-            # test functions 
-            funcnames = ('codefile.spam', 'codefile.ham', 'codefile.eggs', 
-                         'codefile.closure', 'codefile.inner') 
-            required_xml_attrs = 'name', 'cname', 'qualified_name' 
-            assert all(f in xml_funcs for f in funcnames) 
-            spam, ham, eggs = [xml_funcs[funcname] for funcname in funcnames] 
- 
-            self.assertEqual(spam.attrib['name'], 'spam') 
-            self.assertNotEqual('spam', spam.attrib['cname']) 
-            assert self.elem_hasattrs(spam, required_xml_attrs) 
- 
-            # test locals of functions 
-            spam_locals = list(spam.find('Locals')) 
-            assert spam_locals 
-            spam_locals.sort(key=lambda e: e.attrib['name']) 
-            names = [e.attrib['name'] for e in spam_locals] 
-            self.assertEqual(list('abcd'), names) 
-            assert self.elem_hasattrs(spam_locals[0], required_xml_attrs) 
- 
-            # test arguments of functions 
-            spam_arguments = list(spam.find('Arguments')) 
-            assert spam_arguments 
-            self.assertEqual(1, len(list(spam_arguments))) 
- 
-            # test step-into functions 
-            step_into = spam.find('StepIntoFunctions') 
-            spam_stepinto = [x.attrib['name'] for x in step_into] 
-            assert spam_stepinto 
-            self.assertEqual(2, len(spam_stepinto)) 
-            assert 'puts' in spam_stepinto 
-            assert 'some_c_function' in spam_stepinto 
-        except: 
-            f = open(self.debug_dest) 
-            try: 
-                print(f.read()) 
-            finally: 
-                f.close() 
-            raise 
- 
- 
- 
-if __name__ == "__main__": 
-    import unittest 
-    unittest.main() 
+
+class TestWithTransform(object): # (TransformTest): # Disabled!
+
+    def test_simplified(self):
+        t = self.run_pipeline([WithTransform(None)], u"""
+        with x:
+            y = z ** 3
+        """)
+
+        self.assertCode(u"""
+
+        $0_0 = x
+        $0_2 = $0_0.__exit__
+        $0_0.__enter__()
+        $0_1 = True
+        try:
+            try:
+                $1_0 = None
+                y = z ** 3
+            except:
+                $0_1 = False
+                if (not $0_2($1_0)):
+                    raise
+        finally:
+            if $0_1:
+                $0_2(None, None, None)
+
+        """, t)
+
+    def test_basic(self):
+        t = self.run_pipeline([WithTransform(None)], u"""
+        with x as y:
+            y = z ** 3
+        """)
+        self.assertCode(u"""
+
+        $0_0 = x
+        $0_2 = $0_0.__exit__
+        $0_3 = $0_0.__enter__()
+        $0_1 = True
+        try:
+            try:
+                $1_0 = None
+                y = $0_3
+                y = z ** 3
+            except:
+                $0_1 = False
+                if (not $0_2($1_0)):
+                    raise
+        finally:
+            if $0_1:
+                $0_2(None, None, None)
+
+        """, t)
+
+
+class TestInterpretCompilerDirectives(TransformTest):
+    """
+    This class tests the parallel directives AST-rewriting and importing.
+    """
+
+    # Test the parallel directives (c)importing
+
+    import_code = u"""
+        cimport cython.parallel
+        cimport cython.parallel as par
+        from cython cimport parallel as par2
+        from cython cimport parallel
+
+        from cython.parallel cimport threadid as tid
+        from cython.parallel cimport threadavailable as tavail
+        from cython.parallel cimport prange
+    """
+
+    expected_directives_dict = {
+        u'cython.parallel': u'cython.parallel',
+        u'par': u'cython.parallel',
+        u'par2': u'cython.parallel',
+        u'parallel': u'cython.parallel',
+
+        u"tid": u"cython.parallel.threadid",
+        u"tavail": u"cython.parallel.threadavailable",
+        u"prange": u"cython.parallel.prange",
+    }
+
+
+    def setUp(self):
+        super(TestInterpretCompilerDirectives, self).setUp()
+
+        compilation_options = Main.CompilationOptions(Main.default_options)
+        ctx = compilation_options.create_context()
+
+        transform = InterpretCompilerDirectives(ctx, ctx.compiler_directives)
+        transform.module_scope = Symtab.ModuleScope('__main__', None, ctx)
+        self.pipeline = [transform]
+
+        self.debug_exception_on_error = DebugFlags.debug_exception_on_error
+
+    def tearDown(self):
+        DebugFlags.debug_exception_on_error = self.debug_exception_on_error
+
+    def test_parallel_directives_cimports(self):
+        self.run_pipeline(self.pipeline, self.import_code)
+        parallel_directives = self.pipeline[0].parallel_directives
+        self.assertEqual(parallel_directives, self.expected_directives_dict)
+
+    def test_parallel_directives_imports(self):
+        self.run_pipeline(self.pipeline,
+                          self.import_code.replace(u'cimport', u'import'))
+        parallel_directives = self.pipeline[0].parallel_directives
+        self.assertEqual(parallel_directives, self.expected_directives_dict)
+
+
+# TODO: Re-enable once they're more robust.
+if False:
+    from Cython.Debugger import DebugWriter
+    from Cython.Debugger.Tests.TestLibCython import DebuggerTestCase
+else:
+    # skip test, don't let it inherit unittest.TestCase
+    DebuggerTestCase = object
+
+
+class TestDebugTransform(DebuggerTestCase):
+
+    def elem_hasattrs(self, elem, attrs):
+        return all(attr in elem.attrib for attr in attrs)
+
+    def test_debug_info(self):
+        try:
+            assert os.path.exists(self.debug_dest)
+
+            t = DebugWriter.etree.parse(self.debug_dest)
+            # the xpath of the standard ElementTree is primitive, don't use
+            # anything fancy
+            L = list(t.find('/Module/Globals'))
+            assert L
+            xml_globals = dict((e.attrib['name'], e.attrib['type']) for e in L)
+            self.assertEqual(len(L), len(xml_globals))
+
+            L = list(t.find('/Module/Functions'))
+            assert L
+            xml_funcs = dict((e.attrib['qualified_name'], e) for e in L)
+            self.assertEqual(len(L), len(xml_funcs))
+
+            # test globals
+            self.assertEqual('CObject', xml_globals.get('c_var'))
+            self.assertEqual('PythonObject', xml_globals.get('python_var'))
+
+            # test functions
+            funcnames = ('codefile.spam', 'codefile.ham', 'codefile.eggs',
+                         'codefile.closure', 'codefile.inner')
+            required_xml_attrs = 'name', 'cname', 'qualified_name'
+            assert all(f in xml_funcs for f in funcnames)
+            spam, ham, eggs = [xml_funcs[funcname] for funcname in funcnames]
+
+            self.assertEqual(spam.attrib['name'], 'spam')
+            self.assertNotEqual('spam', spam.attrib['cname'])
+            assert self.elem_hasattrs(spam, required_xml_attrs)
+
+            # test locals of functions
+            spam_locals = list(spam.find('Locals'))
+            assert spam_locals
+            spam_locals.sort(key=lambda e: e.attrib['name'])
+            names = [e.attrib['name'] for e in spam_locals]
+            self.assertEqual(list('abcd'), names)
+            assert self.elem_hasattrs(spam_locals[0], required_xml_attrs)
+
+            # test arguments of functions
+            spam_arguments = list(spam.find('Arguments'))
+            assert spam_arguments
+            self.assertEqual(1, len(list(spam_arguments)))
+
+            # test step-into functions
+            step_into = spam.find('StepIntoFunctions')
+            spam_stepinto = [x.attrib['name'] for x in step_into]
+            assert spam_stepinto
+            self.assertEqual(2, len(spam_stepinto))
+            assert 'puts' in spam_stepinto
+            assert 'some_c_function' in spam_stepinto
+        except:
+            f = open(self.debug_dest)
+            try:
+                print(f.read())
+            finally:
+                f.close()
+            raise
+
+
+
+if __name__ == "__main__":
+    import unittest
+    unittest.main()