Use subTests for easier test investigation.

* Moved test set up to module scope
* Use subTests decorator to inject compiler parameter into tests
* Introduced new compiler parameter to assert* family of methods
* Used functools to maintain the same API for the assert* methods where applicable

Author: vjabuilds

Lib/test/test_codeop.py

@@ -4,33 +4,31 @@
 """
 import unittest
 import warnings
-from test.support import warnings_helper
+from test.support import subTests, warnings_helper
 from textwrap import dedent
+import functools
 
 from codeop import compile_command, CommandCompiler, Compile
 from codeop import PyCF_DONT_IMPLY_DEDENT, PyCF_ONLY_AST
 import ast
 
 
-class CodeopTests(unittest.TestCase):
+WRAPPING_COMPILERS = [compile_command, CommandCompiler()]
+RAW_COMPILERS = [Compile()]
+COMPILERS = WRAPPING_COMPILERS + RAW_COMPILERS
 
-    def setUp(self):
-        self.wrapping_compilers = [compile_command, CommandCompiler()]
-        self.raw_compilers = [Compile()]
-        self.compilers = self.wrapping_compilers + self.raw_compilers
 
-    def assertValid(self, str, symbol='single'):
+class CodeopTests(unittest.TestCase):
+    def assertValid(self, str, symbol='single', *, compiler):
         '''succeed iff str is a valid piece of code'''
-        for compiler in self.compilers:
-            expected = compile(str, "<input>", symbol, PyCF_DONT_IMPLY_DEDENT)
-            self.assertEqual(compiler(str, "<input>", symbol), expected)
+        expected = compile(str, "<input>", symbol, PyCF_DONT_IMPLY_DEDENT)
+        self.assertEqual(compiler(str, "<input>", symbol), expected)
 
-    def assertIncomplete(self, str, symbol='single'):
+    def assertIncomplete(self, str, symbol='single', *, compiler):
         '''succeed iff str is the start of a valid piece of code'''
-        for compiler in self.wrapping_compilers:
+        if compiler in WRAPPING_COMPILERS:
             self.assertEqual(compiler(str, "<input>", symbol=symbol), None)
-
-        for compiler in self.raw_compilers:
+        else:
             # Compile has should raise like built-in compile
             with self.assertRaises(SyntaxError) as cm_original_error:
                 compile(str, "<input>", symbol, compiler.flags)
@@ -42,29 +40,28 @@ def assertIncomplete(self, str, symbol='single'):
                 cm_wrapped_error.exception.args
             )
 
-    def assertInvalid(self, str, symbol='single', is_syntax=1):
+    def assertInvalid(self, str, symbol='single', is_syntax=1, *, compiler):
         '''succeed iff str is the start of an invalid piece of code'''
-        for compiler in self.compilers:
-            try:
-                compiler(str,"<input>", symbol=symbol)
-                self.fail("No exception raised for invalid code")
-            except SyntaxError:
-                self.assertTrue(is_syntax)
-            except OverflowError:
-                self.assertTrue(not is_syntax)
-
-    def test_valid(self):
-        av = self.assertValid
-
-        # special case
-        for compiler in self.wrapping_compilers:
-            self.assertEqual(
-                compiler("", "<input>", 'single'),
-                compile("pass", "<input>", 'single', PyCF_DONT_IMPLY_DEDENT))
-            self.assertEqual(
-                compiler("\n", "<input>", 'single'),
-                compile("pass", "<input>", 'single', PyCF_DONT_IMPLY_DEDENT))
-
+        try:
+            compiler(str,"<input>", symbol=symbol)
+            self.fail("No exception raised for invalid code")
+        except SyntaxError:
+            self.assertTrue(is_syntax)
+        except OverflowError:
+            self.assertTrue(not is_syntax)
+
+    @subTests('compiler', WRAPPING_COMPILERS)
+    def test_empty(self, compiler):
+        self.assertEqual(
+            compiler("", "<input>", 'single'),
+            compile("pass", "<input>", 'single', PyCF_DONT_IMPLY_DEDENT))
+        self.assertEqual(
+            compiler("\n", "<input>", 'single'),
+            compile("pass", "<input>", 'single', PyCF_DONT_IMPLY_DEDENT))
+
+    @subTests('compiler', COMPILERS)
+    def test_valid(self, compiler):
+        av = functools.partial(self.assertValid, compiler=compiler)
         av("a = 1")
         av("\na = 1")
         av("a = 1\n")
@@ -116,8 +113,9 @@ def test_valid(self):
         av("def f():\n pass\n#foo\n")
         av("@a.b.c\ndef f():\n pass\n")
 
-    def test_incomplete(self):
-        ai = self.assertIncomplete
+    @subTests('compiler', COMPILERS)
+    def test_incomplete(self, compiler):
+        ai = functools.partial(self.assertIncomplete, compiler=compiler)
 
         ai("(a **")
         ai("(a,b,")
@@ -250,8 +248,9 @@ def test_incomplete(self):
         ai('a = f"""')
         ai('a = \\')
 
