diff --git a/Lib/test/test_zipfile.py b/Lib/test/test_zipfile.py
index d21a9eb..15f97b5 100644
--- a/Lib/test/test_zipfile.py
+++ b/Lib/test/test_zipfile.py
@@ -1,99 +1,99 @@
-import zlib # implied prerequisite
-import zipfile, os, StringIO, tempfile
-from test.test_support import TestFailed
-
-srcname = "junk9630"+os.extsep+"tmp"
-zipname = "junk9708"+os.extsep+"tmp"
-
-
-def zipTest(f, compression, srccontents):
-    zip = zipfile.ZipFile(f, "w", compression)   # Create the ZIP archive
-    zip.write(srcname, "another"+os.extsep+"name")
-    zip.write(srcname, srcname)
-    zip.close()
-
-    zip = zipfile.ZipFile(f, "r", compression)   # Read the ZIP archive
-    readData2 = zip.read(srcname)
-    readData1 = zip.read("another"+os.extsep+"name")
-    zip.close()
-
-    if readData1 != srccontents or readData2 != srccontents:
-        raise TestFailed, "Written data doesn't equal read data."
-
-
+# We can test part of the module without zlib.
 try:
-    fp = open(srcname, "wb")               # Make a source file with some lines
-    for i in range(0, 1000):
-        fp.write("Test of zipfile line %d.\n" % i)
-    fp.close()
+    import zlib
+except ImportError:
+    zlib = None
+    
+import zipfile, os, unittest
 
-    fp = open(srcname, "rb")
-    writtenData = fp.read()
-    fp.close()
+from StringIO import StringIO
+from tempfile import TemporaryFile
 
-    for file in (zipname, tempfile.TemporaryFile(), StringIO.StringIO()):
-        zipTest(file, zipfile.ZIP_STORED, writtenData)
+from test.test_support import TESTFN, run_unittest
 
-    for file in (zipname, tempfile.TemporaryFile(), StringIO.StringIO()):
-        zipTest(file, zipfile.ZIP_DEFLATED, writtenData)
+TESTFN2 = TESTFN + "2"
 
-finally:
-    if os.path.isfile(srcname):           # Remove temporary files
-        os.unlink(srcname)
-    if os.path.isfile(zipname):
-        os.unlink(zipname)
+class TestsWithSourceFile(unittest.TestCase):
+    def setUp(self):
+        line_gen = ("Test of zipfile line %d." % i for i in range(0, 1000))
+        self.data = '\n'.join(line_gen)
 
+        # Make a source file with some lines
+        fp = open(TESTFN, "wb")
+        fp.write(self.data)
+        fp.close()
 
-# This test checks that the ZipFile constructor closes the file object
-# it opens if there's an error in the file.  If it doesn't, the traceback
-# holds a reference to the ZipFile object and, indirectly, the file object.
-# On Windows, this causes the os.unlink() call to fail because the
-# underlying file is still open.  This is SF bug #412214.
-#
-fp = open(srcname, "w")
-fp.write("this is not a legal zip file\n")
-fp.close()
-try:
-    zf = zipfile.ZipFile(srcname)
-except zipfile.BadZipfile:
-    os.unlink(srcname)
+    def zipTest(self, f, compression):
+        # Create the ZIP archive
+        zipfp = zipfile.ZipFile(f, "w", compression)
+        zipfp.write(TESTFN, "another"+os.extsep+"name")
+        zipfp.write(TESTFN, TESTFN)
+        zipfp.close()
 
+        # Read the ZIP archive
+        zipfp = zipfile.ZipFile(f, "r", compression)
+        self.assertEqual(zipfp.read(TESTFN), self.data)
+        self.assertEqual(zipfp.read("another"+os.extsep+"name"), self.data)
+        zipfp.close()
 
