From 5be32d88182f956f423a56c6250ce4020e8cd53c Mon Sep 17 00:00:00 2001
From: "Miss Islington (bot)"
 <31488909+miss-islington@users.noreply.github.com>
Date: Tue, 22 Aug 2023 08:42:00 -0700
Subject: [3.11] gh-106016: Add Lib/test/test_module/ directory (GH-108293)
 (#108304)

gh-106016: Add Lib/test/test_module/ directory (GH-108293)

* Move Python scripts related to test_module to this new directory:
  good_getattr.py and bad_getattrX.py scripts.
* Move Lib/test/test_module.py to Lib/test/test_module/__init__.py.
(cherry picked from commit adfc118fdab66882599e01a84c22bd897055f3f1)

Co-authored-by: Victor Stinner <vstinner@python.org>
---
 Lib/test/bad_getattr.py              |   4 -
 Lib/test/bad_getattr2.py             |   7 -
 Lib/test/bad_getattr3.py             |   5 -
 Lib/test/good_getattr.py             |  11 --
 Lib/test/test_module.py              | 370 -----------------------------------
 Lib/test/test_module/__init__.py     | 370 +++++++++++++++++++++++++++++++++++
 Lib/test/test_module/bad_getattr.py  |   4 +
 Lib/test/test_module/bad_getattr2.py |   7 +
 Lib/test/test_module/bad_getattr3.py |   5 +
 Lib/test/test_module/good_getattr.py |  11 ++
 Makefile.pre.in                      |   1 +
 11 files changed, 398 insertions(+), 397 deletions(-)
 delete mode 100644 Lib/test/bad_getattr.py
 delete mode 100644 Lib/test/bad_getattr2.py
 delete mode 100644 Lib/test/bad_getattr3.py
 delete mode 100644 Lib/test/good_getattr.py
 delete mode 100644 Lib/test/test_module.py
 create mode 100644 Lib/test/test_module/__init__.py
 create mode 100644 Lib/test/test_module/bad_getattr.py
 create mode 100644 Lib/test/test_module/bad_getattr2.py
 create mode 100644 Lib/test/test_module/bad_getattr3.py
 create mode 100644 Lib/test/test_module/good_getattr.py

diff --git a/Lib/test/bad_getattr.py b/Lib/test/bad_getattr.py
deleted file mode 100644
index 16f901b..0000000
--- a/Lib/test/bad_getattr.py
+++ /dev/null
@@ -1,4 +0,0 @@
-x = 1
-
-__getattr__ = "Surprise!"
-__dir__ = "Surprise again!"
diff --git a/Lib/test/bad_getattr2.py b/Lib/test/bad_getattr2.py
deleted file mode 100644
index 0a52a53..0000000
--- a/Lib/test/bad_getattr2.py
+++ /dev/null
@@ -1,7 +0,0 @@
-def __getattr__():
-    "Bad one"
-
-x = 1
-
-def __dir__(bad_sig):
-    return []
diff --git a/Lib/test/bad_getattr3.py b/Lib/test/bad_getattr3.py
deleted file mode 100644
index 0d5f926..0000000
--- a/Lib/test/bad_getattr3.py
+++ /dev/null
@@ -1,5 +0,0 @@
-def __getattr__(name):
-    if name != 'delgetattr':
-        raise AttributeError
-    del globals()['__getattr__']
-    raise AttributeError
diff --git a/Lib/test/good_getattr.py b/Lib/test/good_getattr.py
deleted file mode 100644
index 7d27de6..0000000
--- a/Lib/test/good_getattr.py
+++ /dev/null
@@ -1,11 +0,0 @@
-x = 1
-
-def __dir__():
-    return ['a', 'b', 'c']
-
-def __getattr__(name):
-    if name == "yolo":
-        raise AttributeError("Deprecated, use whatever instead")
-    return f"There is {name}"
-
-y = 2
diff --git a/Lib/test/test_module.py b/Lib/test/test_module.py
deleted file mode 100644
index f72177d..0000000
--- a/Lib/test/test_module.py
+++ /dev/null
@@ -1,370 +0,0 @@
-# Test the module type
-import unittest
-import weakref
-from test.support import gc_collect
-from test.support import import_helper
-from test.support.script_helper import assert_python_ok
-
-import sys
-ModuleType = type(sys)
-
-class FullLoader:
-    @classmethod
-    def module_repr(cls, m):
-        return "<module '{}' (crafted)>".format(m.__name__)
-
-class BareLoader:
-    pass
-
-
-class ModuleTests(unittest.TestCase):
-    def test_uninitialized(self):
-        # An uninitialized module has no __dict__ or __name__,
-        # and __doc__ is None
-        foo = ModuleType.__new__(ModuleType)
-        self.assertTrue(isinstance(foo.__dict__, dict))
-        self.assertEqual(dir(foo), [])
-        try:
-            s = foo.__name__
-            self.fail("__name__ = %s" % repr(s))
-        except AttributeError:
-            pass
-        self.assertEqual(foo.__doc__, ModuleType.__doc__)
-
-    def test_uninitialized_missing_getattr(self):
-        # Issue 8297
-        # test the text in the AttributeError of an uninitialized module
-        foo = ModuleType.__new__(ModuleType)
-        self.assertRaisesRegex(
-                AttributeError, "module has no attribute 'not_here'",
-                getattr, foo, "not_here")
-
-    def test_missing_getattr(self):
-        # Issue 8297
-        # test the text in the AttributeError
-        foo = ModuleType("foo")
-        self.assertRaisesRegex(
-                AttributeError, "module 'foo' has no attribute 'not_here'",
-                getattr, foo, "not_here")
-
-    def test_no_docstring(self):
-        # Regularly initialized module, no docstring
-        foo = ModuleType("foo")
-        self.assertEqual(foo.__name__, "foo")
-        self.assertEqual(foo.__doc__, None)
-        self.assertIs(foo.__loader__, None)
-        self.assertIs(foo.__package__, None)
-        self.assertIs(foo.__spec__, None)
-        self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": None,
-                                        "__loader__": None, "__package__": None,
-                                        "__spec__": None})
-
-    def test_ascii_docstring(self):
-        # ASCII docstring
-        foo = ModuleType("foo", "foodoc")
-        self.assertEqual(foo.__name__, "foo")
-        self.assertEqual(foo.__doc__, "foodoc")
-        self.assertEqual(foo.__dict__,
-                         {"__name__": "foo", "__doc__": "foodoc",
-                          "__loader__": None, "__package__": None,
-                          "__spec__": None})
-
-    def test_unicode_docstring(self):
-        # Unicode docstring
-        foo = ModuleType("foo", "foodoc\u1234")
-        self.assertEqual(foo.__name__, "foo")
-        self.assertEqual(foo.__doc__, "foodoc\u1234")
-        self.assertEqual(foo.__dict__,
-                         {"__name__": "foo", "__doc__": "foodoc\u1234",
-                          "__loader__": None, "__package__": None,
-                          "__spec__": None})
-
-    def test_reinit(self):
-        # Reinitialization should not replace the __dict__
-        foo = ModuleType("foo", "foodoc\u1234")
-        foo.bar = 42
-        d = foo.__dict__
-        foo.__init__("foo", "foodoc")
-        self.assertEqual(foo.__name__, "foo")
-        self.assertEqual(foo.__doc__, "foodoc")
-        self.assertEqual(foo.bar, 42)
-        self.assertEqual(foo.__dict__,
-              {"__name__": "foo", "__doc__": "foodoc", "bar": 42,
-               "__loader__": None, "__package__": None, "__spec__": None})
-        self.assertTrue(foo.__dict__ is d)
-
-    def test_dont_clear_dict(self):
-        # See issue 7140.
-        def f():
-            foo = ModuleType("foo")
-            foo.bar = 4
-            return foo
-        gc_collect()
-        self.assertEqual(f().__dict__["bar"], 4)
-
-    def test_clear_dict_in_ref_cycle(self):
-        destroyed = []
-        m = ModuleType("foo")
-        m.destroyed = destroyed
-        s = """class A:
-    def __init__(self, l):
-        self.l = l
-    def __del__(self):
-        self.l.append(1)
-a = A(destroyed)"""
-        exec(s, m.__dict__)
-        del m
-        gc_collect()
-        self.assertEqual(destroyed, [1])
-
-    def test_weakref(self):
-        m = ModuleType("foo")
-        wr = weakref.ref(m)
-        self.assertIs(wr(), m)
-        del m
-        gc_collect()
-        self.assertIs(wr(), None)
-
-    def test_module_getattr(self):
-        import test.good_getattr as gga
-        from test.good_getattr import test
-        self.assertEqual(test, "There is test")
-        self.assertEqual(gga.x, 1)
-        self.assertEqual(gga.y, 2)
-        with self.assertRaisesRegex(AttributeError,
-                                    "Deprecated, use whatever instead"):
-            gga.yolo
-        self.assertEqual(gga.whatever, "There is whatever")
-        del sys.modules['test.good_getattr']
-
-    def test_module_getattr_errors(self):
-        import test.bad_getattr as bga
-        from test import bad_getattr2
-        self.assertEqual(bga.x, 1)
-        self.assertEqual(bad_getattr2.x, 1)
-        with self.assertRaises(TypeError):
-            bga.nope
-        with self.assertRaises(TypeError):
-            bad_getattr2.nope
-        del sys.modules['test.bad_getattr']
-        if 'test.bad_getattr2' in sys.modules:
-            del sys.modules['test.bad_getattr2']
-
-    def test_module_dir(self):
-        import test.good_getattr as gga
-        self.assertEqual(dir(gga), ['a', 'b', 'c'])
-        del sys.modules['test.good_getattr']
-
-    def test_module_dir_errors(self):
-        import test.bad_getattr as bga
-        from test import bad_getattr2
-        with self.assertRaises(TypeError):
-            dir(bga)
-        with self.assertRaises(TypeError):
-            dir(bad_getattr2)
-        del sys.modules['test.bad_getattr']
-        if 'test.bad_getattr2' in sys.modules:
-            del sys.modules['test.bad_getattr2']
-
-    def test_module_getattr_tricky(self):
-        from test import bad_getattr3
-        # these lookups should not crash
-        with self.assertRaises(AttributeError):
-            bad_getattr3.one
-        with self.assertRaises(AttributeError):
-            bad_getattr3.delgetattr
-        if 'test.bad_getattr3' in sys.modules:
-            del sys.modules['test.bad_getattr3']
-
-    def test_module_repr_minimal(self):
-        # reprs when modules have no __file__, __name__, or __loader__
-        m = ModuleType('foo')
-        del m.__name__
-        self.assertEqual(repr(m), "<module '?'>")
-
-    def test_module_repr_with_name(self):
-        m = ModuleType('foo')
-        self.assertEqual(repr(m), "<module 'foo'>")
-
-    def test_module_repr_with_name_and_filename(self):
-        m = ModuleType('foo')
-        m.__file__ = '/tmp/foo.py'
-        self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>")
-
-    def test_module_repr_with_filename_only(self):
-        m = ModuleType('foo')
-        del m.__name__
-        m.__file__ = '/tmp/foo.py'
-        self.assertEqual(repr(m), "<module '?' from '/tmp/foo.py'>")
-
-    def test_module_repr_with_loader_as_None(self):
-        m = ModuleType('foo')
-        assert m.__loader__ is None
-        self.assertEqual(repr(m), "<module 'foo'>")
-
-    def test_module_repr_with_bare_loader_but_no_name(self):
-        m = ModuleType('foo')
-        del m.__name__
-        # Yes, a class not an instance.
-        m.__loader__ = BareLoader
-        loader_repr = repr(BareLoader)
-        self.assertEqual(
-            repr(m), "<module '?' ({})>".format(loader_repr))
-
-    def test_module_repr_with_full_loader_but_no_name(self):
-        # m.__loader__.module_repr() will fail because the module has no
-        # m.__name__.  This exception will get suppressed and instead the
-        # loader's repr will be used.
-        m = ModuleType('foo')
-        del m.__name__
-        # Yes, a class not an instance.
-        m.__loader__ = FullLoader
-        loader_repr = repr(FullLoader)
-        self.assertEqual(
-            repr(m), "<module '?' ({})>".format(loader_repr))
-
-    def test_module_repr_with_bare_loader(self):
-        m = ModuleType('foo')
-        # Yes, a class not an instance.
-        m.__loader__ = BareLoader
-        module_repr = repr(BareLoader)
-        self.assertEqual(
-            repr(m), "<module 'foo' ({})>".format(module_repr))
-
-    def test_module_repr_with_full_loader(self):
-        m = ModuleType('foo')
-        # Yes, a class not an instance.
-        m.__loader__ = FullLoader
-        self.assertEqual(
-            repr(m), "<module 'foo' (crafted)>")
-
-    def test_module_repr_with_bare_loader_and_filename(self):
-        # Because the loader has no module_repr(), use the file name.
-        m = ModuleType('foo')
-        # Yes, a class not an instance.
-        m.__loader__ = BareLoader
-        m.__file__ = '/tmp/foo.py'
-        self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>")
-
-    def test_module_repr_with_full_loader_and_filename(self):
-        # Even though the module has an __file__, use __loader__.module_repr()
-        m = ModuleType('foo')
-        # Yes, a class not an instance.
-        m.__loader__ = FullLoader
-        m.__file__ = '/tmp/foo.py'
-        self.assertEqual(repr(m), "<module 'foo' (crafted)>")
-
-    def test_module_repr_builtin(self):
-        self.assertEqual(repr(sys), "<module 'sys' (built-in)>")
-
-    def test_module_repr_source(self):
-        r = repr(unittest)
-        starts_with = "<module 'unittest' from '"
-        ends_with = "__init__.py'>"
-        self.assertEqual(r[:len(starts_with)], starts_with,
-                         '{!r} does not start with {!r}'.format(r, starts_with))
-        self.assertEqual(r[-len(ends_with):], ends_with,
-                         '{!r} does not end with {!r}'.format(r, ends_with))
-
-    def test_module_finalization_at_shutdown(self):
-        # Module globals and builtins should still be available during shutdown
-        rc, out, err = assert_python_ok("-c", "from test import final_a")
-        self.assertFalse(err)
-        lines = out.splitlines()
-        self.assertEqual(set(lines), {
-            b"x = a",
-            b"x = b",
-            b"final_a.x = a",
-            b"final_b.x = b",
-            b"len = len",
-            b"shutil.rmtree = rmtree"})
-
-    def test_descriptor_errors_propagate(self):
-        class Descr:
-            def __get__(self, o, t):
-                raise RuntimeError
-        class M(ModuleType):
-            melon = Descr()
-        self.assertRaises(RuntimeError, getattr, M("mymod"), "melon")
-
-    def test_lazy_create_annotations(self):
-        # module objects lazy create their __annotations__ dict on demand.
-        # the annotations dict is stored in module.__dict__.
-        # a freshly created module shouldn't have an annotations dict yet.
-        foo = ModuleType("foo")
-        for i in range(4):
-            self.assertFalse("__annotations__" in foo.__dict__)
-            d = foo.__annotations__
-            self.assertTrue("__annotations__" in foo.__dict__)
-            self.assertEqual(foo.__annotations__, d)
-            self.assertEqual(foo.__dict__['__annotations__'], d)
-            if i % 2:
-                del foo.__annotations__
-            else:
-                del foo.__dict__['__annotations__']
-
-    def test_setting_annotations(self):
-        foo = ModuleType("foo")
-        for i in range(4):
-            self.assertFalse("__annotations__" in foo.__dict__)
-            d = {'a': int}
-            foo.__annotations__ = d
-            self.assertTrue("__annotations__" in foo.__dict__)
-            self.assertEqual(foo.__annotations__, d)
-            self.assertEqual(foo.__dict__['__annotations__'], d)
-            if i % 2:
-                del foo.__annotations__
-            else:
-                del foo.__dict__['__annotations__']
-
-    def test_annotations_getset_raises(self):
-        # double delete
-        foo = ModuleType("foo")
-        foo.__annotations__ = {}
-        del foo.__annotations__
-        with self.assertRaises(AttributeError):
-            del foo.__annotations__
-
-    def test_annotations_are_created_correctly(self):
-        ann_module4 = import_helper.import_fresh_module('test.ann_module4')
-        self.assertTrue("__annotations__" in ann_module4.__dict__)
-        del ann_module4.__annotations__
-        self.assertFalse("__annotations__" in ann_module4.__dict__)
-
-
-    def test_repeated_attribute_pops(self):
-        # Repeated accesses to module attribute will be specialized
-        # Check that popping the attribute doesn't break it
-        m = ModuleType("test")
-        d = m.__dict__
-        count = 0
-        for _ in range(100):
-            m.attr = 1
-            count += m.attr # Might be specialized
-            d.pop("attr")
-        self.assertEqual(count, 100)
-
-    # frozen and namespace module reprs are tested in importlib.
-
-    def test_subclass_with_slots(self):
-        # In 3.11alpha this crashed, as the slots weren't NULLed.
-
-        class ModuleWithSlots(ModuleType):
-            __slots__ = ("a", "b")
-
-            def __init__(self, name):
-                super().__init__(name)
-
-        m = ModuleWithSlots("name")
-        with self.assertRaises(AttributeError):
-            m.a
-        with self.assertRaises(AttributeError):
-            m.b
-        m.a, m.b = 1, 2
-        self.assertEqual(m.a, 1)
-        self.assertEqual(m.b, 2)
-
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/Lib/test/test_module/__init__.py b/Lib/test/test_module/__init__.py
new file mode 100644
index 0000000..87d1a8e
--- /dev/null
+++ b/Lib/test/test_module/__init__.py
@@ -0,0 +1,370 @@
+# Test the module type
+import unittest
+import weakref
+from test.support import gc_collect
+from test.support import import_helper
+from test.support.script_helper import assert_python_ok
+
+import sys
+ModuleType = type(sys)
+
+class FullLoader:
+    @classmethod
+    def module_repr(cls, m):
+        return "<module '{}' (crafted)>".format(m.__name__)
+
+class BareLoader:
+    pass
+
+
+class ModuleTests(unittest.TestCase):
+    def test_uninitialized(self):
+        # An uninitialized module has no __dict__ or __name__,
+        # and __doc__ is None
+        foo = ModuleType.__new__(ModuleType)
+        self.assertTrue(isinstance(foo.__dict__, dict))
+        self.assertEqual(dir(foo), [])
+        try:
+            s = foo.__name__
+            self.fail("__name__ = %s" % repr(s))
+        except AttributeError:
+            pass
+        self.assertEqual(foo.__doc__, ModuleType.__doc__)
+
+    def test_uninitialized_missing_getattr(self):
+        # Issue 8297
+        # test the text in the AttributeError of an uninitialized module
+        foo = ModuleType.__new__(ModuleType)
+        self.assertRaisesRegex(
+                AttributeError, "module has no attribute 'not_here'",
+                getattr, foo, "not_here")
+
+    def test_missing_getattr(self):
+        # Issue 8297
+        # test the text in the AttributeError
+        foo = ModuleType("foo")
+        self.assertRaisesRegex(
+                AttributeError, "module 'foo' has no attribute 'not_here'",
+                getattr, foo, "not_here")
+
+    def test_no_docstring(self):
+        # Regularly initialized module, no docstring
+        foo = ModuleType("foo")
+        self.assertEqual(foo.__name__, "foo")
+        self.assertEqual(foo.__doc__, None)
+        self.assertIs(foo.__loader__, None)
+        self.assertIs(foo.__package__, None)
+        self.assertIs(foo.__spec__, None)
+        self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": None,
+                                        "__loader__": None, "__package__": None,
+                                        "__spec__": None})
+
+    def test_ascii_docstring(self):
+        # ASCII docstring
+        foo = ModuleType("foo", "foodoc")
+        self.assertEqual(foo.__name__, "foo")
+        self.assertEqual(foo.__doc__, "foodoc")
+        self.assertEqual(foo.__dict__,
+                         {"__name__": "foo", "__doc__": "foodoc",
+                          "__loader__": None, "__package__": None,
+                          "__spec__": None})
+
+    def test_unicode_docstring(self):
+        # Unicode docstring
+        foo = ModuleType("foo", "foodoc\u1234")
+        self.assertEqual(foo.__name__, "foo")
+        self.assertEqual(foo.__doc__, "foodoc\u1234")
+        self.assertEqual(foo.__dict__,
+                         {"__name__": "foo", "__doc__": "foodoc\u1234",
+                          "__loader__": None, "__package__": None,
+                          "__spec__": None})
+
+    def test_reinit(self):
+        # Reinitialization should not replace the __dict__
+        foo = ModuleType("foo", "foodoc\u1234")
+        foo.bar = 42
+        d = foo.__dict__
+        foo.__init__("foo", "foodoc")
+        self.assertEqual(foo.__name__, "foo")
+        self.assertEqual(foo.__doc__, "foodoc")
+        self.assertEqual(foo.bar, 42)
+        self.assertEqual(foo.__dict__,
+              {"__name__": "foo", "__doc__": "foodoc", "bar": 42,
+               "__loader__": None, "__package__": None, "__spec__": None})
+        self.assertTrue(foo.__dict__ is d)
+
+    def test_dont_clear_dict(self):
+        # See issue 7140.
+        def f():
+            foo = ModuleType("foo")
+            foo.bar = 4
+            return foo
+        gc_collect()
+        self.assertEqual(f().__dict__["bar"], 4)
+
+    def test_clear_dict_in_ref_cycle(self):
+        destroyed = []
+        m = ModuleType("foo")
+        m.destroyed = destroyed
+        s = """class A:
+    def __init__(self, l):
+        self.l = l
+    def __del__(self):
+        self.l.append(1)
+a = A(destroyed)"""
+        exec(s, m.__dict__)
+        del m
+        gc_collect()
+        self.assertEqual(destroyed, [1])
+
+    def test_weakref(self):
+        m = ModuleType("foo")
+        wr = weakref.ref(m)
+        self.assertIs(wr(), m)
+        del m
+        gc_collect()
+        self.assertIs(wr(), None)
+
+    def test_module_getattr(self):
+        import test.test_module.good_getattr as gga
+        from test.test_module.good_getattr import test
+        self.assertEqual(test, "There is test")
+        self.assertEqual(gga.x, 1)
+        self.assertEqual(gga.y, 2)
+        with self.assertRaisesRegex(AttributeError,
+                                    "Deprecated, use whatever instead"):
+            gga.yolo
+        self.assertEqual(gga.whatever, "There is whatever")
+        del sys.modules['test.test_module.good_getattr']
+
+    def test_module_getattr_errors(self):
+        import test.test_module.bad_getattr as bga
+        from test.test_module import bad_getattr2
+        self.assertEqual(bga.x, 1)
+        self.assertEqual(bad_getattr2.x, 1)
+        with self.assertRaises(TypeError):
+            bga.nope
+        with self.assertRaises(TypeError):
+            bad_getattr2.nope
+        del sys.modules['test.test_module.bad_getattr']
+        if 'test.test_module.bad_getattr2' in sys.modules:
+            del sys.modules['test.test_module.bad_getattr2']
+
+    def test_module_dir(self):
+        import test.test_module.good_getattr as gga
+        self.assertEqual(dir(gga), ['a', 'b', 'c'])
+        del sys.modules['test.test_module.good_getattr']
+
+    def test_module_dir_errors(self):
+        import test.test_module.bad_getattr as bga
+        from test.test_module import bad_getattr2
+        with self.assertRaises(TypeError):
+            dir(bga)
+        with self.assertRaises(TypeError):
+            dir(bad_getattr2)
+        del sys.modules['test.test_module.bad_getattr']
+        if 'test.test_module.bad_getattr2' in sys.modules:
+            del sys.modules['test.test_module.bad_getattr2']
+
+    def test_module_getattr_tricky(self):
+        from test.test_module import bad_getattr3
+        # these lookups should not crash
+        with self.assertRaises(AttributeError):
+            bad_getattr3.one
+        with self.assertRaises(AttributeError):
+            bad_getattr3.delgetattr
+        if 'test.test_module.bad_getattr3' in sys.modules:
+            del sys.modules['test.test_module.bad_getattr3']
+
+    def test_module_repr_minimal(self):
+        # reprs when modules have no __file__, __name__, or __loader__
+        m = ModuleType('foo')
+        del m.__name__
+        self.assertEqual(repr(m), "<module '?'>")
+
+    def test_module_repr_with_name(self):
+        m = ModuleType('foo')
+        self.assertEqual(repr(m), "<module 'foo'>")
+
+    def test_module_repr_with_name_and_filename(self):
+        m = ModuleType('foo')
+        m.__file__ = '/tmp/foo.py'
+        self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>")
+
+    def test_module_repr_with_filename_only(self):
+        m = ModuleType('foo')
+        del m.__name__
+        m.__file__ = '/tmp/foo.py'
+        self.assertEqual(repr(m), "<module '?' from '/tmp/foo.py'>")
+
+    def test_module_repr_with_loader_as_None(self):
+        m = ModuleType('foo')
+        assert m.__loader__ is None
+        self.assertEqual(repr(m), "<module 'foo'>")
+
+    def test_module_repr_with_bare_loader_but_no_name(self):
+        m = ModuleType('foo')
+        del m.__name__
+        # Yes, a class not an instance.
+        m.__loader__ = BareLoader
+        loader_repr = repr(BareLoader)
+        self.assertEqual(
+            repr(m), "<module '?' ({})>".format(loader_repr))
+
+    def test_module_repr_with_full_loader_but_no_name(self):
+        # m.__loader__.module_repr() will fail because the module has no
+        # m.__name__.  This exception will get suppressed and instead the
+        # loader's repr will be used.
+        m = ModuleType('foo')
+        del m.__name__
+        # Yes, a class not an instance.
+        m.__loader__ = FullLoader
+        loader_repr = repr(FullLoader)
+        self.assertEqual(
+            repr(m), "<module '?' ({})>".format(loader_repr))
+
+    def test_module_repr_with_bare_loader(self):
+        m = ModuleType('foo')
+        # Yes, a class not an instance.
+        m.__loader__ = BareLoader
+        module_repr = repr(BareLoader)
+        self.assertEqual(
+            repr(m), "<module 'foo' ({})>".format(module_repr))
+
+    def test_module_repr_with_full_loader(self):
+        m = ModuleType('foo')
+        # Yes, a class not an instance.
+        m.__loader__ = FullLoader
+        self.assertEqual(
+            repr(m), "<module 'foo' (crafted)>")
+
+    def test_module_repr_with_bare_loader_and_filename(self):
+        # Because the loader has no module_repr(), use the file name.
+        m = ModuleType('foo')
+        # Yes, a class not an instance.
+        m.__loader__ = BareLoader
+        m.__file__ = '/tmp/foo.py'
+        self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>")
+
+    def test_module_repr_with_full_loader_and_filename(self):
+        # Even though the module has an __file__, use __loader__.module_repr()
+        m = ModuleType('foo')
+        # Yes, a class not an instance.
+        m.__loader__ = FullLoader
+        m.__file__ = '/tmp/foo.py'
+        self.assertEqual(repr(m), "<module 'foo' (crafted)>")
+
+    def test_module_repr_builtin(self):
+        self.assertEqual(repr(sys), "<module 'sys' (built-in)>")
+
+    def test_module_repr_source(self):
+        r = repr(unittest)
+        starts_with = "<module 'unittest' from '"
+        ends_with = "__init__.py'>"
+        self.assertEqual(r[:len(starts_with)], starts_with,
+                         '{!r} does not start with {!r}'.format(r, starts_with))
+        self.assertEqual(r[-len(ends_with):], ends_with,
+                         '{!r} does not end with {!r}'.format(r, ends_with))
+
+    def test_module_finalization_at_shutdown(self):
+        # Module globals and builtins should still be available during shutdown
+        rc, out, err = assert_python_ok("-c", "from test import final_a")
+        self.assertFalse(err)
+        lines = out.splitlines()
+        self.assertEqual(set(lines), {
+            b"x = a",
+            b"x = b",
+            b"final_a.x = a",
+            b"final_b.x = b",
+            b"len = len",
+            b"shutil.rmtree = rmtree"})
+
+    def test_descriptor_errors_propagate(self):
+        class Descr:
+            def __get__(self, o, t):
+                raise RuntimeError
+        class M(ModuleType):
+            melon = Descr()
+        self.assertRaises(RuntimeError, getattr, M("mymod"), "melon")
+
+    def test_lazy_create_annotations(self):
+        # module objects lazy create their __annotations__ dict on demand.
+        # the annotations dict is stored in module.__dict__.
+        # a freshly created module shouldn't have an annotations dict yet.
+        foo = ModuleType("foo")
+        for i in range(4):
+            self.assertFalse("__annotations__" in foo.__dict__)
+            d = foo.__annotations__
+            self.assertTrue("__annotations__" in foo.__dict__)
+            self.assertEqual(foo.__annotations__, d)
+            self.assertEqual(foo.__dict__['__annotations__'], d)
+            if i % 2:
+                del foo.__annotations__
+            else:
+                del foo.__dict__['__annotations__']
+
+    def test_setting_annotations(self):
+        foo = ModuleType("foo")
+        for i in range(4):
+            self.assertFalse("__annotations__" in foo.__dict__)
+            d = {'a': int}
+            foo.__annotations__ = d
+            self.assertTrue("__annotations__" in foo.__dict__)
+            self.assertEqual(foo.__annotations__, d)
+            self.assertEqual(foo.__dict__['__annotations__'], d)
+            if i % 2:
+                del foo.__annotations__
+            else:
+                del foo.__dict__['__annotations__']
+
+    def test_annotations_getset_raises(self):
+        # double delete
+        foo = ModuleType("foo")
+        foo.__annotations__ = {}
+        del foo.__annotations__
+        with self.assertRaises(AttributeError):
+            del foo.__annotations__
+
+    def test_annotations_are_created_correctly(self):
+        ann_module4 = import_helper.import_fresh_module('test.ann_module4')
+        self.assertTrue("__annotations__" in ann_module4.__dict__)
+        del ann_module4.__annotations__
+        self.assertFalse("__annotations__" in ann_module4.__dict__)
+
+
+    def test_repeated_attribute_pops(self):
+        # Repeated accesses to module attribute will be specialized
+        # Check that popping the attribute doesn't break it
+        m = ModuleType("test")
+        d = m.__dict__
+        count = 0
+        for _ in range(100):
+            m.attr = 1
+            count += m.attr # Might be specialized
+            d.pop("attr")
+        self.assertEqual(count, 100)
+
+    # frozen and namespace module reprs are tested in importlib.
+
+    def test_subclass_with_slots(self):
+        # In 3.11alpha this crashed, as the slots weren't NULLed.
+
+        class ModuleWithSlots(ModuleType):
+            __slots__ = ("a", "b")
+
+            def __init__(self, name):
+                super().__init__(name)
+
+        m = ModuleWithSlots("name")
+        with self.assertRaises(AttributeError):
+            m.a
+        with self.assertRaises(AttributeError):
+            m.b
+        m.a, m.b = 1, 2
+        self.assertEqual(m.a, 1)
+        self.assertEqual(m.b, 2)
+
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/Lib/test/test_module/bad_getattr.py b/Lib/test/test_module/bad_getattr.py
new file mode 100644
index 0000000..16f901b
--- /dev/null
+++ b/Lib/test/test_module/bad_getattr.py
@@ -0,0 +1,4 @@
+x = 1
+
+__getattr__ = "Surprise!"
+__dir__ = "Surprise again!"
diff --git a/Lib/test/test_module/bad_getattr2.py b/Lib/test/test_module/bad_getattr2.py
new file mode 100644
index 0000000..0a52a53
--- /dev/null
+++ b/Lib/test/test_module/bad_getattr2.py
@@ -0,0 +1,7 @@
+def __getattr__():
+    "Bad one"
+
+x = 1
+
+def __dir__(bad_sig):
+    return []
diff --git a/Lib/test/test_module/bad_getattr3.py b/Lib/test/test_module/bad_getattr3.py
new file mode 100644
index 0000000..0d5f926
--- /dev/null
+++ b/Lib/test/test_module/bad_getattr3.py
@@ -0,0 +1,5 @@
+def __getattr__(name):
+    if name != 'delgetattr':
+        raise AttributeError
+    del globals()['__getattr__']
+    raise AttributeError
diff --git a/Lib/test/test_module/good_getattr.py b/Lib/test/test_module/good_getattr.py
new file mode 100644
index 0000000..7d27de6
--- /dev/null
+++ b/Lib/test/test_module/good_getattr.py
@@ -0,0 +1,11 @@
+x = 1
+
+def __dir__():
+    return ['a', 'b', 'c']
+
+def __getattr__(name):
+    if name == "yolo":
+        raise AttributeError("Deprecated, use whatever instead")
+    return f"There is {name}"
+
+y = 2
diff --git a/Makefile.pre.in b/Makefile.pre.in
index 2a407a7..6405d06 100644
--- a/Makefile.pre.in
+++ b/Makefile.pre.in
@@ -2012,6 +2012,7 @@ TESTSUBDIRS=	ctypes/test \
 		test/test_importlib/zipdata01 \
 		test/test_importlib/zipdata02 \
 		test/test_json \
+		test/test_module \
 		test/test_peg_generator \
 		test/test_sqlite3 \
 		test/test_tomllib \
-- 
cgit v0.12