init

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/fake_3_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/fake_4_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/fake_5_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/fake_6_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/no_assertions__ret_code_of_1__test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        pass
+
+    def test_get_mods(self):
+        pass
+
+    def test_get_pressed(self):
+        pass
+
+    def test_name(self):
+        pass
+
+    def test_set_mods(self):
+        pass
+
+    def test_set_repeat(self):
+        pass
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/all_ok/zero_tests_test.py

@@ -0,0 +1,23 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    pass
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/everything/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/everything/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/everything/incomplete_todo_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def todo_test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def todo_test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/everything/magic_tag_test.py

@@ -0,0 +1,38 @@
+__tags__ = ["magic"]
+
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/everything/sleep_test.py

@@ -0,0 +1,29 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+import time
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        stop_time = time.time() + 10.0
+        while time.time() < stop_time:
+            time.sleep(1)
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/exclude/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/exclude/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/exclude/invisible_tag_test.py

@@ -0,0 +1,41 @@
+__tags__ = ["invisible"]
+
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/exclude/magic_tag_test.py

@@ -0,0 +1,38 @@
+__tags__ = ["magic"]
+
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/failures1/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/failures1/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/failures1/fake_3_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/failures1/fake_4_test.py

@@ -0,0 +1,41 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(False, "Some Jibberish")
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        if 1:
+            if 1:
+                assert False
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/incomplete/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/incomplete/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def todo_test_get_pressed(self):
+        self.fail()
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def todo_test_set_mods(self):
+        self.fail()
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/incomplete/fake_3_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/incomplete_todo/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/incomplete_todo/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def todo_test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def todo_test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/incomplete_todo/fake_3_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/infinite_loop/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/infinite_loop/fake_1_test.py

@@ -0,0 +1,40 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        while True:
+            pass
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/infinite_loop/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stderr/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stderr/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stderr/fake_3_test.py

@@ -0,0 +1,41 @@
+import sys
+
+if __name__ == "__main__":
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        sys.stderr.write("jibberish messes things up\n")
+        self.assertTrue(False)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stderr/fake_4_test.py

@@ -0,0 +1,41 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(False, "Some Jibberish")
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        if 1:
+            if 1:
+                assert False
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stdout/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stdout/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stdout/fake_3_test.py

@@ -0,0 +1,42 @@
+import sys
+
+if __name__ == "__main__":
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        sys.stdout.write("jibberish ruins everything\n")
+        self.assertTrue(False)
+
+    def test_name(self):
+        sys.stdout.write("forgot to remove debug crap\n")
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/print_stdout/fake_4_test.py

@@ -0,0 +1,41 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(False, "Some Jibberish")
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        if 1:
+            if 1:
+                assert False
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/run_tests__test.py

