Spaces:
Build error
Build error
| from __future__ import absolute_import | |
| import os | |
| import unittest | |
| import tempfile | |
| from .Compiler import Errors | |
| from .CodeWriter import CodeWriter | |
| from .Compiler.TreeFragment import TreeFragment, strip_common_indent | |
| from .Compiler.Visitor import TreeVisitor, VisitorTransform | |
| from .Compiler import TreePath | |
| class NodeTypeWriter(TreeVisitor): | |
| def __init__(self): | |
| super(NodeTypeWriter, self).__init__() | |
| self._indents = 0 | |
| self.result = [] | |
| def visit_Node(self, node): | |
| if not self.access_path: | |
| name = u"(root)" | |
| else: | |
| tip = self.access_path[-1] | |
| if tip[2] is not None: | |
| name = u"%s[%d]" % tip[1:3] | |
| else: | |
| name = tip[1] | |
| self.result.append(u" " * self._indents + | |
| u"%s: %s" % (name, node.__class__.__name__)) | |
| self._indents += 1 | |
| self.visitchildren(node) | |
| self._indents -= 1 | |
| def treetypes(root): | |
| """Returns a string representing the tree by class names. | |
| There's a leading and trailing whitespace so that it can be | |
| compared by simple string comparison while still making test | |
| cases look ok.""" | |
| w = NodeTypeWriter() | |
| w.visit(root) | |
| return u"\n".join([u""] + w.result + [u""]) | |
| class CythonTest(unittest.TestCase): | |
| def setUp(self): | |
| self.listing_file = Errors.listing_file | |
| self.echo_file = Errors.echo_file | |
| Errors.listing_file = Errors.echo_file = None | |
| def tearDown(self): | |
| Errors.listing_file = self.listing_file | |
| Errors.echo_file = self.echo_file | |
| def assertLines(self, expected, result): | |
| "Checks that the given strings or lists of strings are equal line by line" | |
| if not isinstance(expected, list): | |
| expected = expected.split(u"\n") | |
| if not isinstance(result, list): | |
| result = result.split(u"\n") | |
| for idx, (expected_line, result_line) in enumerate(zip(expected, result)): | |
| self.assertEqual(expected_line, result_line, | |
| "Line %d:\nExp: %s\nGot: %s" % (idx, expected_line, result_line)) | |
| self.assertEqual(len(expected), len(result), | |
| "Unmatched lines. Got:\n%s\nExpected:\n%s" % ("\n".join(expected), u"\n".join(result))) | |
| def codeToLines(self, tree): | |
| writer = CodeWriter() | |
| writer.write(tree) | |
| return writer.result.lines | |
| def codeToString(self, tree): | |
| return "\n".join(self.codeToLines(tree)) | |
| def assertCode(self, expected, result_tree): | |
| result_lines = self.codeToLines(result_tree) | |
| expected_lines = strip_common_indent(expected.split("\n")) | |
| for idx, (line, expected_line) in enumerate(zip(result_lines, expected_lines)): | |
| self.assertEqual(expected_line, line, | |
| "Line %d:\nGot: %s\nExp: %s" % (idx, line, expected_line)) | |
| self.assertEqual(len(result_lines), len(expected_lines), | |
| "Unmatched lines. Got:\n%s\nExpected:\n%s" % ("\n".join(result_lines), expected)) | |
| def assertNodeExists(self, path, result_tree): | |
| self.assertNotEqual(TreePath.find_first(result_tree, path), None, | |
| "Path '%s' not found in result tree" % path) | |
| def fragment(self, code, pxds=None, pipeline=None): | |
| "Simply create a tree fragment using the name of the test-case in parse errors." | |
| if pxds is None: | |
| pxds = {} | |
| if pipeline is None: | |
| pipeline = [] | |
| name = self.id() | |
| if name.startswith("__main__."): | |
| name = name[len("__main__."):] | |
| name = name.replace(".", "_") | |
| return TreeFragment(code, name, pxds, pipeline=pipeline) | |
| def treetypes(self, root): | |
| return treetypes(root) | |
| def should_fail(self, func, exc_type=Exception): | |
| """Calls "func" and fails if it doesn't raise the right exception | |
| (any exception by default). Also returns the exception in question. | |
| """ | |
| try: | |
| func() | |
| self.fail("Expected an exception of type %r" % exc_type) | |
| except exc_type as e: | |
| self.assertTrue(isinstance(e, exc_type)) | |
| return e | |
| def should_not_fail(self, func): | |
| """Calls func and succeeds if and only if no exception is raised | |
| (i.e. converts exception raising into a failed testcase). Returns | |
| the return value of func.""" | |
| try: | |
| return func() | |
| except Exception as exc: | |
| self.fail(str(exc)) | |
| class TransformTest(CythonTest): | |
| """ | |
| Utility base class for transform unit tests. It is based around constructing | |
| test trees (either explicitly or by parsing a Cython code string); running | |
| the transform, serialize it using a customized Cython serializer (with | |
| special markup for nodes that cannot be represented in Cython), | |
| and do a string-comparison line-by-line of the result. | |
| To create a test case: | |
| - Call run_pipeline. The pipeline should at least contain the transform you | |
| are testing; pyx should be either a string (passed to the parser to | |
| create a post-parse tree) or a node representing input to pipeline. | |
| The result will be a transformed result. | |
| - Check that the tree is correct. If wanted, assertCode can be used, which | |
| takes a code string as expected, and a ModuleNode in result_tree | |
| (it serializes the ModuleNode to a string and compares line-by-line). | |
| All code strings are first stripped for whitespace lines and then common | |
| indentation. | |
| Plans: One could have a pxd dictionary parameter to run_pipeline. | |
| """ | |
| def run_pipeline(self, pipeline, pyx, pxds=None): | |
| if pxds is None: | |
| pxds = {} | |
| tree = self.fragment(pyx, pxds).root | |
| # Run pipeline | |
| for T in pipeline: | |
| tree = T(tree) | |
| return tree | |
| class TreeAssertVisitor(VisitorTransform): | |
| # actually, a TreeVisitor would be enough, but this needs to run | |
| # as part of the compiler pipeline | |
| def visit_CompilerDirectivesNode(self, node): | |
| directives = node.directives | |
| if 'test_assert_path_exists' in directives: | |
| for path in directives['test_assert_path_exists']: | |
| if TreePath.find_first(node, path) is None: | |
| Errors.error( | |
| node.pos, | |
| "Expected path '%s' not found in result tree" % path) | |
| if 'test_fail_if_path_exists' in directives: | |
| for path in directives['test_fail_if_path_exists']: | |
| if TreePath.find_first(node, path) is not None: | |
| Errors.error( | |
| node.pos, | |
| "Unexpected path '%s' found in result tree" % path) | |
| self.visitchildren(node) | |
| return node | |
| visit_Node = VisitorTransform.recurse_to_children | |
| def unpack_source_tree(tree_file, dir=None): | |
| if dir is None: | |
| dir = tempfile.mkdtemp() | |
| header = [] | |
| cur_file = None | |
| f = open(tree_file) | |
| try: | |
| lines = f.readlines() | |
| finally: | |
| f.close() | |
| del f | |
| try: | |
| for line in lines: | |
| if line[:5] == '#####': | |
| filename = line.strip().strip('#').strip().replace('/', os.path.sep) | |
| path = os.path.join(dir, filename) | |
| if not os.path.exists(os.path.dirname(path)): | |
| os.makedirs(os.path.dirname(path)) | |
| if cur_file is not None: | |
| f, cur_file = cur_file, None | |
| f.close() | |
| cur_file = open(path, 'w') | |
| elif cur_file is not None: | |
| cur_file.write(line) | |
| elif line.strip() and not line.lstrip().startswith('#'): | |
| if line.strip() not in ('"""', "'''"): | |
| header.append(line) | |
| finally: | |
| if cur_file is not None: | |
| cur_file.close() | |
| return dir, ''.join(header) | |