Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 1 | # Test the module type |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 2 | import unittest |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 3 | from test.support import run_unittest, gc_collect |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 4 | |
| 5 | import sys |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 6 | ModuleType = type(sys) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 7 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 8 | class FullLoader: |
| 9 | @classmethod |
| 10 | def module_repr(cls, m): |
| 11 | return "<module '{}' (crafted)>".format(m.__name__) |
| 12 | |
| 13 | class BareLoader: |
| 14 | pass |
| 15 | |
| 16 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 17 | class ModuleTests(unittest.TestCase): |
| 18 | def test_uninitialized(self): |
| 19 | # An uninitialized module has no __dict__ or __name__, |
| 20 | # and __doc__ is None |
| 21 | foo = ModuleType.__new__(ModuleType) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 22 | self.assertTrue(foo.__dict__ is None) |
Benjamin Peterson | 1432771 | 2009-08-15 13:23:05 +0000 | [diff] [blame] | 23 | self.assertRaises(SystemError, dir, foo) |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 24 | try: |
| 25 | s = foo.__name__ |
| 26 | self.fail("__name__ = %s" % repr(s)) |
| 27 | except AttributeError: |
| 28 | pass |
| 29 | self.assertEqual(foo.__doc__, ModuleType.__doc__) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 30 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 31 | def test_no_docstring(self): |
| 32 | # Regularly initialized module, no docstring |
| 33 | foo = ModuleType("foo") |
| 34 | self.assertEqual(foo.__name__, "foo") |
| 35 | self.assertEqual(foo.__doc__, None) |
| 36 | self.assertEqual(foo.__dict__, {"__name__": "foo", "__doc__": None}) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 37 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 38 | def test_ascii_docstring(self): |
| 39 | # ASCII docstring |
| 40 | foo = ModuleType("foo", "foodoc") |
| 41 | self.assertEqual(foo.__name__, "foo") |
| 42 | self.assertEqual(foo.__doc__, "foodoc") |
| 43 | self.assertEqual(foo.__dict__, |
| 44 | {"__name__": "foo", "__doc__": "foodoc"}) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 45 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 46 | def test_unicode_docstring(self): |
| 47 | # Unicode docstring |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 48 | foo = ModuleType("foo", "foodoc\u1234") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 49 | self.assertEqual(foo.__name__, "foo") |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 50 | self.assertEqual(foo.__doc__, "foodoc\u1234") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 51 | self.assertEqual(foo.__dict__, |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 52 | {"__name__": "foo", "__doc__": "foodoc\u1234"}) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 53 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 54 | def test_reinit(self): |
| 55 | # Reinitialization should not replace the __dict__ |
Guido van Rossum | ef87d6e | 2007-05-02 19:09:54 +0000 | [diff] [blame] | 56 | foo = ModuleType("foo", "foodoc\u1234") |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 57 | foo.bar = 42 |
| 58 | d = foo.__dict__ |
| 59 | foo.__init__("foo", "foodoc") |
| 60 | self.assertEqual(foo.__name__, "foo") |
| 61 | self.assertEqual(foo.__doc__, "foodoc") |
| 62 | self.assertEqual(foo.bar, 42) |
| 63 | self.assertEqual(foo.__dict__, |
| 64 | {"__name__": "foo", "__doc__": "foodoc", "bar": 42}) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 65 | self.assertTrue(foo.__dict__ is d) |
Guido van Rossum | c3a787e | 2002-06-04 05:52:47 +0000 | [diff] [blame] | 66 | |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 67 | @unittest.expectedFailure |
Benjamin Peterson | a0dfa82 | 2009-11-13 02:25:08 +0000 | [diff] [blame] | 68 | def test_dont_clear_dict(self): |
| 69 | # See issue 7140. |
| 70 | def f(): |
| 71 | foo = ModuleType("foo") |
| 72 | foo.bar = 4 |
| 73 | return foo |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 74 | gc_collect() |
Benjamin Peterson | a0dfa82 | 2009-11-13 02:25:08 +0000 | [diff] [blame] | 75 | self.assertEqual(f().__dict__["bar"], 4) |
| 76 | |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 77 | def test_clear_dict_in_ref_cycle(self): |
| 78 | destroyed = [] |
| 79 | m = ModuleType("foo") |
| 80 | m.destroyed = destroyed |
| 81 | s = """class A: |
Benjamin Peterson | ca81bf7 | 2011-12-15 15:57:15 -0500 | [diff] [blame] | 82 | def __init__(self, l): |
| 83 | self.l = l |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 84 | def __del__(self): |
Benjamin Peterson | ca81bf7 | 2011-12-15 15:57:15 -0500 | [diff] [blame] | 85 | self.l.append(1) |
| 86 | a = A(destroyed)""" |
Benjamin Peterson | 5c4bfc4 | 2010-10-12 22:57:59 +0000 | [diff] [blame] | 87 | exec(s, m.__dict__) |
| 88 | del m |
| 89 | gc_collect() |
| 90 | self.assertEqual(destroyed, [1]) |
| 91 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 92 | def test_module_repr_minimal(self): |
| 93 | # reprs when modules have no __file__, __name__, or __loader__ |
| 94 | m = ModuleType('foo') |
| 95 | del m.__name__ |
| 96 | self.assertEqual(repr(m), "<module '?'>") |
| 97 | |
| 98 | def test_module_repr_with_name(self): |
| 99 | m = ModuleType('foo') |
| 100 | self.assertEqual(repr(m), "<module 'foo'>") |
| 101 | |
| 102 | def test_module_repr_with_name_and_filename(self): |
| 103 | m = ModuleType('foo') |
| 104 | m.__file__ = '/tmp/foo.py' |
| 105 | self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>") |
| 106 | |
| 107 | def test_module_repr_with_filename_only(self): |
| 108 | m = ModuleType('foo') |
| 109 | del m.__name__ |
| 110 | m.__file__ = '/tmp/foo.py' |
| 111 | self.assertEqual(repr(m), "<module '?' from '/tmp/foo.py'>") |
| 112 | |
| 113 | def test_module_repr_with_bare_loader_but_no_name(self): |
| 114 | m = ModuleType('foo') |
| 115 | del m.__name__ |
| 116 | # Yes, a class not an instance. |
| 117 | m.__loader__ = BareLoader |
| 118 | self.assertEqual( |
| 119 | repr(m), "<module '?' (<class 'test.test_module.BareLoader'>)>") |
| 120 | |
| 121 | def test_module_repr_with_full_loader_but_no_name(self): |
| 122 | # m.__loader__.module_repr() will fail because the module has no |
| 123 | # m.__name__. This exception will get suppressed and instead the |
| 124 | # loader's repr will be used. |
| 125 | m = ModuleType('foo') |
| 126 | del m.__name__ |
| 127 | # Yes, a class not an instance. |
| 128 | m.__loader__ = FullLoader |
| 129 | self.assertEqual( |
| 130 | repr(m), "<module '?' (<class 'test.test_module.FullLoader'>)>") |
| 131 | |
| 132 | def test_module_repr_with_bare_loader(self): |
| 133 | m = ModuleType('foo') |
| 134 | # Yes, a class not an instance. |
| 135 | m.__loader__ = BareLoader |
| 136 | self.assertEqual( |
| 137 | repr(m), "<module 'foo' (<class 'test.test_module.BareLoader'>)>") |
| 138 | |
| 139 | def test_module_repr_with_full_loader(self): |
| 140 | m = ModuleType('foo') |
| 141 | # Yes, a class not an instance. |
| 142 | m.__loader__ = FullLoader |
| 143 | self.assertEqual( |
| 144 | repr(m), "<module 'foo' (crafted)>") |
| 145 | |
| 146 | def test_module_repr_with_bare_loader_and_filename(self): |
| 147 | # Because the loader has no module_repr(), use the file name. |
| 148 | m = ModuleType('foo') |
| 149 | # Yes, a class not an instance. |
| 150 | m.__loader__ = BareLoader |
| 151 | m.__file__ = '/tmp/foo.py' |
| 152 | self.assertEqual(repr(m), "<module 'foo' from '/tmp/foo.py'>") |
| 153 | |
| 154 | def test_module_repr_with_full_loader_and_filename(self): |
| 155 | # Even though the module has an __file__, use __loader__.module_repr() |
| 156 | m = ModuleType('foo') |
| 157 | # Yes, a class not an instance. |
| 158 | m.__loader__ = FullLoader |
| 159 | m.__file__ = '/tmp/foo.py' |
| 160 | self.assertEqual(repr(m), "<module 'foo' (crafted)>") |
| 161 | |
| 162 | def test_module_repr_builtin(self): |
| 163 | self.assertEqual(repr(sys), "<module 'sys' (built-in)>") |
| 164 | |
| 165 | def test_module_repr_source(self): |
| 166 | r = repr(unittest) |
| 167 | self.assertEqual(r[:25], "<module 'unittest' from '") |
| 168 | self.assertEqual(r[-13:], "__init__.py'>") |
| 169 | |
| 170 | # frozen and namespace module reprs are tested in importlib. |
| 171 | |
| 172 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 173 | def test_main(): |
| 174 | run_unittest(ModuleTests) |
| 175 | |
Eric V. Smith | 984b11f | 2012-05-24 20:21:04 -0400 | [diff] [blame] | 176 | |
Guido van Rossum | d8faa36 | 2007-04-27 19:54:29 +0000 | [diff] [blame] | 177 | if __name__ == '__main__': |
| 178 | test_main() |