-    def test_invalid(self):
-        ai = self.assertInvalid
+    @subTests('compiler', COMPILERS)
+    def test_invalid(self, compiler):
+        ai = functools.partial(self.assertInvalid, compiler=compiler)
         ai("a b")
 
         ai("a @")
@@ -287,103 +286,104 @@ def test_invalid(self):
 
         ai("[i for i in range(10)] = (1, 2, 3)")
 
-    def test_invalid_exec(self):
-        ai = self.assertInvalid
+    @subTests('compiler', COMPILERS)
+    def test_invalid_exec(self, compiler):
+        ai = functools.partial(self.assertInvalid, compiler=compiler)
         ai("raise = 4", symbol="exec")
         ai('def a-b', symbol='exec')
         ai('await?', symbol='exec')
         ai('=!=', symbol='exec')
         ai('a await raise b', symbol='exec')
         ai('a await raise b?+1', symbol='exec')
 
-    def test_filename(self):
-        for compiler in self.compilers:
-            self.assertEqual(
-                compiler("a = 1\n", "abc", "single").co_filename,
-                compile("a = 1\n", "abc", 'single').co_filename
-            )
-            self.assertNotEqual(
-                compiler("a = 1\n", "abc", "single").co_filename,
-                compile("a = 1\n", "def", 'single').co_filename
-            )
+    @subTests('compiler', COMPILERS)
+    def test_filename(self, compiler):
+        self.assertEqual(
+            compiler("a = 1\n", "abc", "single").co_filename,
+            compile("a = 1\n", "abc", 'single').co_filename
+        )
+        self.assertNotEqual(
+            compiler("a = 1\n", "abc", "single").co_filename,
+            compile("a = 1\n", "def", 'single').co_filename
+        )
 
     def assertReturnsModule(self, code, compiler):
         retval = compiler(code, "<input>", 'exec', PyCF_ONLY_AST)
         self.assertIsInstance(retval, ast.Module)
 
-    def test_ast_return_value(self):
-        for compiler in self.raw_compilers:
-            validate_ast = self.assertReturnsModule
-            validate_ast("x = 5", compiler)
-            validate_ast("\nx = 5", compiler)
-            validate_ast("x = 5\n", compiler)
-            validate_ast("x = 5\n\n", compiler)
-            validate_ast("\n\nx = 5\n\n", compiler)
-
-    def test_warning(self):
+    @subTests('compiler', RAW_COMPILERS)
+    def test_ast_return_value(self, compiler):
+        validate_ast = self.assertReturnsModule
+        validate_ast("x = 5", compiler)
+        validate_ast("\nx = 5", compiler)
+        validate_ast("x = 5\n", compiler)
+        validate_ast("x = 5\n\n", compiler)
+        validate_ast("\n\nx = 5\n\n", compiler)
+
+    @subTests('compiler', COMPILERS)
+    def test_warning(self, compiler):
         # Test that the warning is only returned once.
