Convert test_import to unittest.

Lib/test/test_import.py

-from test.test_support import TESTFN, TestFailed
+from test.test_support import TESTFN, run_unittest
 
+import unittest
 import os
 import random
 import sys
 import py_compile
 
-# Brief digression to test that import is case-sensitive:  if we got this
-# far, we know for sure that "random" exists.
-try:
-    import RAnDoM
-except ImportError:
-    pass
-else:
-    raise TestFailed("import of RAnDoM should have failed (case mismatch)")
-
-# Another brief digression to test the accuracy of manifest float constants.
-from test import double_const  # don't blink -- that *was* the test
 
 def remove_files(name):
     for f in (name + os.extsep + "py",
@@ -26,7 +16,26 @@ def remove_files(name):
         if os.path.exists(f):
             os.remove(f)
 
-def test_with_extension(ext): # ext normally ".py"; perhaps ".pyw"
+
+class ImportTest(unittest.TestCase):
+    
+    def testCaseSensitivity(self):
+        # Brief digression to test that import is case-sensitive:  if we got this
+        # far, we know for sure that "random" exists.
+        try:
+            import RAnDoM
+        except ImportError:
+            pass
+        else:
+            self.fail("import of RAnDoM should have failed (case mismatch)")
+
+    def testDoubleConst(self):
+        # Another brief digression to test the accuracy of manifest float constants.
+        from test import double_const  # don't blink -- that *was* the test
+
+    def testImport(self):
+        def test_with_extension(ext):
+            # ext normally ".py"; perhaps ".pyw"
             source = TESTFN + ext
             pyo = TESTFN + os.extsep + "pyo"
             if sys.platform.startswith('java'):
@@ -46,12 +55,12 @@ def test_with_extension(ext): # ext normally ".py"; perhaps ".pyw"
                 try:
                     mod = __import__(TESTFN)
                 except ImportError, err:
-            raise ValueError("import from %s failed: %s" % (ext, err))
+                    self.fail("import from %s failed: %s" % (ext, err))
                 
-        if mod.a != a or mod.b != b:
-            print a, "!=", mod.a
-            print b, "!=", mod.b
-            raise ValueError("module loaded (%s) but contents invalid" % mod)
+                self.assertEquals(mod.a, a,
+                    "module loaded (%s) but contents invalid" % mod)
+                self.assertEquals(mod.b, b,
+                    "module loaded (%s) but contents invalid" % mod)
             finally:
                 os.unlink(source)
 
@@ -59,33 +68,34 @@ def test_with_extension(ext): # ext normally ".py"; perhaps ".pyw"
                 try:
                     reload(mod)
                 except ImportError, err:
-            raise ValueError("import from .pyc/.pyo failed: %s" % err)
+                    self.fail("import from .pyc/.pyo failed: %s" % err)
             finally:
                 try:
                     os.unlink(pyc)
-        except os.error:
+                except OSError:
                     pass
                 try:
                     os.unlink(pyo)
-        except os.error:
+                except OSError:
                     pass
                 del sys.modules[TESTFN]
 
-sys.path.insert(0, os.curdir)
-try:
+        sys.path.insert(0, os.curdir)
+        try:
             test_with_extension(os.extsep + "py")
             if sys.platform.startswith("win"):
                 for ext in ".PY", ".Py", ".pY", ".pyw", ".PYW", ".pYw":
                     test_with_extension(ext)
-finally:
+        finally:
             del sys.path[0]
 
-# Verify that the imp module can correctly load and find .py files
-import imp
-x = imp.find_module("os")
-os = imp.load_module("os", *x)
+    def testImpModule(self):
+        # Verify that the imp module can correctly load and find .py files
+        import imp
+        x = imp.find_module("os")
+        os = imp.load_module("os", *x)
 
-def test_module_with_large_stack(module):
+    def test_module_with_large_stack(self, module='longlist'):
         # create module w/list of 65000 elements to test bug #561858
         filename = module + os.extsep + 'py'
 
@@ -116,9 +126,7 @@ def test_module_with_large_stack(module):
             if os.path.exists(fname):
                 os.unlink(fname)
 
-test_module_with_large_stack('longlist')
-
-def test_failing_import_sticks():
+    def test_failing_import_sticks(self):
         source = TESTFN + os.extsep + "py"
         f = open(source, "w")
         print >> f, "a = 1/0"
@@ -133,16 +141,14 @@ def test_failing_import_sticks():
                     mod = __import__(TESTFN)
                 except ZeroDivisionError:
                     if TESTFN in sys.modules:
-                    raise TestFailed("damaged module in sys.modules", i)
+                        self.fail("damaged module in sys.modules on %i. try" % i)
                 else:
-                raise TestFailed("was able to import a damaged module", i)
+                    self.fail("was able to import a damaged module on %i. try" % i)
         finally:
             sys.path.pop(0)
             remove_files(TESTFN)
 
-test_failing_import_sticks()
-
-def test_failing_reload():
+    def test_failing_reload(self):
         # A failing reload should leave the module object in sys.modules.
         source = TESTFN + os.extsep + "py"
         f = open(source, "w")
@@ -153,10 +159,9 @@ def test_failing_reload():
         sys.path.insert(0, os.curdir)
         try:
             mod = __import__(TESTFN)
-        if TESTFN not in sys.modules:
-            raise TestFailed("expected module in sys.modules")
-        if mod.a != 1 or mod.b != 2:
-            raise TestFailed("module has wrong attribute values")
+            self.assert_(TESTFN in sys.modules, "expected module in sys.modules")
+            self.assertEquals(mod.a, 1, "module has wrong attribute values")
+            self.assertEquals(mod.b, 2, "module has wrong attribute values")
 
             # On WinXP, just replacing the .py file wasn't enough to
             # convince reload() to reparse it.  Maybe the timestamp didn't
@@ -169,21 +174,17 @@ def test_failing_reload():
             print >> f, "a = 10"
             print >> f, "b = 20//0"
             f.close()
-        try:
-            reload(mod)
-        except ZeroDivisionError:
-            pass
-        else:
-            raise TestFailed("was able to reload a damaged module")
+
+            self.assertRaises(ZeroDivisionError, reload, mod)
 
             # But we still expect the module to be in sys.modules.
             mod = sys.modules.get(TESTFN)
-        if mod is None:
-            raise TestFailed("expected module to still be in sys.modules")
+            self.failIf(mod is None, "expected module to still be in sys.modules")
+
             # We should have replaced a w/ 10, but the old b value should
             # stick.
-        if mod.a != 10 or mod.b != 2:
-            raise TestFailed("module has wrong attribute values")
+            self.assertEquals(mod.a, 10, "module has wrong attribute values")
+            self.assertEquals(mod.b, 2, "module has wrong attribute values")
 
         finally:
             sys.path.pop(0)
@@ -191,34 +192,30 @@ def test_failing_reload():
             if TESTFN in sys.modules:
                 del sys.modules[TESTFN]
 
-test_failing_reload()
-
-def test_import_name_binding():
+    def test_import_name_binding(self):
         # import x.y.z binds x in the current namespace
         import test as x
         import test.test_support
-    assert x is test, x.__name__
-    assert hasattr(test.test_support, "__file__")
+        self.assert_(x is test, x.__name__)
+        self.assert_(hasattr(test.test_support, "__file__"))
 
         # import x.y.z as w binds z as w
         import test.test_support as y
-    assert y is test.test_support, y.__name__
-
-test_import_name_binding()
+        self.assert_(y is test.test_support, y.__name__)
 
-def test_import_initless_directory_warning():
+    def test_import_initless_directory_warning(self):
         import warnings
         oldfilters = warnings.filters[:]
         warnings.simplefilter('error', ImportWarning);
         try:
             # Just a random non-package directory we always expect to be
             # somewhere in sys.path...
-        __import__("site-packages")
-    except ImportWarning:
-        pass
-    else:
-        raise AssertionError
+            self.assertRaises(ImportWarning, __import__, "site-packages")
         finally:
             warnings.filters = oldfilters
 
-test_import_initless_directory_warning()
+def test_main(verbose=None):
+    run_unittest(ImportTest)
+
+if __name__ == '__main__':
+    test_main()