gh-97669: Remove outdated example scripts (#97675)

Remove outdated example scripts of the Tools/scripts/ directory. A
copy can be found in the old-demos project:
https://github.com/gvanrossum/old-demos

Removed scripts (39):

* byext.py
* byteyears.py
* cleanfuture.py
* copytime.py
* crlf.py
* db2pickle.py
* dutree.doc
* dutree.py
* find-uname.py
* find_recursionlimit.py
* finddiv.py
* findlinksto.py
* findnocoding.py
* fixcid.py
* fixdiv.py
* fixheader.py
* fixnotice.py
* fixps.py
* get-remote-certificate.py
* google.py
* highlight.py
* ifdef.py
* import_diagnostics.py
* lfcr.py
* linktree.py
* lll.py
* mailerdaemon.py
* make_ctype.py
* mkreal.py
* objgraph.py
* pdeps.py
* pickle2db.py
* pindent.py
* pysource.py
* reindent-rst.py
* rgrep.py
* suff.py
* texi2html.py
* which.py

Changes:

* Remove test_fixcid, test_lll, test_pdeps and test_pindent
  of test.test_tools.
* Remove get-remote-certificate.py changelog entry, since the script
  was removed.

Note: there is a copy of crlf.py in Lib/test/test_lib2to3/data/.

4 files changed, 0 insertions, 506 deletions

diff --git a/Lib/test/test_tools/test_fixcid.py b/Lib/test/test_tools/test_fixcid.py
deleted file mode 100644
index a72f74b..0000000
--- a/Lib/test/test_tools/test_fixcid.py
+++ /dev/null
@@ -1,94 +0,0 @@
-'''Test Tools/scripts/fixcid.py.'''
-
-from io import StringIO
-import os, os.path
-import runpy
-import sys
-from test import support
-from test.support import os_helper
-from test.test_tools import skip_if_missing, scriptsdir
-import unittest
-
-skip_if_missing()
-
-class Test(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(os_helper.TESTFN)
-        self.addCleanup(os_helper.rmtree, os_helper.TESTFN)
-        c_filename = os.path.join(os_helper.TESTFN, "file.c")
-        with open(c_filename, "w", encoding="utf-8") as file:
-            file.write("int xx;\n")
-        with open(os.path.join(os_helper.TESTFN, "file.py"), "w",
-                  encoding="utf-8") as file:
-            file.write("xx = 'unaltered'\n")
-        script = os.path.join(scriptsdir, "fixcid.py")
-        output = self.run_script(args=(os_helper.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 = os_helper.TESTFN + ".subst"
-        with open(substfilename, "w", encoding="utf-8") as file:
-            file.write(substfile)
-        self.addCleanup(os_helper.unlink, substfilename)
-
-        argv = ["fixcid.py", "-s", substfilename] + list(args)
-        script = os.path.join(scriptsdir, "fixcid.py")
-        with support.swap_attr(sys, "argv", argv), \
-                support.swap_attr(sys, "stdin", StringIO(input)), \
-                support.captured_stdout() as output, \
-                support.captured_stderr():
-            try:
-                runpy.run_path(script, run_name="__main__")
-            except SystemExit as exit:
-                self.assertEqual(exit.code, 0)
-        return output.getvalue()
diff --git a/Lib/test/test_tools/test_lll.py b/Lib/test/test_tools/test_lll.py
deleted file mode 100644
index 6eeb96e..0000000
--- a/Lib/test/test_tools/test_lll.py
+++ /dev/null
@@ -1,41 +0,0 @@
-"""Tests for the lll script in the Tools/script directory."""
-
-import os
-import tempfile
-from test import support
-from test.support import os_helper
-from test.test_tools import skip_if_missing, import_tool
-import unittest
-
-skip_if_missing()
-
-
-class lllTests(unittest.TestCase):
-
-    def setUp(self):
-        self.lll = import_tool('lll')
-
-    @os_helper.skip_unless_symlink
-    def test_lll_multiple_dirs(self):
-        with tempfile.TemporaryDirectory() as dir1, \
-             tempfile.TemporaryDirectory() as dir2:
-            fn1 = os.path.join(dir1, 'foo1')
-            fn2 = os.path.join(dir2, 'foo2')
-            for fn, dir in (fn1, dir1), (fn2, dir2):
-                open(fn, 'wb').close()
-                os.symlink(fn, os.path.join(dir, 'symlink'))
-
-            with support.captured_stdout() as output:
-                self.lll.main([dir1, dir2])
-            prefix = '\\\\?\\' if os.name == 'nt' else ''
-            self.assertEqual(output.getvalue(),
-                f'{dir1}:\n'
-                f'symlink -> {prefix}{fn1}\n'
-                f'\n'
-                f'{dir2}:\n'
-                f'symlink -> {prefix}{fn2}\n'
-            )
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/test/test_tools/test_pdeps.py b/Lib/test/test_tools/test_pdeps.py
deleted file mode 100644
index a986d10..0000000
--- a/Lib/test/test_tools/test_pdeps.py
+++ /dev/null
@@ -1,32 +0,0 @@
-"""Tests for the pdeps script in the Tools directory."""
-
-import os
-import unittest
-import tempfile
-
-from test.test_tools import skip_if_missing, import_tool
-
-skip_if_missing()
-
-
-class PdepsTests(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(self):
-        self.pdeps = import_tool('pdeps')
-
-    def test_process_errors(self):
-        # Issue #14492: m_import.match(line) can be None.
-        with tempfile.TemporaryDirectory() as tmpdir:
-            fn = os.path.join(tmpdir, 'foo')
-            with open(fn, 'w', encoding='utf-8') as stream:
-                stream.write("#!/this/will/fail")
-            self.pdeps.process(fn, {})
-
-    def test_inverse_attribute_error(self):
-        # Issue #14492: this used to fail with an AttributeError.
-        self.pdeps.inverse({'a': []})
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/test/test_tools/test_pindent.py b/Lib/test/test_tools/test_pindent.py
deleted file mode 100644
index 61e97fe..0000000
--- a/Lib/test/test_tools/test_pindent.py
+++ /dev/null
@@ -1,339 +0,0 @@
-"""Tests for the pindent script in the Tools directory."""
-
-import os
-import sys
-import unittest
-import subprocess
-import textwrap
-from test.support import os_helper
-from test.support.script_helper import assert_python_ok
-
-from test.test_tools import scriptsdir, skip_if_missing
-
-skip_if_missing()
-
-
-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):
-        with subprocess.Popen(
-                (sys.executable, self.script) + args,
-                stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                universal_newlines=True) as proc:
-            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 os_helper.temp_dir() as directory:
-            data_path = os.path.join(directory, '_test.py')
-            with open(self.script, encoding='utf-8') as f:
-                closed = f.read()
-            with open(data_path, 'w', encoding='utf-8') 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, encoding='utf-8') as f:
-                self.assertEqual(f.read(), closed)
-            with open(data_path, encoding='utf-8') 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, encoding='utf-8') as f:
-                self.assertEqual(f.read(), clean)
-            with open(data_path, encoding='utf-8') as f:
-                self.assertEqual(f.read(), closed)
-
-            broken = self.lstriplines(closed)
-            with open(data_path, 'w', encoding='utf-8') 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, encoding='utf-8') as f:
-                self.assertEqual(f.read(), broken)
-            with open(data_path, encoding='utf-8') 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)
-
-
-if __name__ == '__main__':
-    unittest.main()