-        for compiler in self.compilers:
-            with warnings_helper.check_warnings(
-                    ('"is" with \'str\' literal', SyntaxWarning),
-                    ('"\\\\e" is an invalid escape sequence', SyntaxWarning),
-                    ) as w:
-                compiler(r"'\e' is 0", "<input>", "single")
-            self.assertEqual(len(w.warnings), 2)
-
-            # bpo-41520: check SyntaxWarning treated as an SyntaxError
-            with warnings.catch_warnings(), self.assertRaises(SyntaxError):
-                warnings.simplefilter('error', SyntaxWarning)
-                compiler('1 is 1', "<input>", 'exec')
-
-            # Check SyntaxWarning treated as an SyntaxError
-            with warnings.catch_warnings(), self.assertRaises(SyntaxError):
-                warnings.simplefilter('error', SyntaxWarning)
-                compiler(r"'\e'", "<input>", 'exec')
-
-    def test_incomplete_warning(self):
-        code = "'\\e' + ("
-        for compiler in self.wrapping_compilers:
-            with warnings.catch_warnings(record=True) as w:
-                warnings.simplefilter('always')
-            compiler(code)
-            self.assertEqual(w, [])
-        for compiler in self.raw_compilers:
-            warnings_cm = warnings_helper.check_warnings(
-                ('"\\\\e" is an invalid esceape sequence', SyntaxWarning)
-            )
-            with self.assertRaises(SyntaxError), warnings_cm as w:
-                compiler = self.compilers[-1]
-                compiler(code, "<input>", 'single')
-            self.assertEqual(len(w.warnings), 1)
-
-    def test_invalid_warning(self):
+        with warnings_helper.check_warnings(
+                ('"is" with \'str\' literal', SyntaxWarning),
+                ('"\\\\e" is an invalid escape sequence', SyntaxWarning),
+                ) as w:
+            compiler(r"'\e' is 0", "<input>", "single")
+        self.assertEqual(len(w.warnings), 2)
+
+        # bpo-41520: check SyntaxWarning treated as an SyntaxError
+        with warnings.catch_warnings(), self.assertRaises(SyntaxError):
+            warnings.simplefilter('error', SyntaxWarning)
+            compiler('1 is 1', "<input>", 'exec')
+
+        # Check SyntaxWarning treated as an SyntaxError
+        with warnings.catch_warnings(), self.assertRaises(SyntaxError):
+            warnings.simplefilter('error', SyntaxWarning)
+            compiler(r"'\e'", "<input>", 'exec')
+
+    @subTests('compiler', WRAPPING_COMPILERS)
+    def test_incomplete_warning(self, compiler):
         with warnings.catch_warnings(record=True) as w:
             warnings.simplefilter('always')
-            self.assertInvalid("'\\e' 1")
-        self.assertEqual(len(w), len(self.compilers))
+        compiler("'\\e' + (")
+        self.assertEqual(w, [])
+
+    @subTests('compiler', RAW_COMPILERS)
+    def test_raw_raises_error(self, compiler):
+        warnings_cm = warnings_helper.check_warnings(
+            ('"\\\\e" is an invalid esceape sequence', SyntaxWarning)
+        )
+        with self.assertRaises(SyntaxError), warnings_cm as w:
+            compiler("'\\e' + (", "<input>", 'single')
+        self.assertEqual(len(w.warnings), 1)
+
+    @subTests('compiler', COMPILERS)
+    def test_invalid_warning(self, compiler):
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always')
+            self.assertInvalid("'\\e' 1", compiler=compiler)
+        self.assertEqual(len(w), 1)
         for warning in w:
             self.assertEqual(warning.category, SyntaxWarning)
             self.assertRegex(str(warning), 'invalid escape sequence')
             self.assertEqual(warning.filename, '<input>')
 
-    def assertSyntaxErrorMatches(self, code, message):
-        with self.subTest(code):
-            for compiler in self.compilers:
-                with self.assertRaisesRegex(SyntaxError, message):
-                    compiler(code, "<input>", 'exec')
-
-    def test_syntax_errors(self):
-        self.assertSyntaxErrorMatches(
-            dedent("""\
+    @subTests('compiler', COMPILERS)
+    def test_syntax_errors(self, compiler):
+        code = dedent("""\
                 def foo(x,x):
                    pass
-            """), "duplicate parameter 'x' in function definition")
-
-    def test_future_imports(self):
-        for compiler in self.raw_compilers:
-            original_flags = compiler.flags
-            compiler('from __future__ import annotations', "<input>", 'single')
-            self.assertGreater(compiler.flags, original_flags)
+            """)
+        message = "duplicate parameter 'x' in function definition"
+        with self.assertRaisesRegex(SyntaxError, message):
+            compiler(code, "<input>", 'exec')
+
+    @subTests('compiler', RAW_COMPILERS)
+    def test_future_imports(self, compiler):
+        original_flags = compiler.flags
+        compiler('from __future__ import annotations', "<input>", 'single')
+        self.assertGreater(compiler.flags, original_flags)
+        # reset flags to ensure test has no side-effects
+        compiler.flags = original_flags
 
 
 if __name__ == "__main__":