@@ -0,0 +1,145 @@
+################################################################################
+
+import subprocess, os, sys, re, difflib
+
+################################################################################
+
+IGNORE = (".svn", "infinite_loop")
+NORMALIZERS = (
+    (r"Ran (\d+) tests in (\d+\.\d+)s", "Ran \\1 tests in X.XXXs"),
+    (r'File ".*?([^/\\.]+\.py)"', 'File "\\1"'),
+)
+
+################################################################################
+
+
+def norm_result(result):
+    "normalize differences, such as timing between output"
+    for normalizer, replacement in NORMALIZERS:
+        if hasattr(normalizer, "__call__"):
+            result = normalizer(result)
+        else:
+            result = re.sub(normalizer, replacement, result)
+
+    return result
+
+
+def call_proc(cmd, cd=None):
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        cwd=cd,
+        universal_newlines=True,
+    )
+    if proc.wait():
+        print("%s %s" % (cmd, proc.wait()))
+        raise Exception(proc.stdout.read())
+
+    return proc.stdout.read()
+
+
+################################################################################
+
+unnormed_diff = "-u" in sys.argv
+verbose = "-v" in sys.argv or unnormed_diff
+if "-h" in sys.argv or "--help" in sys.argv:
+    sys.exit(
+        "\nCOMPARES OUTPUT OF SINGLE VS SUBPROCESS MODE OF RUN_TESTS.PY\n\n"
+        "-v, to output diffs even on success\n"
+        "-u, to output diffs of unnormalized tests\n\n"
+        "Each line of a Differ delta begins with a two-letter code:\n\n"
+        "    '- '    line unique to sequence 1\n"
+        "    '+ '    line unique to sequence 2\n"
+        "    '  '    line common to both sequences\n"
+        "    '? '    line not present in either input sequence\n"
+    )
+
+main_dir = os.path.split(os.path.abspath(sys.argv[0]))[0]
+trunk_dir = os.path.normpath(os.path.join(main_dir, "../../"))
+
+test_suite_dirs = [
+    x
+    for x in os.listdir(main_dir)
+    if os.path.isdir(os.path.join(main_dir, x)) and x not in IGNORE
+]
+
+
+################################################################################
+
+
+def assert_on_results(suite, single, sub):
+    test = globals().get("%s_test" % suite)
+    if hasattr(test, "__call_"):
+        test(suite, single, sub)
+        print("assertions on %s OK" % (suite,))
+
+
+# Don't modify tests in suites below. These assertions are in place to make sure
+# that tests are actually being ran
+
+
+def all_ok_test(uite, *args):
+    for results in args:
+        assert "Ran 36 tests" in results  # some tests are runing
+        assert "OK" in results  # OK
+
+
+def failures1_test(suite, *args):
+    for results in args:
+        assert "FAILED (failures=2)" in results
+        assert "Ran 18 tests" in results
+
+
+################################################################################
+# Test that output is the same in single process and subprocess modes
+#
+
+base_cmd = [sys.executable, "run_tests.py", "-i"]
+
+cmd = base_cmd + ["-n", "-f"]
+sub_cmd = base_cmd + ["-f"]
+time_out_cmd = base_cmd + ["-t", "4", "-f", "infinite_loop"]
+
+passes = 0
+failed = False
+
+for suite in test_suite_dirs:
+    single = call_proc(cmd + [suite], trunk_dir)
+    subs = call_proc(sub_cmd + [suite], trunk_dir)
+
+    normed_single, normed_subs = map(norm_result, (single, subs))
+
+    failed = normed_single != normed_subs
+    if failed:
+        print("%s suite comparison FAILED\n" % (suite,))
+    else:
+        passes += 1
+        print("%s suite comparison OK" % (suite,))
+
+    assert_on_results(suite, single, subs)
+
+    if verbose or failed:
+        print("difflib.Differ().compare(single, suprocessed):\n")
+        print(
+            "".join(
+                list(
+                    difflib.Differ().compare(
+                        (unnormed_diff and single or normed_single).splitlines(1),
+                        (unnormed_diff and subs or normed_subs).splitlines(1),
+                    )
+                )
+            )
+        )
+
+sys.stdout.write("infinite_loop suite (subprocess mode timeout) ")
+loop_test = call_proc(time_out_cmd, trunk_dir)
+assert "successfully terminated" in loop_test
+passes += 1
+print("OK")
+
+print("\n%s/%s suites pass" % (passes, len(test_suite_dirs) + 1))
+
+print("\n-h for help")
+
+################################################################################

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/timeout/__init__.py

@@ -0,0 +1 @@
+# empty

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/timeout/fake_2_test.py

@@ -0,0 +1,39 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        self.assertTrue(True)
+
+    def test_get_mods(self):
+        self.assertTrue(True)
+
+    def test_get_pressed(self):
+        self.assertTrue(True)
+
+    def test_name(self):
+        self.assertTrue(True)
+
+    def test_set_mods(self):
+        self.assertTrue(True)
+
+    def test_set_repeat(self):
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()

.venv/lib/python3.8/site-packages/pygame/tests/run_tests__tests/timeout/sleep_test.py

@@ -0,0 +1,30 @@
+if __name__ == "__main__":
+    import sys
+    import os
+
+    pkg_dir = os.path.split(
+        os.path.split(os.path.split(os.path.abspath(__file__))[0])[0]
+    )[0]
+    parent_dir, pkg_name = os.path.split(pkg_dir)
+    is_pygame_pkg = pkg_name == "tests" and os.path.split(parent_dir)[1] == "pygame"
+    if not is_pygame_pkg:
+        sys.path.insert(0, parent_dir)
+else:
+    is_pygame_pkg = __name__.startswith("pygame.tests.")
+
+import unittest
+
+import time
+
+
+class KeyModuleTest(unittest.TestCase):
+    def test_get_focused(self):
+        stop_time = time.time() + 10.0
+        while time.time() < stop_time:
+            time.sleep(1)
+
+        self.assertTrue(True)
+
+
+if __name__ == "__main__":
+    unittest.main()