Merged revisions 61913,61915-61916,61918-61919,61922-61926,61928-61929,61931,61935,61938,61943 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r61913 | benjamin.peterson | 2008-03-25 22:14:42 +0100 (Tue, 25 Mar 2008) | 2 lines

  Merged the ACKS from py3k
........
  r61915 | thomas.heller | 2008-03-25 22:18:39 +0100 (Tue, 25 Mar 2008) | 1 line

  Make _ctypes.c PY_SSIZE_T_CLEAN.
........
  r61916 | benjamin.peterson | 2008-03-25 22:55:50 +0100 (Tue, 25 Mar 2008) | 3 lines

  Opps! I merged the revisions, but forgot to add
  the header to ACKS
........
  r61918 | andrew.kuchling | 2008-03-26 01:16:50 +0100 (Wed, 26 Mar 2008) | 1 line

  Minor docstring typos
........
  r61919 | andrew.kuchling | 2008-03-26 01:30:02 +0100 (Wed, 26 Mar 2008) | 1 line

  Add various items
........
  r61922 | neal.norwitz | 2008-03-26 05:55:51 +0100 (Wed, 26 Mar 2008) | 6 lines

  Try to get this test to be less flaky.  It was failing sometimes because
  the connect would succeed before the timeout occurred.  Try using an
  address and port that hopefully doesn't exist to ensure we get no response.
  If this doesn't work, we can use a public address close to python.org
  and hopefully that address never gets taken.
........
  r61923 | jerry.seutter | 2008-03-26 06:03:03 +0100 (Wed, 26 Mar 2008) | 1 line

  Changed test so it no longer runs as a side effect of importing.
........
  r61924 | neal.norwitz | 2008-03-26 06:19:41 +0100 (Wed, 26 Mar 2008) | 5 lines

  Ensure that the mailbox is closed to prevent problems on Windows with removing
  an open file.  This doesn't seem to be a problem in 2.6, but that appears
  to be somewhat accidental (specific to reference counting).  When this
  gets merged to 3.0, it will make the 3.0 code simpler.
........
  r61925 | jerry.seutter | 2008-03-26 06:32:51 +0100 (Wed, 26 Mar 2008) | 1 line

  Changed test so it no longer runs as a side effect of importing.
........
  r61926 | jerry.seutter | 2008-03-26 06:58:14 +0100 (Wed, 26 Mar 2008) | 1 line

  Changed test so it no longer runs as a side effect of importing.
........
  r61928 | georg.brandl | 2008-03-26 10:04:36 +0100 (Wed, 26 Mar 2008) | 2 lines

  Add Josiah.
........
  r61929 | georg.brandl | 2008-03-26 10:32:46 +0100 (Wed, 26 Mar 2008) | 2 lines

  Add an example for an RFC 822 continuation.
........
  r61931 | benjamin.peterson | 2008-03-26 12:57:47 +0100 (Wed, 26 Mar 2008) | 2 lines

  Added help options to PDB
........
  r61935 | christian.heimes | 2008-03-26 13:32:49 +0100 (Wed, 26 Mar 2008) | 1 line

  Prepare integration of bytearray backport branch
........
  r61938 | christian.heimes | 2008-03-26 13:50:43 +0100 (Wed, 26 Mar 2008) | 3 lines

  Removed merge tracking for "svnmerge" for
  svn+ssh://pythondev@svn.python.org/python/branches/trunk-bytearray
........
  r61943 | georg.brandl | 2008-03-26 13:57:47 +0100 (Wed, 26 Mar 2008) | 2 lines

  Fix and simplify error handling, silencing a compiler warning.
........

6 files changed, 419 insertions, 389 deletions

diff --git a/Lib/pdb.py b/Lib/pdb.py
index 29746d7..a6355ec 100755
--- a/Lib/pdb.py
+++ b/Lib/pdb.py
@@ -1233,7 +1233,7 @@ def help():
         print('along the Python search path')
 
 def main():
-    if not sys.argv[1:]:
+    if not sys.argv[1:] or sys.argv[1] in ("--help", "-h"):
         print("usage: pdb.py scriptfile [arg] ...")
         sys.exit(2)
 
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
index 53e7d04..cbb7be8 100644
--- a/Lib/test/test_format.py
+++ b/Lib/test/test_format.py
@@ -1,7 +1,9 @@
 from test.test_support import verbose, TestFailed
 import sys
-from test.test_support import MAX_Py_ssize_t
-maxsize = MAX_Py_ssize_t
+import test.test_support as test_support
+import unittest
+
+maxsize = test_support.MAX_Py_ssize_t
 
 # test string formatting operator (I am not sure if this is being tested
 # elsewhere but, surely, some of the given cases are *not* tested because
@@ -33,8 +35,10 @@ def testformat(formatstr, args, output=None, limit=None):
         elif output and limit is None and result != output:
             if verbose:
                 print('no')
-            print("%r %% %r == %r != %r" %\
-                (formatstr, args, result, output))
+            #print("%r %% %r == %r != %r" %\
+            #    (formatstr, args, result, output))
+            raise AssertionError("%r %% %r == %r != %r" %
+                                (formatstr, args, result, output))
         # when 'limit' is specified, it determines how many characters
         # must match exactly; lengths must always match.
         # ex: limit=5, '12345678' matches '12345___'
@@ -50,207 +54,210 @@ def testformat(formatstr, args, output=None, limit=None):
             if verbose:
                 print('yes')
 
