| """Tests for scripts in the Tools directory. |
| |
| This file contains regression tests for some of the scripts found in the |
| Tools directory of a Python checkout or tarball, such as reindent.py. |
| """ |
| |
| import os |
| import runpy |
| import sys |
| import unittest |
| import shutil |
| from cStringIO import StringIO |
| import subprocess |
| import sysconfig |
| import tempfile |
| import textwrap |
| from test import test_support |
| from test.script_helper import assert_python_ok, temp_dir |
| |
| if not sysconfig.is_python_build(): |
| # XXX some installers do contain the tools, should we detect that |
| # and run the tests in that case too? |
| raise unittest.SkipTest('test irrelevant for an installed Python') |
| |
| basepath = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), |
| 'Tools') |
| scriptsdir = os.path.join(basepath, 'scripts') |
| |
| |
| class ReindentTests(unittest.TestCase): |
| script = os.path.join(scriptsdir, 'reindent.py') |
| |
| def test_noargs(self): |
| assert_python_ok(self.script) |
| |
| def test_help(self): |
| rc, out, err = assert_python_ok(self.script, '-h') |
| self.assertEqual(out, b'') |
| self.assertGreater(err, b'') |
| |
| |
| class PindentTests(unittest.TestCase): |
| script = os.path.join(scriptsdir, 'pindent.py') |
| |
| def assertFileEqual(self, fn1, fn2): |
| with open(fn1) as f1, open(fn2) as f2: |
| self.assertEqual(f1.readlines(), f2.readlines()) |
| |
| def pindent(self, source, *args): |
| proc = subprocess.Popen( |
| (sys.executable, self.script) + args, |
| stdin=subprocess.PIPE, stdout=subprocess.PIPE, |
| universal_newlines=True) |
| out, err = proc.communicate(source) |
| self.assertIsNone(err) |
| return out |
| |
| def lstriplines(self, data): |
| return '\n'.join(line.lstrip() for line in data.splitlines()) + '\n' |
| |
| def test_selftest(self): |
| self.maxDiff = None |
| with temp_dir() as directory: |
| data_path = os.path.join(directory, '_test.py') |
| with open(self.script) as f: |
| closed = f.read() |
| with open(data_path, 'w') as f: |
| f.write(closed) |
| |
| rc, out, err = assert_python_ok(self.script, '-d', data_path) |
| self.assertEqual(out, b'') |
| self.assertEqual(err, b'') |
| backup = data_path + '~' |
| self.assertTrue(os.path.exists(backup)) |
| with open(backup) as f: |
| self.assertEqual(f.read(), closed) |
| with open(data_path) as f: |
| clean = f.read() |
| compile(clean, '_test.py', 'exec') |
| self.assertEqual(self.pindent(clean, '-c'), closed) |
| self.assertEqual(self.pindent(closed, '-d'), clean) |
| |
| rc, out, err = assert_python_ok(self.script, '-c', data_path) |
| self.assertEqual(out, b'') |
| self.assertEqual(err, b'') |
| with open(backup) as f: |
| self.assertEqual(f.read(), clean) |
| with open(data_path) as f: |
| self.assertEqual(f.read(), closed) |
| |
| broken = self.lstriplines(closed) |
| with open(data_path, 'w') as f: |
| f.write(broken) |
| rc, out, err = assert_python_ok(self.script, '-r', data_path) |
| self.assertEqual(out, b'') |
| self.assertEqual(err, b'') |
| with open(backup) as f: |
| self.assertEqual(f.read(), broken) |
| with open(data_path) as f: |
| indented = f.read() |
| compile(indented, '_test.py', 'exec') |
| self.assertEqual(self.pindent(broken, '-r'), indented) |
| |
| def pindent_test(self, clean, closed): |
| self.assertEqual(self.pindent(clean, '-c'), closed) |
| self.assertEqual(self.pindent(closed, '-d'), clean) |
| broken = self.lstriplines(closed) |
| self.assertEqual(self.pindent(broken, '-r', '-e', '-s', '4'), closed) |
| |
| def test_statements(self): |
| clean = textwrap.dedent("""\ |
| if a: |
| pass |
| |
| if a: |
| pass |
| else: |
| pass |
| |
| if a: |
| pass |
| elif: |
| pass |
| else: |
| pass |
| |
| while a: |
| break |
| |
| while a: |
| break |
| else: |
| pass |
| |
| for i in a: |
| break |
| |
| for i in a: |
| break |
| else: |
| pass |
| |
| try: |
| pass |
| finally: |
| pass |
| |
| try: |
| pass |
| except TypeError: |
| pass |
| except ValueError: |
| pass |
| else: |
| pass |
| |
| try: |
| pass |
| except TypeError: |
| pass |
| except ValueError: |
| pass |
| finally: |
| pass |
| |
| with a: |
| pass |
| |
| class A: |
| pass |
| |
| def f(): |
| pass |
| """) |
| |
| closed = textwrap.dedent("""\ |
| if a: |
| pass |
| # end if |
| |
| if a: |
| pass |
| else: |
| pass |
| # end if |
| |
| if a: |
| pass |
| elif: |
| pass |
| else: |
| pass |
| # end if |
| |
| while a: |
| break |
| # end while |
| |
| while a: |
| break |
| else: |
| pass |
| # end while |
| |
| for i in a: |
| break |
| # end for |
| |
| for i in a: |
| break |
| else: |
| pass |
| # end for |
| |
| try: |
| pass |
| finally: |
| pass |
| # end try |
| |
| try: |
| pass |
| except TypeError: |
| pass |
| except ValueError: |
| pass |
| else: |
| pass |
| # end try |
| |
| try: |
| pass |
| except TypeError: |
| pass |
| except ValueError: |
| pass |
| finally: |
| pass |
| # end try |
| |
| with a: |
| pass |
| # end with |
| |
| class A: |
| pass |
| # end class A |
| |
| def f(): |
| pass |
| # end def f |
| """) |
| self.pindent_test(clean, closed) |
| |
| def test_multilevel(self): |
| clean = textwrap.dedent("""\ |
| def foobar(a, b): |
| if a == b: |
| a = a+1 |
| elif a < b: |
| b = b-1 |
| if b > a: a = a-1 |
| else: |
| print 'oops!' |
| """) |
| closed = textwrap.dedent("""\ |
| def foobar(a, b): |
| if a == b: |
| a = a+1 |
| elif a < b: |
| b = b-1 |
| if b > a: a = a-1 |
| # end if |
| else: |
| print 'oops!' |
| # end if |
| # end def foobar |
| """) |
| self.pindent_test(clean, closed) |
| |
| def test_preserve_indents(self): |
| clean = textwrap.dedent("""\ |
| if a: |
| if b: |
| pass |
| """) |
| closed = textwrap.dedent("""\ |
| if a: |
| if b: |
| pass |
| # end if |
| # end if |
| """) |
| self.assertEqual(self.pindent(clean, '-c'), closed) |
| self.assertEqual(self.pindent(closed, '-d'), clean) |
| broken = self.lstriplines(closed) |
| self.assertEqual(self.pindent(broken, '-r', '-e', '-s', '9'), closed) |
| clean = textwrap.dedent("""\ |
| if a: |
| \tif b: |
| \t\tpass |
| """) |
| closed = textwrap.dedent("""\ |
| if a: |
| \tif b: |
| \t\tpass |
| \t# end if |
| # end if |
| """) |
| self.assertEqual(self.pindent(clean, '-c'), closed) |
| self.assertEqual(self.pindent(closed, '-d'), clean) |
| broken = self.lstriplines(closed) |
| self.assertEqual(self.pindent(broken, '-r'), closed) |
| |
| def test_escaped_newline(self): |
| clean = textwrap.dedent("""\ |
| class\\ |
| \\ |
| A: |
| def\ |
| \\ |
| f: |
| pass |
| """) |
| closed = textwrap.dedent("""\ |
| class\\ |
| \\ |
| A: |
| def\ |
| \\ |
| f: |
| pass |
| # end def f |
| # end class A |
| """) |
| self.assertEqual(self.pindent(clean, '-c'), closed) |
| self.assertEqual(self.pindent(closed, '-d'), clean) |
| |
| def test_empty_line(self): |
| clean = textwrap.dedent("""\ |
| if a: |
| |
| pass |
| """) |
| closed = textwrap.dedent("""\ |
| if a: |
| |
| pass |
| # end if |
| """) |
| self.pindent_test(clean, closed) |
| |
| def test_oneline(self): |
| clean = textwrap.dedent("""\ |
| if a: pass |
| """) |
| closed = textwrap.dedent("""\ |
| if a: pass |
| # end if |
| """) |
| self.pindent_test(clean, closed) |
| |
| |
| class FixcidTests(unittest.TestCase): |
| def test_parse_strings(self): |
| old1 = 'int xx = "xx\\"xx"[xx];\n' |
| old2 = "int xx = 'x\\'xx' + xx;\n" |
| output = self.run_script(old1 + old2) |
| new1 = 'int yy = "xx\\"xx"[yy];\n' |
| new2 = "int yy = 'x\\'xx' + yy;\n" |
| self.assertMultiLineEqual(output, |
| "1\n" |
| "< {old1}" |
| "> {new1}" |
| "{new1}" |
| "2\n" |
| "< {old2}" |
| "> {new2}" |
| "{new2}".format(old1=old1, old2=old2, new1=new1, new2=new2) |
| ) |
| |
| def test_alter_comments(self): |
| output = self.run_script( |
| substfile= |
| "xx yy\n" |
| "*aa bb\n", |
| args=("-c", "-",), |
| input= |
| "/* xx altered */\n" |
| "int xx;\n" |
| "/* aa unaltered */\n" |
| "int aa;\n", |
| ) |
| self.assertMultiLineEqual(output, |
| "1\n" |
| "< /* xx altered */\n" |
| "> /* yy altered */\n" |
| "/* yy altered */\n" |
| "2\n" |
| "< int xx;\n" |
| "> int yy;\n" |
| "int yy;\n" |
| "/* aa unaltered */\n" |
| "4\n" |
| "< int aa;\n" |
| "> int bb;\n" |
| "int bb;\n" |
| ) |
| |
| def test_directory(self): |
| os.mkdir(test_support.TESTFN) |
| self.addCleanup(test_support.rmtree, test_support.TESTFN) |
| c_filename = os.path.join(test_support.TESTFN, "file.c") |
| with open(c_filename, "w") as file: |
| file.write("int xx;\n") |
| with open(os.path.join(test_support.TESTFN, "file.py"), "w") as file: |
| file.write("xx = 'unaltered'\n") |
| script = os.path.join(scriptsdir, "fixcid.py") |
| output = self.run_script(args=(test_support.TESTFN,)) |
| self.assertMultiLineEqual(output, |
| "{}:\n" |
| "1\n" |
| '< int xx;\n' |
| '> int yy;\n'.format(c_filename) |
| ) |
| |
| def run_script(self, input="", args=("-",), substfile="xx yy\n"): |
| substfilename = test_support.TESTFN + ".subst" |
| with open(substfilename, "w") as file: |
| file.write(substfile) |
| self.addCleanup(test_support.unlink, substfilename) |
| |
| argv = ["fixcid.py", "-s", substfilename] + list(args) |
| script = os.path.join(scriptsdir, "fixcid.py") |
| with test_support.swap_attr(sys, "argv", argv), \ |
| test_support.swap_attr(sys, "stdin", StringIO(input)), \ |
| test_support.captured_stdout() as output: |
| try: |
| runpy.run_path(script, run_name="__main__") |
| except SystemExit as exit: |
| self.assertEqual(exit.code, 0) |
| return output.getvalue() |
| |
| |
| def test_main(): |
| test_support.run_unittest(*[obj for obj in globals().values() |
| if isinstance(obj, type)]) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |