Using appropriate checks in tests

Lib/test/test_module.py

 # Test the module type
 import unittest
 import weakref
 from test.support import run_unittest, gc_collect
 from test.script_helper import assert_python_ok
 
 import sys
 ModuleType = type(sys)
 
 class FullLoader:
@@ skipping 19 matching lines @@
             pass
         self.assertEqual(foo.__doc__, ModuleType.__doc__)
 
     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})
+                                        "__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})
+                          "__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})
+                          "__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})
+               "__loader__": None, "__package__": None, "__spec__": None})
         self.assertIs(foo.__dict__, 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)
@@ skipping 97 matching lines @@
         # 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)
-        self.assertEqual(r[:25], "<module 'unittest' from '")
-        self.assertEqual(r[-13:], "__init__.py'>")
+        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"})
 
     # frozen and namespace module reprs are tested in importlib.
 
 
 def test_main():
     run_unittest(ModuleTests)
 
 
 if __name__ == '__main__':
     test_main()