-testformat("%.1d", (1,), "1")
-testformat("%.*d", (sys.maxsize,1))  # expect overflow
-testformat("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-testformat("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-testformat("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-
-testformat("%f", (1.0,), "1.000000")
-# these are trying to test the limits of the internal magic-number-length
-# formatting buffer, if that number changes then these tests are less
-# effective
-testformat("%#.*g", (109, -1.e+49/3.))
-testformat("%#.*g", (110, -1.e+49/3.))
-testformat("%#.*g", (110, -1.e+100/3.))
-
-# test some ridiculously large precision, expect overflow
-testformat('%12.*f', (123456, 1.0))
-
-# check for internal overflow validation on length of precision
-overflowrequired = 1
-testformat("%#.*g", (110, -1.e+100/3.))
-testformat("%#.*G", (110, -1.e+100/3.))
-testformat("%#.*f", (110, -1.e+100/3.))
-testformat("%#.*F", (110, -1.e+100/3.))
-overflowrequired = 0
-
-# Formatting of long integers. Overflow is not ok
-overflowok = 0
-testformat("%x", 10, "a")
-testformat("%x", 100000000000, "174876e800")
-testformat("%o", 10, "12")
-testformat("%o", 100000000000, "1351035564000")
-testformat("%d", 10, "10")
-testformat("%d", 100000000000, "100000000000")
-
-big = 123456789012345678901234567890
-testformat("%d", big, "123456789012345678901234567890")
-testformat("%d", -big, "-123456789012345678901234567890")
-testformat("%5d", -big, "-123456789012345678901234567890")
-testformat("%31d", -big, "-123456789012345678901234567890")
-testformat("%32d", -big, " -123456789012345678901234567890")
-testformat("%-32d", -big, "-123456789012345678901234567890 ")
-testformat("%032d", -big, "-0123456789012345678901234567890")
-testformat("%-032d", -big, "-123456789012345678901234567890 ")
-testformat("%034d", -big, "-000123456789012345678901234567890")
-testformat("%034d", big, "0000123456789012345678901234567890")
-testformat("%0+34d", big, "+000123456789012345678901234567890")
-testformat("%+34d", big, "   +123456789012345678901234567890")
-testformat("%34d", big, "    123456789012345678901234567890")
-testformat("%.2d", big, "123456789012345678901234567890")
-testformat("%.30d", big, "123456789012345678901234567890")
-testformat("%.31d", big, "0123456789012345678901234567890")
-testformat("%32.31d", big, " 0123456789012345678901234567890")
-testformat("%d", float(big), "123456________________________", 6)
-
-big = 0x1234567890abcdef12345  # 21 hex digits
-testformat("%x", big, "1234567890abcdef12345")
-testformat("%x", -big, "-1234567890abcdef12345")
-testformat("%5x", -big, "-1234567890abcdef12345")
-testformat("%22x", -big, "-1234567890abcdef12345")
-testformat("%23x", -big, " -1234567890abcdef12345")
-testformat("%-23x", -big, "-1234567890abcdef12345 ")
-testformat("%023x", -big, "-01234567890abcdef12345")
-testformat("%-023x", -big, "-1234567890abcdef12345 ")
-testformat("%025x", -big, "-0001234567890abcdef12345")
-testformat("%025x", big, "00001234567890abcdef12345")
-testformat("%0+25x", big, "+0001234567890abcdef12345")
-testformat("%+25x", big, "   +1234567890abcdef12345")
-testformat("%25x", big, "    1234567890abcdef12345")
-testformat("%.2x", big, "1234567890abcdef12345")
-testformat("%.21x", big, "1234567890abcdef12345")
-testformat("%.22x", big, "01234567890abcdef12345")
-testformat("%23.22x", big, " 01234567890abcdef12345")
-testformat("%-23.22x", big, "01234567890abcdef12345 ")
-testformat("%X", big, "1234567890ABCDEF12345")
-testformat("%#X", big, "0X1234567890ABCDEF12345")
-testformat("%#x", big, "0x1234567890abcdef12345")
-testformat("%#x", -big, "-0x1234567890abcdef12345")
-testformat("%#.23x", -big, "-0x001234567890abcdef12345")
-testformat("%#+.23x", big, "+0x001234567890abcdef12345")
-testformat("%# .23x", big, " 0x001234567890abcdef12345")
-testformat("%#+.23X", big, "+0X001234567890ABCDEF12345")
-testformat("%#-+.23X", big, "+0X001234567890ABCDEF12345")
-testformat("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
-testformat("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
-testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
-# next one gets two leading zeroes from precision, and another from the
-# 0 flag and the width
-testformat("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
-# same, except no 0 flag
-testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
-testformat("%x", float(big), "123456_______________", 6)
-
-big = 0o12345670123456701234567012345670  # 32 octal digits
-testformat("%o", big, "12345670123456701234567012345670")
-testformat("%o", -big, "-12345670123456701234567012345670")
-testformat("%5o", -big, "-12345670123456701234567012345670")
-testformat("%33o", -big, "-12345670123456701234567012345670")
-testformat("%34o", -big, " -12345670123456701234567012345670")
-testformat("%-34o", -big, "-12345670123456701234567012345670 ")
-testformat("%034o", -big, "-012345670123456701234567012345670")
-testformat("%-034o", -big, "-12345670123456701234567012345670 ")
-testformat("%036o", -big, "-00012345670123456701234567012345670")
-testformat("%036o", big, "000012345670123456701234567012345670")
-testformat("%0+36o", big, "+00012345670123456701234567012345670")
-testformat("%+36o", big, "   +12345670123456701234567012345670")
-testformat("%36o", big, "    12345670123456701234567012345670")
-testformat("%.2o", big, "12345670123456701234567012345670")
-testformat("%.32o", big, "12345670123456701234567012345670")
-testformat("%.33o", big, "012345670123456701234567012345670")
-testformat("%34.33o", big, " 012345670123456701234567012345670")
-testformat("%-34.33o", big, "012345670123456701234567012345670 ")
-testformat("%o", big, "12345670123456701234567012345670")
-testformat("%#o", big, "0o12345670123456701234567012345670")
-testformat("%#o", -big, "-0o12345670123456701234567012345670")
-testformat("%#.34o", -big, "-0o0012345670123456701234567012345670")
-testformat("%#+.34o", big, "+0o0012345670123456701234567012345670")
-testformat("%# .34o", big, " 0o0012345670123456701234567012345670")
-testformat("%#-+.34o", big, "+0o0012345670123456701234567012345670")
-testformat("%#-+39.34o", big, "+0o0012345670123456701234567012345670  ")
-testformat("%#+39.34o", big, "  +0o0012345670123456701234567012345670")
-# next one gets one leading zero from precision
-testformat("%.33o", big, "012345670123456701234567012345670")
-# one leading zero from precision
-testformat("%#.33o", big, "0o012345670123456701234567012345670")
-# leading zero vanishes
-testformat("%#.32o", big, "0o12345670123456701234567012345670")
-# one leading zero from precision, and another from '0' flag & width
-testformat("%034.33o", big, "0012345670123456701234567012345670")
-# max width includes base marker; padding zeroes come after marker
-testformat("%0#38.33o", big, "0o000012345670123456701234567012345670")
-# padding spaces come before marker
-testformat("%#36.33o", big, " 0o012345670123456701234567012345670")
-testformat("%o", float(big), "123456__________________________", 6)
 
-# Some small ints, in both Python int and long flavors).
-testformat("%d", 42, "42")
-testformat("%d", -42, "-42")
-testformat("%#x", 1, "0x1")
-testformat("%#X", 1, "0X1")
-testformat("%#o", 1, "0o1")
-testformat("%#o", 1, "0o1")
-testformat("%#o", 0, "0o0")
-testformat("%#o", 0, "0o0")
-testformat("%o", 0, "0")
-testformat("%d", 0, "0")
-testformat("%#x", 0, "0x0")
-testformat("%#X", 0, "0X0")
+class FormatTest(unittest.TestCase):
+    def test_format(self):
+        testformat("%.1d", (1,), "1")
+        testformat("%.*d", (sys.maxsize,1))  # expect overflow
+        testformat("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
+        testformat("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
+        testformat("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
 
-testformat("%x", 0x42, "42")
-testformat("%x", -0x42, "-42")
-testformat("%x", float(0x42), "42")
+        testformat("%f", (1.0,), "1.000000")
+        # these are trying to test the limits of the internal magic-number-length
+        # formatting buffer, if that number changes then these tests are less
+        # effective
+        testformat("%#.*g", (109, -1.e+49/3.))
+        testformat("%#.*g", (110, -1.e+49/3.))
+        testformat("%#.*g", (110, -1.e+100/3.))
+        # test some ridiculously large precision, expect overflow
+        testformat('%12.*f', (123456, 1.0))
+        # check for internal overflow validation on length of precision
+        overflowrequired = 1
+        testformat("%#.*g", (110, -1.e+100/3.))
+        testformat("%#.*G", (110, -1.e+100/3.))
+        testformat("%#.*f", (110, -1.e+100/3.))
+        testformat("%#.*F", (110, -1.e+100/3.))
+        overflowrequired = 0
+        # Formatting of integers. Overflow is not ok
+        overflowok = 0
+        testformat("%x", 10, "a")
+        testformat("%x", 100000000000, "174876e800")
+        testformat("%o", 10, "12")
+        testformat("%o", 100000000000, "1351035564000")
+        testformat("%d", 10, "10")
+        testformat("%d", 100000000000, "100000000000")
+        big = 123456789012345678901234567890
+        testformat("%d", big, "123456789012345678901234567890")
+        testformat("%d", -big, "-123456789012345678901234567890")
+        testformat("%5d", -big, "-123456789012345678901234567890")
+        testformat("%31d", -big, "-123456789012345678901234567890")
+        testformat("%32d", -big, " -123456789012345678901234567890")
+        testformat("%-32d", -big, "-123456789012345678901234567890 ")
+        testformat("%032d", -big, "-0123456789012345678901234567890")
+        testformat("%-032d", -big, "-123456789012345678901234567890 ")
+        testformat("%034d", -big, "-000123456789012345678901234567890")
+        testformat("%034d", big, "0000123456789012345678901234567890")
+        testformat("%0+34d", big, "+000123456789012345678901234567890")
+        testformat("%+34d", big, "   +123456789012345678901234567890")
+        testformat("%34d", big, "    123456789012345678901234567890")
+        testformat("%.2d", big, "123456789012345678901234567890")
+        testformat("%.30d", big, "123456789012345678901234567890")
+        testformat("%.31d", big, "0123456789012345678901234567890")
+        testformat("%32.31d", big, " 0123456789012345678901234567890")
+        testformat("%d", float(big), "123456________________________", 6)
+        big = 0x1234567890abcdef12345  # 21 hex digits
+        testformat("%x", big, "1234567890abcdef12345")
+        testformat("%x", -big, "-1234567890abcdef12345")
+        testformat("%5x", -big, "-1234567890abcdef12345")
+        testformat("%22x", -big, "-1234567890abcdef12345")
+        testformat("%23x", -big, " -1234567890abcdef12345")
+        testformat("%-23x", -big, "-1234567890abcdef12345 ")
+        testformat("%023x", -big, "-01234567890abcdef12345")
+        testformat("%-023x", -big, "-1234567890abcdef12345 ")
+        testformat("%025x", -big, "-0001234567890abcdef12345")
+        testformat("%025x", big, "00001234567890abcdef12345")
+        testformat("%0+25x", big, "+0001234567890abcdef12345")
+        testformat("%+25x", big, "   +1234567890abcdef12345")
+        testformat("%25x", big, "    1234567890abcdef12345")
+        testformat("%.2x", big, "1234567890abcdef12345")
+        testformat("%.21x", big, "1234567890abcdef12345")
+        testformat("%.22x", big, "01234567890abcdef12345")
+        testformat("%23.22x", big, " 01234567890abcdef12345")
+        testformat("%-23.22x", big, "01234567890abcdef12345 ")
+        testformat("%X", big, "1234567890ABCDEF12345")
+        testformat("%#X", big, "0X1234567890ABCDEF12345")
+        testformat("%#x", big, "0x1234567890abcdef12345")
+        testformat("%#x", -big, "-0x1234567890abcdef12345")
+        testformat("%#.23x", -big, "-0x001234567890abcdef12345")
+        testformat("%#+.23x", big, "+0x001234567890abcdef12345")
+        testformat("%# .23x", big, " 0x001234567890abcdef12345")
+        testformat("%#+.23X", big, "+0X001234567890ABCDEF12345")
+        testformat("%#-+.23X", big, "+0X001234567890ABCDEF12345")
+        testformat("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
+        testformat("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
+        testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
+        # next one gets two leading zeroes from precision, and another from the
+        # 0 flag and the width
+        testformat("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
+        # same, except no 0 flag
+        testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
+        testformat("%x", float(big), "123456_______________", 6)
+        big = 0o12345670123456701234567012345670  # 32 octal digits
+        testformat("%o", big, "12345670123456701234567012345670")
+        testformat("%o", -big, "-12345670123456701234567012345670")
+        testformat("%5o", -big, "-12345670123456701234567012345670")
+        testformat("%33o", -big, "-12345670123456701234567012345670")
+        testformat("%34o", -big, " -12345670123456701234567012345670")
+        testformat("%-34o", -big, "-12345670123456701234567012345670 ")
+        testformat("%034o", -big, "-012345670123456701234567012345670")
+        testformat("%-034o", -big, "-12345670123456701234567012345670 ")
+        testformat("%036o", -big, "-00012345670123456701234567012345670")
+        testformat("%036o", big, "000012345670123456701234567012345670")
+        testformat("%0+36o", big, "+00012345670123456701234567012345670")
+        testformat("%+36o", big, "   +12345670123456701234567012345670")
+        testformat("%36o", big, "    12345670123456701234567012345670")
+        testformat("%.2o", big, "12345670123456701234567012345670")
+        testformat("%.32o", big, "12345670123456701234567012345670")
+        testformat("%.33o", big, "012345670123456701234567012345670")
+        testformat("%34.33o", big, " 012345670123456701234567012345670")
+        testformat("%-34.33o", big, "012345670123456701234567012345670 ")
+        testformat("%o", big, "12345670123456701234567012345670")
+        testformat("%#o", big, "0o12345670123456701234567012345670")
+        testformat("%#o", -big, "-0o12345670123456701234567012345670")
+        testformat("%#.34o", -big, "-0o0012345670123456701234567012345670")
+        testformat("%#+.34o", big, "+0o0012345670123456701234567012345670")
+        testformat("%# .34o", big, " 0o0012345670123456701234567012345670")
+        testformat("%#+.34o", big, "+0o0012345670123456701234567012345670")
+        testformat("%#-+.34o", big, "+0o0012345670123456701234567012345670")
+        testformat("%#-+37.34o", big, "+0o0012345670123456701234567012345670")
+        testformat("%#+37.34o", big, "+0o0012345670123456701234567012345670")
+        # next one gets one leading zero from precision
+        testformat("%.33o", big, "012345670123456701234567012345670")
+        # base marker shouldn't change that, since "0" is redundant
+        testformat("%#.33o", big, "0o012345670123456701234567012345670")
+        # but reduce precision, and base marker should add a zero
+        testformat("%#.32o", big, "0o12345670123456701234567012345670")
+        # one leading zero from precision, and another from "0" flag & width
+        testformat("%034.33o", big, "0012345670123456701234567012345670")
+        # base marker shouldn't change that
+        testformat("%0#34.33o", big, "0o012345670123456701234567012345670")
+        testformat("%o", float(big), "123456__________________________", 6)
+        # Some small ints, in both Python int and flavors).
+        testformat("%d", 42, "42")
+        testformat("%d", -42, "-42")
+        testformat("%d", 42, "42")
+        testformat("%d", -42, "-42")
+        testformat("%d", 42.0, "42")
+        testformat("%#x", 1, "0x1")
+        testformat("%#x", 1, "0x1")
+        testformat("%#X", 1, "0X1")
+        testformat("%#X", 1, "0X1")
+        testformat("%#x", 1.0, "0x1")
+        testformat("%#o", 1, "0o1")
+        testformat("%#o", 1, "0o1")
+        testformat("%#o", 0, "0o0")
+        testformat("%#o", 0, "0o0")
+        testformat("%o", 0, "0")
+        testformat("%o", 0, "0")
+        testformat("%d", 0, "0")
+        testformat("%d", 0, "0")
+        testformat("%#x", 0, "0x0")
+        testformat("%#x", 0, "0x0")
+        testformat("%#X", 0, "0X0")
+        testformat("%#X", 0, "0X0")
+        testformat("%x", 0x42, "42")
+        testformat("%x", -0x42, "-42")
+        testformat("%x", 0x42, "42")
+        testformat("%x", -0x42, "-42")
+        testformat("%x", float(0x42), "42")
+        testformat("%o", 0o42, "42")
+        testformat("%o", -0o42, "-42")
+        testformat("%o", 0o42, "42")
+        testformat("%o", -0o42, "-42")
+        testformat("%o", float(0o42), "42")
+        # Test exception for unknown format characters
+        if verbose:
+            print('Testing exceptions')
+        def test_exc(formatstr, args, exception, excmsg):
+            try:
+                testformat(formatstr, args)
+            except exception as exc:
+                if str(exc) == excmsg:
+                    if verbose:
+                        print("yes")
+                else:
+                    if verbose: print('no')
+                    print('Unexpected ', exception, ':', repr(str(exc)))
+            except:
+                if verbose: print('no')
+                print('Unexpected exception')
+                raise
+            else:
+                raise TestFailed('did not get expected exception: %s' % excmsg)
+        test_exc('abc %a', 1, ValueError,
+                 "unsupported format character 'a' (0x61) at index 5")
+        #test_exc(unicode('abc %\u3000','raw-unicode-escape'), 1, ValueError,
+        #         "unsupported format character '?' (0x3000) at index 5")
+        test_exc('%d', '1', TypeError, "%d format: a number is required, not str")
+        test_exc('%g', '1', TypeError, "a float is required")
+        test_exc('no format', '1', TypeError,
+                 "not all arguments converted during string formatting")
+        test_exc('no format', '1', TypeError,
+                 "not all arguments converted during string formatting")
 
-testformat("%o", 0o42, "42")
-testformat("%o", -0o42, "-42")
-testformat("%o", 0o42, "42")
-testformat("%o", -0o42, "-42")
-testformat("%o", float(0o42), "42")
+        if maxsize == 2**31-1:
+            # crashes 2.2.1 and earlier:
+            try:
+                "%*d"%(maxsize, -127)
+            except MemoryError:
+                pass
+            else:
+                raise TestFailed('"%*d"%(maxsize, -127) should fail')
 
-# Test exception for unknown format characters
-if verbose:
-    print('Testing exceptions')
+def test_main():
+    test_support.run_unittest(FormatTest)
 
-def test_exc(formatstr, args, exception, excmsg):
-    try:
-        testformat(formatstr, args)
-    except exception as exc:
-        if str(exc) == excmsg:
-            if verbose:
-                print("yes")
-        else:
-            if verbose: print('no')
-            print('Unexpected ', exception, ':', repr(str(exc)))
-    except:
-        if verbose: print('no')
-        print('Unexpected exception')
-        raise
-    else:
-        raise TestFailed('did not get expected exception: %s' % excmsg)
 
-test_exc('abc %a', 1, ValueError,
-         "unsupported format character 'a' (0x61) at index 5")
-test_exc(str(b'abc %\u3000', 'raw-unicode-escape'), 1, ValueError,
-         "unsupported format character '?' (0x3000) at index 5")
-
-#test_exc('%d', '1', TypeError, "an integer is required")
-test_exc('%d', '1', TypeError, '%d format: a number is required, not str')
-test_exc('%g', '1', TypeError, "a float is required")
-test_exc('no format', '1', TypeError,
-         "not all arguments converted during string formatting")
-test_exc('no format', '1', TypeError,
-         "not all arguments converted during string formatting")
-test_exc('no format', '1', TypeError,
-         "not all arguments converted during string formatting")
-test_exc('no format', '1', TypeError,
-         "not all arguments converted during string formatting")
-
-if maxsize == 2**31-1:
-    # crashes 2.2.1 and earlier:
-    try:
-        "%*d"%(maxsize, -127)
-    except MemoryError:
-        pass
-    else:
-        raise TestFailed('"%*d"%(maxsize, -127) should fail')
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py
index 78bb613..ce0e075 100644
--- a/Lib/test/test_imaplib.py
+++ b/Lib/test/test_imaplib.py
@@ -1,12 +1,25 @@
 import imaplib
 import time
 
-# We can check only that it successfully produces a result,
-# not the correctness of the result itself, since the result
-# depends on the timezone the machine is in.
+from test import test_support
+import unittest
 
-timevalues = [2000000000, 2000000000.0, time.localtime(2000000000),
-              '"18-May-2033 05:33:20 +0200"']
 
-for t in timevalues:
-    imaplib.Time2Internaldate(t)
+class TestImaplib(unittest.TestCase):
+    def test_that_Time2Internaldate_returns_a_result(self):
+        # We can check only that it successfully produces a result,
+        # not the correctness of the result itself, since the result
+        # depends on the timezone the machine is in.
+        timevalues = [2000000000, 2000000000.0, time.localtime(2000000000),
+                      '"18-May-2033 05:33:20 +0200"']
+
+        for t in timevalues:
+            imaplib.Time2Internaldate(t)
+
+
+def test_main():
+    test_support.run_unittest(TestImaplib)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py
index 925f878..8f4b486 100644
--- a/Lib/test/test_mailbox.py
+++ b/Lib/test/test_mailbox.py
@@ -374,7 +374,7 @@ class TestMailbox(TestBase):
 
     def test_flush(self):
         # Write changes to disk
-        self._test_flush_or_close(self._box.flush)
+        self._test_flush_or_close(self._box.flush, True)
 
     def test_lock_unlock(self):
         # Lock and unlock the mailbox
@@ -386,15 +386,17 @@ class TestMailbox(TestBase):
 
     def test_close(self):
         # Close mailbox and flush changes to disk
-        self._test_flush_or_close(self._box.close)
+        self._test_flush_or_close(self._box.close, False)
 
-    def _test_flush_or_close(self, method):
+    def _test_flush_or_close(self, method, should_call_close):
         contents = [self._template % i for i in range(3)]
         self._box.add(contents[0])
         self._box.add(contents[1])
         self._box.add(contents[2])
         oldbox = self._box
         method()
+        if should_call_close:
+            self._box.close()
         self._box = self._factory(self._path)
         keys = self._box.keys()
         self.assertEqual(len(keys), 3)
diff --git a/Lib/test/test_ntpath.py b/Lib/test/test_ntpath.py
index 3c05e63..627b167 100644
--- a/Lib/test/test_ntpath.py
+++ b/Lib/test/test_ntpath.py
@@ -1,174 +1,187 @@
 import ntpath
-from test.test_support import verbose, TestFailed
 import os
+from test.test_support import verbose, TestFailed
+import test.test_support as test_support
+import unittest
 
-errors = 0
 
 def tester(fn, wantResult):
-    global errors
     fn = fn.replace("\\", "\\\\")
     gotResult = eval(fn)
     if wantResult != gotResult:
-        print("error!")
-        print("evaluated: " + str(fn))
-        print("should be: " + str(wantResult))
-        print(" returned: " + str(gotResult))
-        print("")
-        errors = errors + 1
-
-tester('ntpath.splitext("foo.ext")', ('foo', '.ext'))
-tester('ntpath.splitext("/foo/foo.ext")', ('/foo/foo', '.ext'))
-tester('ntpath.splitext(".ext")', ('.ext', ''))
-tester('ntpath.splitext("\\foo.ext\\foo")', ('\\foo.ext\\foo', ''))
-tester('ntpath.splitext("foo.ext\\")', ('foo.ext\\', ''))
-tester('ntpath.splitext("")', ('', ''))
-tester('ntpath.splitext("foo.bar.ext")', ('foo.bar', '.ext'))
-tester('ntpath.splitext("xx/foo.bar.ext")', ('xx/foo.bar', '.ext'))
-tester('ntpath.splitext("xx\\foo.bar.ext")', ('xx\\foo.bar', '.ext'))
-tester('ntpath.splitext("c:a/b\\c.d")', ('c:a/b\\c', '.d'))
-
-tester('ntpath.splitdrive("c:\\foo\\bar")',
-       ('c:', '\\foo\\bar'))
-tester('ntpath.splitunc("\\\\conky\\mountpoint\\foo\\bar")',
-       ('\\\\conky\\mountpoint', '\\foo\\bar'))
-tester('ntpath.splitdrive("c:/foo/bar")',
-       ('c:', '/foo/bar'))
-tester('ntpath.splitunc("//conky/mountpoint/foo/bar")',
-       ('//conky/mountpoint', '/foo/bar'))
-
-tester('ntpath.split("c:\\foo\\bar")', ('c:\\foo', 'bar'))
-tester('ntpath.split("\\\\conky\\mountpoint\\foo\\bar")',
-       ('\\\\conky\\mountpoint\\foo', 'bar'))
-
-tester('ntpath.split("c:\\")', ('c:\\', ''))
-tester('ntpath.split("\\\\conky\\mountpoint\\")',
-       ('\\\\conky\\mountpoint', ''))
-
-tester('ntpath.split("c:/")', ('c:/', ''))
-tester('ntpath.split("//conky/mountpoint/")', ('//conky/mountpoint', ''))
-
-tester('ntpath.isabs("c:\\")', 1)
-tester('ntpath.isabs("\\\\conky\\mountpoint\\")', 1)
-tester('ntpath.isabs("\\foo")', 1)
-tester('ntpath.isabs("\\foo\\bar")', 1)
-
-tester('ntpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"])',
-       "/home/swen")
-tester('ntpath.commonprefix(["\\home\\swen\\spam", "\\home\\swen\\eggs"])',
-       "\\home\\swen\\")
-tester('ntpath.commonprefix(["/home/swen/spam", "/home/swen/spam"])',
-       "/home/swen/spam")
-
-tester('ntpath.join("")', '')
-tester('ntpath.join("", "", "")', '')
-tester('ntpath.join("a")', 'a')
-tester('ntpath.join("/a")', '/a')
-tester('ntpath.join("\\a")', '\\a')
-tester('ntpath.join("a:")', 'a:')
-tester('ntpath.join("a:", "b")', 'a:b')
-tester('ntpath.join("a:", "/b")', 'a:/b')
-tester('ntpath.join("a:", "\\b")', 'a:\\b')
-tester('ntpath.join("a", "/b")', '/b')
-tester('ntpath.join("a", "\\b")', '\\b')
-tester('ntpath.join("a", "b", "c")', 'a\\b\\c')
-tester('ntpath.join("a\\", "b", "c")', 'a\\b\\c')
-tester('ntpath.join("a", "b\\", "c")', 'a\\b\\c')
-tester('ntpath.join("a", "b", "\\c")', '\\c')
-tester('ntpath.join("d:\\", "\\pleep")', 'd:\\pleep')
-tester('ntpath.join("d:\\", "a", "b")', 'd:\\a\\b')
-tester("ntpath.join('c:', '/a')", 'c:/a')
-tester("ntpath.join('c:/', '/a')", 'c:/a')
-tester("ntpath.join('c:/a', '/b')", '/b')
-tester("ntpath.join('c:', 'd:/')", 'd:/')
-tester("ntpath.join('c:/', 'd:/')", 'd:/')
-tester("ntpath.join('c:/', 'd:/a/b')", 'd:/a/b')
-
-tester("ntpath.join('')", '')
-tester("ntpath.join('', '', '', '', '')", '')
-tester("ntpath.join('a')", 'a')
-tester("ntpath.join('', 'a')", 'a')
-tester("ntpath.join('', '', '', '', 'a')", 'a')
-tester("ntpath.join('a', '')", 'a\\')
-tester("ntpath.join('a', '', '', '', '')", 'a\\')
-tester("ntpath.join('a\\', '')", 'a\\')
-tester("ntpath.join('a\\', '', '', '', '')", 'a\\')
-
-tester("ntpath.normpath('A//////././//.//B')", r'A\B')
-tester("ntpath.normpath('A/./B')", r'A\B')
-tester("ntpath.normpath('A/foo/../B')", r'A\B')
-tester("ntpath.normpath('C:A//B')", r'C:A\B')
-tester("ntpath.normpath('D:A/./B')", r'D:A\B')
-tester("ntpath.normpath('e:A/foo/../B')", r'e:A\B')
-
-tester("ntpath.normpath('C:///A//B')", r'C:\A\B')
-tester("ntpath.normpath('D:///A/./B')", r'D:\A\B')
-tester("ntpath.normpath('e:///A/foo/../B')", r'e:\A\B')
-
-tester("ntpath.normpath('..')", r'..')
-tester("ntpath.normpath('.')", r'.')
-tester("ntpath.normpath('')", r'.')
-tester("ntpath.normpath('/')", '\\')
-tester("ntpath.normpath('c:/')", 'c:\\')
-tester("ntpath.normpath('/../.././..')", '\\')
-tester("ntpath.normpath('c:/../../..')", 'c:\\')
-tester("ntpath.normpath('../.././..')", r'..\..\..')
-tester("ntpath.normpath('K:../.././..')", r'K:..\..\..')
-tester("ntpath.normpath('C:////a/b')", r'C:\a\b')
-tester("ntpath.normpath('//machine/share//a/b')", r'\\machine\share\a\b')
-
-oldenv = os.environ.copy()
-try:
-    os.environ.clear()
-    os.environ["foo"] = "bar"
-    os.environ["{foo"] = "baz1"
-    os.environ["{foo}"] = "baz2"
-    tester('ntpath.expandvars("foo")', "foo")
-    tester('ntpath.expandvars("$foo bar")', "bar bar")
-    tester('ntpath.expandvars("${foo}bar")', "barbar")
-    tester('ntpath.expandvars("$[foo]bar")', "$[foo]bar")
-    tester('ntpath.expandvars("$bar bar")', "$bar bar")
-    tester('ntpath.expandvars("$?bar")', "$?bar")
-    tester('ntpath.expandvars("${foo}bar")', "barbar")
-    tester('ntpath.expandvars("$foo}bar")', "bar}bar")
-    tester('ntpath.expandvars("${foo")', "${foo")
-    tester('ntpath.expandvars("${{foo}}")', "baz1}")
-    tester('ntpath.expandvars("$foo$foo")', "barbar")
-    tester('ntpath.expandvars("$bar$bar")', "$bar$bar")
-    tester('ntpath.expandvars("%foo% bar")', "bar bar")
-    tester('ntpath.expandvars("%foo%bar")', "barbar")
-    tester('ntpath.expandvars("%foo%%foo%")', "barbar")
-    tester('ntpath.expandvars("%%foo%%foo%foo%")', "%foo%foobar")
-    tester('ntpath.expandvars("%?bar%")', "%?bar%")
-    tester('ntpath.expandvars("%foo%%bar")', "bar%bar")
-    tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar")
-finally:
-    os.environ.clear()
-    os.environ.update(oldenv)
-
-# ntpath.abspath() can only be used on a system with the "nt" module
-# (reasonably), so we protect this test with "import nt".  This allows
-# the rest of the tests for the ntpath module to be run to completion
-# on any platform, since most of the module is intended to be usable
-# from any platform.
-try:
-    import nt
-except ImportError:
-    pass
-else:
-    tester('ntpath.abspath("C:\\")', "C:\\")
-
-currentdir = os.path.split(os.getcwd())[-1]
-tester('ntpath.relpath("a")', 'a')
-tester('ntpath.relpath(os.path.abspath("a"))', 'a')
-tester('ntpath.relpath("a/b")', 'a\\b')
-tester('ntpath.relpath("../a/b")', '..\\a\\b')
-tester('ntpath.relpath("a", "../b")', '..\\'+currentdir+'\\a')
-tester('ntpath.relpath("a/b", "../c")', '..\\'+currentdir+'\\a\\b')
-tester('ntpath.relpath("a", "b/c")', '..\\..\\a')
-tester('ntpath.relpath("//conky/mountpoint/a", "//conky/mountpoint/b/c")', '..\\..\\a')
-tester('ntpath.relpath("a", "a")', '.')
-
-if errors:
-    raise TestFailed(str(errors) + " errors.")
-elif verbose:
-    print("No errors.  Thank your lucky stars.")
+        raise TestFailed("%s should return: %s but returned: %s" \
+              %(str(fn), str(wantResult), str(gotResult)))
+
+
+class TestNtpath(unittest.TestCase):
+    def test_splitext(self):
+        tester('ntpath.splitext("foo.ext")', ('foo', '.ext'))
+        tester('ntpath.splitext("/foo/foo.ext")', ('/foo/foo', '.ext'))
+        tester('ntpath.splitext(".ext")', ('.ext', ''))
+        tester('ntpath.splitext("\\foo.ext\\foo")', ('\\foo.ext\\foo', ''))
+        tester('ntpath.splitext("foo.ext\\")', ('foo.ext\\', ''))
+        tester('ntpath.splitext("")', ('', ''))
+        tester('ntpath.splitext("foo.bar.ext")', ('foo.bar', '.ext'))
+        tester('ntpath.splitext("xx/foo.bar.ext")', ('xx/foo.bar', '.ext'))
+        tester('ntpath.splitext("xx\\foo.bar.ext")', ('xx\\foo.bar', '.ext'))
+        tester('ntpath.splitext("c:a/b\\c.d")', ('c:a/b\\c', '.d'))
+
+    def test_splitdrive(self):
+        tester('ntpath.splitdrive("c:\\foo\\bar")',
+               ('c:', '\\foo\\bar'))
+        tester('ntpath.splitdrive("c:/foo/bar")',
+               ('c:', '/foo/bar'))
+
+    def test_splitunc(self):
+        tester('ntpath.splitunc("\\\\conky\\mountpoint\\foo\\bar")',
+               ('\\\\conky\\mountpoint', '\\foo\\bar'))
+        tester('ntpath.splitunc("//conky/mountpoint/foo/bar")',
+               ('//conky/mountpoint', '/foo/bar'))
+
+    def test_split(self):
+        tester('ntpath.split("c:\\foo\\bar")', ('c:\\foo', 'bar'))
+        tester('ntpath.split("\\\\conky\\mountpoint\\foo\\bar")',
+               ('\\\\conky\\mountpoint\\foo', 'bar'))
+
+        tester('ntpath.split("c:\\")', ('c:\\', ''))
+        tester('ntpath.split("\\\\conky\\mountpoint\\")',
+               ('\\\\conky\\mountpoint', ''))
+
+        tester('ntpath.split("c:/")', ('c:/', ''))
+        tester('ntpath.split("//conky/mountpoint/")', ('//conky/mountpoint', ''))
+
+    def test_isabs(self):
+        tester('ntpath.isabs("c:\\")', 1)
+        tester('ntpath.isabs("\\\\conky\\mountpoint\\")', 1)
+        tester('ntpath.isabs("\\foo")', 1)
+        tester('ntpath.isabs("\\foo\\bar")', 1)
+
+    def test_commonprefix(self):
+        tester('ntpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"])',
+               "/home/swen")
+        tester('ntpath.commonprefix(["\\home\\swen\\spam", "\\home\\swen\\eggs"])',
+               "\\home\\swen\\")
+        tester('ntpath.commonprefix(["/home/swen/spam", "/home/swen/spam"])',
+               "/home/swen/spam")
+
+    def test_join(self):
+        tester('ntpath.join("")', '')
+        tester('ntpath.join("", "", "")', '')
+        tester('ntpath.join("a")', 'a')
+        tester('ntpath.join("/a")', '/a')
+        tester('ntpath.join("\\a")', '\\a')
+        tester('ntpath.join("a:")', 'a:')
+        tester('ntpath.join("a:", "b")', 'a:b')
+        tester('ntpath.join("a:", "/b")', 'a:/b')
+        tester('ntpath.join("a:", "\\b")', 'a:\\b')
+        tester('ntpath.join("a", "/b")', '/b')
+        tester('ntpath.join("a", "\\b")', '\\b')
+        tester('ntpath.join("a", "b", "c")', 'a\\b\\c')
+        tester('ntpath.join("a\\", "b", "c")', 'a\\b\\c')
+        tester('ntpath.join("a", "b\\", "c")', 'a\\b\\c')
+        tester('ntpath.join("a", "b", "\\c")', '\\c')
+        tester('ntpath.join("d:\\", "\\pleep")', 'd:\\pleep')
+        tester('ntpath.join("d:\\", "a", "b")', 'd:\\a\\b')
+        tester("ntpath.join('c:', '/a')", 'c:/a')
+        tester("ntpath.join('c:/', '/a')", 'c:/a')
+        tester("ntpath.join('c:/a', '/b')", '/b')
+        tester("ntpath.join('c:', 'd:/')", 'd:/')
+        tester("ntpath.join('c:/', 'd:/')", 'd:/')
+        tester("ntpath.join('c:/', 'd:/a/b')", 'd:/a/b')
+
+        tester("ntpath.join('')", '')
+        tester("ntpath.join('', '', '', '', '')", '')
+        tester("ntpath.join('a')", 'a')
+        tester("ntpath.join('', 'a')", 'a')
+        tester("ntpath.join('', '', '', '', 'a')", 'a')
+        tester("ntpath.join('a', '')", 'a\\')
+        tester("ntpath.join('a', '', '', '', '')", 'a\\')
+        tester("ntpath.join('a\\', '')", 'a\\')
+        tester("ntpath.join('a\\', '', '', '', '')", 'a\\')
+
+    def test_normpath(self):
+        tester("ntpath.normpath('A//////././//.//B')", r'A\B')
+        tester("ntpath.normpath('A/./B')", r'A\B')
+        tester("ntpath.normpath('A/foo/../B')", r'A\B')
+        tester("ntpath.normpath('C:A//B')", r'C:A\B')
+        tester("ntpath.normpath('D:A/./B')", r'D:A\B')
+        tester("ntpath.normpath('e:A/foo/../B')", r'e:A\B')
+
+        tester("ntpath.normpath('C:///A//B')", r'C:\A\B')
+        tester("ntpath.normpath('D:///A/./B')", r'D:\A\B')
+        tester("ntpath.normpath('e:///A/foo/../B')", r'e:\A\B')
+
+        tester("ntpath.normpath('..')", r'..')
+        tester("ntpath.normpath('.')", r'.')
+        tester("ntpath.normpath('')", r'.')
+        tester("ntpath.normpath('/')", '\\')
+        tester("ntpath.normpath('c:/')", 'c:\\')
+        tester("ntpath.normpath('/../.././..')", '\\')
+        tester("ntpath.normpath('c:/../../..')", 'c:\\')
+        tester("ntpath.normpath('../.././..')", r'..\..\..')
+        tester("ntpath.normpath('K:../.././..')", r'K:..\..\..')
+        tester("ntpath.normpath('C:////a/b')", r'C:\a\b')
+        tester("ntpath.normpath('//machine/share//a/b')", r'\\machine\share\a\b')
+
+    def test_expandvars(self):
+        oldenv = os.environ.copy()
+        try:
+            os.environ.clear()
+            os.environ["foo"] = "bar"
+            os.environ["{foo"] = "baz1"
+            os.environ["{foo}"] = "baz2"
+            tester('ntpath.expandvars("foo")', "foo")
+            tester('ntpath.expandvars("$foo bar")', "bar bar")
+            tester('ntpath.expandvars("${foo}bar")', "barbar")
+            tester('ntpath.expandvars("$[foo]bar")', "$[foo]bar")
+            tester('ntpath.expandvars("$bar bar")', "$bar bar")
+            tester('ntpath.expandvars("$?bar")', "$?bar")
+            tester('ntpath.expandvars("${foo}bar")', "barbar")
+            tester('ntpath.expandvars("$foo}bar")', "bar}bar")
+            tester('ntpath.expandvars("${foo")', "${foo")
+            tester('ntpath.expandvars("${{foo}}")', "baz1}")
+            tester('ntpath.expandvars("$foo$foo")', "barbar")
+            tester('ntpath.expandvars("$bar$bar")', "$bar$bar")
+            tester('ntpath.expandvars("%foo% bar")', "bar bar")
+            tester('ntpath.expandvars("%foo%bar")', "barbar")
+            tester('ntpath.expandvars("%foo%%foo%")', "barbar")
+            tester('ntpath.expandvars("%%foo%%foo%foo%")', "%foo%foobar")
+            tester('ntpath.expandvars("%?bar%")', "%?bar%")
+            tester('ntpath.expandvars("%foo%%bar")', "bar%bar")
+            tester('ntpath.expandvars("\'%foo%\'%bar")', "\'%foo%\'%bar")
+        finally:
+            os.environ.clear()
+            os.environ.update(oldenv)
+
+    def test_abspath(self):
+        # ntpath.abspath() can only be used on a system with the "nt" module
+        # (reasonably), so we protect this test with "import nt".  This allows
+        # the rest of the tests for the ntpath module to be run to completion
+        # on any platform, since most of the module is intended to be usable
+        # from any platform.
+        try:
+            import nt
+        except ImportError:
+            pass
+        else:
+            tester('ntpath.abspath("C:\\")', "C:\\")
+
+    def test_relpath(self):
+        currentdir = os.path.split(os.getcwd())[-1]
+        tester('ntpath.relpath("a")', 'a')
+        tester('ntpath.relpath(os.path.abspath("a"))', 'a')
+        tester('ntpath.relpath("a/b")', 'a\\b')
+        tester('ntpath.relpath("../a/b")', '..\\a\\b')
+        tester('ntpath.relpath("a", "../b")', '..\\'+currentdir+'\\a')
+        tester('ntpath.relpath("a/b", "../c")', '..\\'+currentdir+'\\a\\b')
+        tester('ntpath.relpath("a", "b/c")', '..\\..\\a')
+        tester('ntpath.relpath("//conky/mountpoint/a", "//conky/mountpoint/b/c")', '..\\..\\a')
+        tester('ntpath.relpath("a", "a")', '.')
+
+
+def test_main():
+    test_support.run_unittest(TestNtpath)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/Lib/test/test_timeout.py b/Lib/test/test_timeout.py
index 5986afa..6324fc1 100644
--- a/Lib/test/test_timeout.py
+++ b/Lib/test/test_timeout.py
@@ -107,24 +107,19 @@ class TimeoutTestCase(unittest.TestCase):
         self.sock.close()
 
     def testConnectTimeout(self):
-        # If we are too close to www.python.org, this test will fail.
-        # Pick a host that should be farther away.
-        if (socket.getfqdn().split('.')[-2:] == ['python', 'org'] or
-            socket.getfqdn().split('.')[-2:-1] == ['xs4all']):
-            self.addr_remote = ('tut.fi', 80)
-
-        # Lookup the IP address to avoid including the DNS lookup time
+        # Choose a private address that is unlikely to exist to prevent
+        # failures due to the connect succeeding before the timeout.
+        # Use a dotted IP address to avoid including the DNS lookup time
         # with the connect time.  This avoids failing the assertion that
         # the timeout occurred fast enough.
-        self.addr_remote = (socket.gethostbyname(self.addr_remote[0]), 80)
+        addr = ('10.0.0.0', 12345)
 
         # Test connect() timeout
         _timeout = 0.001
         self.sock.settimeout(_timeout)
 
         _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.sock.connect,
-                self.addr_remote)
+        self.failUnlessRaises(socket.error, self.sock.connect, addr)
         _t2 = time.time()
 
         _delta = abs(_t1 - _t2)