-# make sure we don't raise an AttributeError when a partially-constructed
-# ZipFile instance is finalized; this tests for regression on SF tracker
-# bug #403871.
-try:
-    zipfile.ZipFile(srcname)
-except IOError:
-    # The bug we're testing for caused an AttributeError to be raised
-    # when a ZipFile instance was created for a file that did not
-    # exist; the .fp member was not initialized but was needed by the
-    # __del__() method.  Since the AttributeError is in the __del__(),
-    # it is ignored, but the user should be sufficiently annoyed by
-    # the message on the output that regression will be noticed
-    # quickly.
-    pass
-else:
-    raise TestFailed("expected creation of readable ZipFile without\n"
-                     "  a file to raise an IOError.")
+    def testStored(self):
+        for f in (TESTFN2, TemporaryFile(), StringIO()):
+            self.zipTest(f, zipfile.ZIP_STORED)
 
+    if zlib:
+        def testDeflated(self):
+            for f in (TESTFN2, TemporaryFile(), StringIO()):
+                self.zipTest(f, zipfile.ZIP_DEFLATED)
 
-# Verify that testzip() doesn't swallow inappropriate exceptions.
-data = StringIO.StringIO()
-zipf = zipfile.ZipFile(data, mode="w")
-zipf.writestr("foo.txt", "O, for a Muse of Fire!")
-zipf.close()
-zipf = zipfile.ZipFile(data, mode="r")
-zipf.close()
-try:
-    zipf.testzip()
-except RuntimeError:
-    # This is correct; calling .read on a closed ZipFile should throw
-    # a RuntimeError, and so should calling .testzip.  An earlier
-    # version of .testzip would swallow this exception (and any other)
-    # and report that the first file in the archive was corrupt.
-    pass
-else:
-    raise TestFailed("expected calling .testzip on a closed ZipFile"
-                     " to raise a RuntimeError")
-del data, zipf
+    def tearDown(self):
+        os.remove(TESTFN)
+        os.remove(TESTFN2)
+
+class OtherTests(unittest.TestCase):
+    def testCloseErroneousFile(self):
+        # This test checks that the ZipFile constructor closes the file object
+        # it opens if there's an error in the file.  If it doesn't, the traceback
+        # holds a reference to the ZipFile object and, indirectly, the file object.
+        # On Windows, this causes the os.unlink() call to fail because the
+        # underlying file is still open.  This is SF bug #412214.
+        #
+        fp = open(TESTFN, "w")
+        fp.write("this is not a legal zip file\n")
+        fp.close()
+        try:
+            zf = zipfile.ZipFile(TESTFN)
+        except zipfile.BadZipfile:
+            os.unlink(TESTFN)
+
+    def testNonExistentFileRaisesIOError(self):
+        # make sure we don't raise an AttributeError when a partially-constructed
+        # ZipFile instance is finalized; this tests for regression on SF tracker
+        # bug #403871.
+
+        # The bug we're testing for caused an AttributeError to be raised
+        # when a ZipFile instance was created for a file that did not
+        # exist; the .fp member was not initialized but was needed by the
+        # __del__() method.  Since the AttributeError is in the __del__(),
+        # it is ignored, but the user should be sufficiently annoyed by
+        # the message on the output that regression will be noticed
+        # quickly.
+        self.assertRaises(IOError, zipfile.ZipFile, TESTFN)
+
+    def testClosedZipRaisesRuntimeError(self):
+        # Verify that testzip() doesn't swallow inappropriate exceptions.
+        data = StringIO()
+        zipf = zipfile.ZipFile(data, mode="w")
+        zipf.writestr("foo.txt", "O, for a Muse of Fire!")
+        zipf.close()
+
+        # This is correct; calling .read on a closed ZipFile should throw
+        # a RuntimeError, and so should calling .testzip.  An earlier
+        # version of .testzip would swallow this exception (and any other)
+        # and report that the first file in the archive was corrupt.
+        self.assertRaises(RuntimeError, zipf.testzip)
+
+def test_main():
+    run_unittest(TestsWithSourceFile, OtherTests)
+
+if __name__ == "__main__":
+    test_main()