Merged revisions 70712,70714,70764-70765,70769-70771,70773,70776-70777,70788-70789,70824,70828,70832,70836,70842,70851,70855,70857,70866-70872,70883,70885,70893-70894,70896-70897,70903,70905-70907,70915,70927,70933,70951,70960,70962-70964,70998,71001,71006,71008,71010-71011,71019,71037,71056,71094,71101-71103,71106,71119,71123,71149-71150,71203,71212,71214-71217,71221,71240 via svnmerge from

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

........
  r70712 | benjamin.peterson | 2009-03-30 10:15:38 -0500 (Mon, 30 Mar 2009) | 1 line

  don't rely on the order dict repr #5605
........
  r70714 | brett.cannon | 2009-03-30 10:20:53 -0500 (Mon, 30 Mar 2009) | 1 line

  Add an entry to developers.txt.
........
  r70764 | martin.v.loewis | 2009-03-30 17:06:33 -0500 (Mon, 30 Mar 2009) | 2 lines

  Add several VM developers.
........
  r70765 | georg.brandl | 2009-03-30 17:09:34 -0500 (Mon, 30 Mar 2009) | 1 line

  #5199: make warning about vars() assignment more visible.
........
  r70769 | andrew.kuchling | 2009-03-30 17:29:53 -0500 (Mon, 30 Mar 2009) | 1 line

  Remove comment
........
  r70770 | andrew.kuchling | 2009-03-30 17:30:20 -0500 (Mon, 30 Mar 2009) | 1 line

  Add several items and placeholders
........
  r70771 | andrew.kuchling | 2009-03-30 17:31:11 -0500 (Mon, 30 Mar 2009) | 1 line

  Many edits
........
  r70773 | georg.brandl | 2009-03-30 17:43:00 -0500 (Mon, 30 Mar 2009) | 1 line

  #5039: make it clear that the impl. note refers to CPython.
........
  r70776 | andrew.kuchling | 2009-03-30 18:08:24 -0500 (Mon, 30 Mar 2009) | 1 line

  typo fix
........
  r70777 | andrew.kuchling | 2009-03-30 18:09:46 -0500 (Mon, 30 Mar 2009) | 1 line

  Add more items
........
  r70788 | andrew.kuchling | 2009-03-30 20:21:01 -0500 (Mon, 30 Mar 2009) | 1 line

  Add various items
........
  r70789 | georg.brandl | 2009-03-30 20:25:15 -0500 (Mon, 30 Mar 2009) | 1 line

  Fix a wrong struct field assignment (docstring as closure).
........
  r70824 | georg.brandl | 2009-03-31 10:43:20 -0500 (Tue, 31 Mar 2009) | 1 line

  #5519: remove reference to Kodos, which seems dead.
........
  r70828 | georg.brandl | 2009-03-31 10:50:16 -0500 (Tue, 31 Mar 2009) | 1 line

  #5581: fget argument of abstractproperty is optional as well.
........
  r70832 | georg.brandl | 2009-03-31 11:31:11 -0500 (Tue, 31 Mar 2009) | 1 line

  #1386675: specify WindowsError as the exception, because it has a winerror attribute that EnvironmentError doesnt have.
........
  r70836 | georg.brandl | 2009-03-31 11:50:25 -0500 (Tue, 31 Mar 2009) | 1 line

  #5417: replace references to undocumented functions by ones to documented functions.
........
  r70842 | georg.brandl | 2009-03-31 12:13:06 -0500 (Tue, 31 Mar 2009) | 1 line

  #970783: document PyObject_Generic[GS]etAttr.
........
  r70851 | georg.brandl | 2009-03-31 13:26:55 -0500 (Tue, 31 Mar 2009) | 1 line

  #837577: note cryptic return value of spawn*e on invalid env dicts.
........
  r70855 | georg.brandl | 2009-03-31 13:30:37 -0500 (Tue, 31 Mar 2009) | 1 line

  #5245: note that PyRun_SimpleString doesnt return on SystemExit.
........
  r70857 | georg.brandl | 2009-03-31 13:33:10 -0500 (Tue, 31 Mar 2009) | 1 line

  #5227: note that Py_Main doesnt return on SystemExit.
........
  r70866 | georg.brandl | 2009-03-31 14:06:57 -0500 (Tue, 31 Mar 2009) | 1 line

  #4882: document named group behavior a bit better.
........
  r70867 | georg.brandl | 2009-03-31 14:10:35 -0500 (Tue, 31 Mar 2009) | 1 line

  #1096310: document usage of sys.__std*__ a bit better.
........
  r70868 | georg.brandl | 2009-03-31 14:12:17 -0500 (Tue, 31 Mar 2009) | 1 line

  #5190: export make_option in __all__.
........
  r70869 | georg.brandl | 2009-03-31 14:14:42 -0500 (Tue, 31 Mar 2009) | 1 line

  Fix-up unwanted change.
........
  r70870 | georg.brandl | 2009-03-31 14:26:24 -0500 (Tue, 31 Mar 2009) | 1 line

  #4411: document mro() and __mro__. (I hope I got it right.)
........
  r70871 | georg.brandl | 2009-03-31 14:30:56 -0500 (Tue, 31 Mar 2009) | 1 line

  #5618: fix typo.
........
  r70872 | r.david.murray | 2009-03-31 14:31:17 -0500 (Tue, 31 Mar 2009) | 3 lines

  Delete out-of-date and little-known README from the test
  directory by consensus of devs at pycon sprint.
........
  r70883 | georg.brandl | 2009-03-31 15:41:08 -0500 (Tue, 31 Mar 2009) | 1 line

  #1674032: return value of flag from Event.wait(). OKed by Guido.
........
  r70885 | tarek.ziade | 2009-03-31 15:48:31 -0500 (Tue, 31 Mar 2009) | 1 line

  using log.warn for sys.stderr
........
  r70893 | georg.brandl | 2009-03-31 15:56:32 -0500 (Tue, 31 Mar 2009) | 1 line

  #1530012: move TQS section before raw strings.
........
  r70894 | benjamin.peterson | 2009-03-31 16:06:30 -0500 (Tue, 31 Mar 2009) | 1 line

  take the usual lock precautions around _active_limbo_lock
........
  r70896 | georg.brandl | 2009-03-31 16:15:33 -0500 (Tue, 31 Mar 2009) | 1 line

  #5598: document DocFileSuite *args argument.
........
  r70897 | benjamin.peterson | 2009-03-31 16:34:42 -0500 (Tue, 31 Mar 2009) | 1 line

  fix Thread.ident when it is the main thread or a dummy thread #5632
........
  r70903 | georg.brandl | 2009-03-31 16:45:18 -0500 (Tue, 31 Mar 2009) | 1 line

  #1676135: remove trailing slashes from --prefix argument.
........
  r70905 | georg.brandl | 2009-03-31 17:03:40 -0500 (Tue, 31 Mar 2009) | 1 line

  #5563: more documentation for bdist_msi.
........
  r70906 | georg.brandl | 2009-03-31 17:11:53 -0500 (Tue, 31 Mar 2009) | 1 line

  #1651995: fix _convert_ref for non-ASCII characters.
........
  r70907 | georg.brandl | 2009-03-31 17:18:19 -0500 (Tue, 31 Mar 2009) | 1 line

  #3427: document correct return type for urlopen().info().
........
  r70915 | georg.brandl | 2009-03-31 17:40:16 -0500 (Tue, 31 Mar 2009) | 1 line

  #5018: remove confusing paragraph.
........
  r70927 | georg.brandl | 2009-03-31 18:01:27 -0500 (Tue, 31 Mar 2009) | 1 line

  Dont shout to users.
........
  r70933 | georg.brandl | 2009-03-31 19:04:33 -0500 (Tue, 31 Mar 2009) | 2 lines

  Issue #5635: Fix running test_sys with tracing enabled.
........
  r70951 | georg.brandl | 2009-04-01 09:02:27 -0500 (Wed, 01 Apr 2009) | 1 line

  Add Maksim, who worked on several issues at the sprint.
........
  r70960 | jesse.noller | 2009-04-01 11:42:19 -0500 (Wed, 01 Apr 2009) | 1 line

  Issue 3270: document Listener address restrictions on windows
........
  r70962 | brett.cannon | 2009-04-01 12:07:16 -0500 (Wed, 01 Apr 2009) | 2 lines

  Ron DuPlain was given commit privileges at PyCon 2009 to work on 3to2.
........
  r70963 | georg.brandl | 2009-04-01 12:46:01 -0500 (Wed, 01 Apr 2009) | 1 line

  #5655: fix docstring oversight.
........
  r70964 | brett.cannon | 2009-04-01 12:52:13 -0500 (Wed, 01 Apr 2009) | 2 lines

  Paul Kippes was given commit privileges to work on 3to2.
........
  r70998 | georg.brandl | 2009-04-01 16:54:21 -0500 (Wed, 01 Apr 2009) | 1 line

  In Pdb, stop assigning values to __builtin__._ which interferes with the one commonly installed by gettext.
........
  r71001 | brett.cannon | 2009-04-01 18:01:12 -0500 (Wed, 01 Apr 2009) | 3 lines

  Add my initials to Misc/developers.txt. Names are now sorted by number of
  characters in the person's name.
........
  r71006 | georg.brandl | 2009-04-01 18:32:17 -0500 (Wed, 01 Apr 2009) | 1 line

  Cache the f_locals dict of the current frame, since every access to frame.f_locals overrides its contents with the real locals which undoes modifications made by the debugging user.
........
  r71008 | andrew.kuchling | 2009-04-01 19:02:14 -0500 (Wed, 01 Apr 2009) | 1 line

  Typo fix
........
  r71010 | benjamin.peterson | 2009-04-01 19:11:52 -0500 (Wed, 01 Apr 2009) | 1 line

  fix markup
........
  r71011 | benjamin.peterson | 2009-04-01 19:12:47 -0500 (Wed, 01 Apr 2009) | 1 line

  this should be :noindex:
........
  r71019 | georg.brandl | 2009-04-01 21:00:01 -0500 (Wed, 01 Apr 2009) | 1 line

  Fix test_doctest, missed two assignments to curframe.
........
  r71037 | r.david.murray | 2009-04-01 23:34:04 -0500 (Wed, 01 Apr 2009) | 6 lines

  Clarify that datetime strftime does not produce leap seconds and datetime
  strptime does not accept it in the strftime behavior section of the
  datetime docs.

  Closes issue 2568.
........
  r71056 | georg.brandl | 2009-04-02 12:43:07 -0500 (Thu, 02 Apr 2009) | 2 lines

  Actually the displayhook should print the repr.
........
  r71094 | vinay.sajip | 2009-04-03 05:23:18 -0500 (Fri, 03 Apr 2009) | 1 line

  Added warning about logging use from asynchronous signal handlers.
........
  r71101 | andrew.kuchling | 2009-04-03 16:43:00 -0500 (Fri, 03 Apr 2009) | 1 line

  Add some items
........
  r71102 | andrew.kuchling | 2009-04-03 16:44:49 -0500 (Fri, 03 Apr 2009) | 1 line

  Fix 'the the'; grammar fix
........
  r71103 | andrew.kuchling | 2009-04-03 16:45:29 -0500 (Fri, 03 Apr 2009) | 1 line

  Fix 'the the' duplication
........
  r71106 | vinay.sajip | 2009-04-03 16:58:16 -0500 (Fri, 03 Apr 2009) | 1 line

  Clarified warning about logging use from asynchronous signal handlers.
........
  r71119 | raymond.hettinger | 2009-04-04 00:37:47 -0500 (Sat, 04 Apr 2009) | 1 line

  Add helpful link.
........
  r71123 | r.david.murray | 2009-04-04 01:39:56 -0500 (Sat, 04 Apr 2009) | 2 lines

  Fix error in description of 'oct' (issue 5678).
........
  r71149 | georg.brandl | 2009-04-04 08:42:39 -0500 (Sat, 04 Apr 2009) | 1 line

  #5642: clarify map() compatibility to the builtin.
........
  r71150 | georg.brandl | 2009-04-04 08:45:49 -0500 (Sat, 04 Apr 2009) | 1 line

  #5601: clarify that webbrowser is not meant for file names.
........
  r71203 | benjamin.peterson | 2009-04-04 18:46:34 -0500 (Sat, 04 Apr 2009) | 1 line

  note how using iter* are unsafe while mutating and document iter(dict)
........
  r71212 | georg.brandl | 2009-04-05 05:24:20 -0500 (Sun, 05 Apr 2009) | 1 line

  #1742837: expand HTTP server docs, and fix SocketServer ones to document methods as methods, not functions.
........
  r71214 | georg.brandl | 2009-04-05 05:29:57 -0500 (Sun, 05 Apr 2009) | 1 line

  Normalize spelling of Mac OS X.
........
  r71215 | georg.brandl | 2009-04-05 05:32:26 -0500 (Sun, 05 Apr 2009) | 1 line

  Avoid sure signs of a diseased mind.
........
  r71216 | georg.brandl | 2009-04-05 05:41:02 -0500 (Sun, 05 Apr 2009) | 1 line

  #1718017: document the relation of os.path and the posixpath, ntpath etc. modules better.
........
  r71217 | georg.brandl | 2009-04-05 05:48:47 -0500 (Sun, 05 Apr 2009) | 1 line

  #1726172: dont raise an unexpected IndexError if a voidresp() call has an empty response.
........
  r71221 | vinay.sajip | 2009-04-05 06:06:24 -0500 (Sun, 05 Apr 2009) | 1 line

  Issue #5695: Moved logging.captureWarnings() call inside with statement in WarningsTest.test_warnings.
........
  r71240 | georg.brandl | 2009-04-05 09:40:06 -0500 (Sun, 05 Apr 2009) | 1 line

  #5370: doc update about unpickling objects with custom __getattr__ etc. methods.
........

11 files changed, 86 insertions, 462 deletions

diff --git a/Lib/distutils/cmd.py b/Lib/distutils/cmd.py
index 46055b4..5829a56 100644
--- a/Lib/distutils/cmd.py
+++ b/Lib/distutils/cmd.py
@@ -333,7 +333,8 @@ class Command:
     # -- External world manipulation -----------------------------------
 
     def warn(self, msg):
-        log.warn("warning: %s: %s\n" % (self.get_command_name(), msg))
+        log.warn("warning: %s: %s\n" %
+                (self.get_command_name(), msg))
 
     def execute(self, func, args, msg=None, level=1):
         util.execute(func, args, msg, dry_run=self.dry_run)
diff --git a/Lib/distutils/log.py b/Lib/distutils/log.py
index 97319a0..6f949d5 100644
--- a/Lib/distutils/log.py
+++ b/Lib/distutils/log.py
@@ -18,13 +18,14 @@ class Log:
 
     def _log(self, level, msg, args):
         if level >= self.threshold:
-            if not args:
-                # msg may contain a '%'. If args is empty,
-                # don't even try to string-format
-                print(msg)
+            if args:
+                msg = msg % args
+            if level in (WARN, ERROR, FATAL):
+                stream = sys.stderr
             else:
-                print(msg % args)
-            sys.stdout.flush()
+                stream = sys.stdout
+            stream.write('%s\n' % msg)
+            stream.flush()
 
     def log(self, level, msg, *args):
         self._log(level, msg, args)
diff --git a/Lib/ftplib.py b/Lib/ftplib.py
index 42f2bff..7e678b4 100644
--- a/Lib/ftplib.py
+++ b/Lib/ftplib.py
@@ -223,7 +223,7 @@ class FTP:
     def voidresp(self):
         """Expect a response beginning with '2'."""
         resp = self.getresp()
-        if resp[0] != '2':
+        if resp[:1] != '2':
             raise error_reply(resp)
         return resp
 
@@ -522,8 +522,6 @@ class FTP:
         resp = self.sendcmd('DELE ' + filename)
         if resp[:3] in ('250', '200'):
             return resp
-        elif resp[:1] == '5':
-            raise error_perm(resp)
         else:
             raise error_reply(resp)
 
diff --git a/Lib/glob.py b/Lib/glob.py
index 9529f7e..c5f5f69 100644
--- a/Lib/glob.py
+++ b/Lib/glob.py
@@ -16,7 +16,7 @@ def glob(pathname):
     return list(iglob(pathname))
 
 def iglob(pathname):
-    """Return a list of paths matching a pathname pattern.
+    """Return an iterator which yields the paths matching a pathname pattern.
 
     The pattern may contain simple shell-style wildcards a la fnmatch.
 
diff --git a/Lib/optparse.py b/Lib/optparse.py
index 7b1734c..d9225e1 100644
--- a/Lib/optparse.py
+++ b/Lib/optparse.py
@@ -11,6 +11,7 @@ For support, use the optik-users@lists.sourceforge.net mailing list
 __version__ = "1.5.3"
 
 __all__ = ['Option',
+           'make_option',
            'SUPPRESS_HELP',
            'SUPPRESS_USAGE',
            'Values',
diff --git a/Lib/pdb.py b/Lib/pdb.py
index ca03c50..22fc4c5 100755
--- a/Lib/pdb.py
+++ b/Lib/pdb.py
@@ -95,10 +95,14 @@ class Pdb(bdb.Bdb, cmd.Cmd):
             rcFile.close()
 
         self.commands = {} # associates a command list to breakpoint numbers
-        self.commands_doprompt = {} # for each bp num, tells if the prompt must be disp. after execing the cmd list
-        self.commands_silent = {} # for each bp num, tells if the stack trace must be disp. after execing the cmd list
-        self.commands_defining = False # True while in the process of defining a command list
-        self.commands_bnum = None # The breakpoint number for which we are defining a list
+        self.commands_doprompt = {} # for each bp num, tells if the prompt
+                                    # must be disp. after execing the cmd list
+        self.commands_silent = {} # for each bp num, tells if the stack trace
+                                  # must be disp. after execing the cmd list
+        self.commands_defining = False # True while in the process of defining
+                                       # a command list
+        self.commands_bnum = None # The breakpoint number for which we are
+                                  # defining a list
 
     def reset(self):
         bdb.Bdb.reset(self)
@@ -114,6 +118,10 @@ class Pdb(bdb.Bdb, cmd.Cmd):
         self.forget()
         self.stack, self.curindex = self.get_stack(f, t)
         self.curframe = self.stack[self.curindex][0]
+        # The f_locals dictionary is updated from the actual frame
+        # locals whenever the .f_locals accessor is called, so we
+        # cache it here to ensure that modifications are not overwritten.
+        self.curframe_locals = self.curframe.f_locals
         self.execRcLines()
 
     # Can be executed earlier than 'setup' if desired
@@ -192,21 +200,30 @@ class Pdb(bdb.Bdb, cmd.Cmd):
         self.cmdloop()
         self.forget()
 
+    def displayhook(self, obj):
+        """Custom displayhook for the exec in default(), which prevents
+        assignment of the _ variable in the builtins.
+        """
+        print(repr(obj))
+
     def default(self, line):
         if line[:1] == '!': line = line[1:]
-        locals = self.curframe.f_locals
+        locals = self.curframe_locals
         globals = self.curframe.f_globals
         try:
             code = compile(line + '\n', '<stdin>', 'single')
             save_stdout = sys.stdout
             save_stdin = sys.stdin
+            save_displayhook = sys.displayhook
             try:
                 sys.stdin = self.stdin
                 sys.stdout = self.stdout
+                sys.displayhook = self.displayhook
                 exec(code, globals, locals)
             finally:
                 sys.stdout = save_stdout
                 sys.stdin = save_stdin
+                sys.displayhook = save_displayhook
         except:
             t, v = sys.exc_info()[:2]
             if type(t) == type(''):
@@ -349,7 +366,7 @@ class Pdb(bdb.Bdb, cmd.Cmd):
                 try:
                     func = eval(arg,
                                 self.curframe.f_globals,
-                                self.curframe.f_locals)
+                                self.curframe_locals)
                 except:
                     func = arg
                 try:
@@ -597,6 +614,7 @@ class Pdb(bdb.Bdb, cmd.Cmd):
         else:
             self.curindex = self.curindex - 1
             self.curframe = self.stack[self.curindex][0]
+            self.curframe_locals = self.curframe.f_locals
             self.print_stack_entry(self.stack[self.curindex])
             self.lineno = None
     do_u = do_up
@@ -607,6 +625,7 @@ class Pdb(bdb.Bdb, cmd.Cmd):
         else:
             self.curindex = self.curindex + 1
             self.curframe = self.stack[self.curindex][0]
+            self.curframe_locals = self.curframe.f_locals
             self.print_stack_entry(self.stack[self.curindex])
             self.lineno = None
     do_d = do_down
@@ -670,7 +689,7 @@ class Pdb(bdb.Bdb, cmd.Cmd):
     def do_debug(self, arg):
         sys.settrace(None)
         globals = self.curframe.f_globals
-        locals = self.curframe.f_locals
+        locals = self.curframe_locals
         p = Pdb(self.completekey, self.stdin, self.stdout)
         p.prompt = "(%s) " % self.prompt.strip()
         print("ENTERING RECURSIVE DEBUGGER", file=self.stdout)
@@ -694,9 +713,8 @@ class Pdb(bdb.Bdb, cmd.Cmd):
         return 1
 
     def do_args(self, arg):
-        f = self.curframe
-        co = f.f_code
-        dict = f.f_locals
+        co = self.curframe.f_code
+        dict = self.curframe_locals
         n = co.co_argcount
         if co.co_flags & 4: n = n+1
         if co.co_flags & 8: n = n+1
@@ -708,16 +726,15 @@ class Pdb(bdb.Bdb, cmd.Cmd):
     do_a = do_args
 
     def do_retval(self, arg):
-        if '__return__' in self.curframe.f_locals:
-            print(self.curframe.f_locals['__return__'], file=self.stdout)
+        if '__return__' in self.curframe_locals:
+            print(self.curframe_locals['__return__'], file=self.stdout)
         else:
             print('*** Not yet returned!', file=self.stdout)
     do_rv = do_retval
 
     def _getval(self, arg):
         try:
-            return eval(arg, self.curframe.f_globals,
-                        self.curframe.f_locals)
+            return eval(arg, self.curframe.f_globals, self.curframe_locals)
         except:
             t, v = sys.exc_info()[:2]
             if isinstance(t, str):
@@ -788,7 +805,7 @@ class Pdb(bdb.Bdb, cmd.Cmd):
     def do_whatis(self, arg):
         try:
             value = eval(arg, self.curframe.f_globals,
-                            self.curframe.f_locals)
+                            self.curframe_locals)
         except:
             t, v = sys.exc_info()[:2]
             if type(t) == type(''):
diff --git a/Lib/test/README b/Lib/test/README
deleted file mode 100644
index a237740..0000000
--- a/Lib/test/README
+++ /dev/null
@@ -1,411 +0,0 @@
-+++++++++++++++++++++++++++++++
-Writing Python Regression Tests
-+++++++++++++++++++++++++++++++
-
-:Author: Skip Montanaro
-:Contact: skip@pobox.com
-
-Introduction
-============
-
-If you add a new module to Python or modify the functionality of an existing
-module, you should write one or more test cases to exercise that new
-functionality.  There are different ways to do this within the regression
-testing facility provided with Python; any particular test should use only
-one of these options.  Each option requires writing a test module using the
-conventions of the selected option:
-
-    - unittest_ based tests
-    - doctest_ based tests
-    - "traditional" Python test modules
-
-Regardless of the mechanics of the testing approach you choose,
-you will be writing unit tests (isolated tests of functions and objects
-defined by the module) using white box techniques.  Unlike black box
-testing, where you only have the external interfaces to guide your test case
-writing, in white box testing you can see the code being tested and tailor
-your test cases to exercise it more completely.  In particular, you will be
-able to refer to the C and Python code in the CVS repository when writing
-your regression test cases.
-
-.. _unittest: http://www.python.org/doc/current/lib/module-unittest.html
-.. _doctest: http://www.python.org/doc/current/lib/module-doctest.html
-
-unittest-based tests
-------------------
-The unittest_ framework is based on the ideas of unit testing as espoused
-by Kent Beck and the `Extreme Programming`_ (XP) movement.  The specific
-interface provided by the framework is tightly based on the JUnit_
-Java implementation of Beck's original SmallTalk test framework.  Please
-see the documentation of the unittest_ module for detailed information on
-the interface and general guidelines on writing unittest-based tests.
-
-The test_support helper module provides a function for use by
-unittest-based tests in the Python regression testing framework,
-``run_unittest()``. This is the primary way of running tests in the
-standard library. You can pass it any number of the following:
-
-- classes derived from or instances of ``unittest.TestCase`` or
-  ``unittest.TestSuite``. These will be handed off to unittest for
-  converting into a proper TestSuite instance.
-
-- a string; this must be a key in sys.modules. The module associated with
-  that string will be scanned by ``unittest.TestLoader.loadTestsFromModule``.
-  This is usually seen as ``test_support.run_unittest(__name__)`` in a test
-  module's ``test_main()`` function. This has the advantage of picking up
-  new tests automatically, without you having to add each new test case
-  manually.
-   
-All test methods in the Python regression framework have names that
-start with "``test_``" and use lower-case names with words separated with
-underscores.
-
-Test methods should *not* have docstrings!  The unittest module prints
-the docstring if there is one, but otherwise prints the function name
-and the full class name.  When there's a problem with a test, the
-latter information makes it easier to find the source for the test
-than the docstring.
-
-All unittest-based tests in the Python test suite use boilerplate that
-looks like this (with minor variations)::
-
-    import unittest
-    from test import test_support
-
-    class MyTestCase1(unittest.TestCase):
-
-        # Define setUp and tearDown only if needed
-
-        def setUp(self):
-            unittest.TestCase.setUp(self)
-            ... additional initialization...
-
-        def tearDown(self):
-            ... additional finalization...
-            unittest.TestCase.tearDown(self)
-
-        def test_feature_one(self):
-            # Testing feature one
-            ...unit test for feature one...
-
-        def test_feature_two(self):
-            # Testing feature two
-            ...unit test for feature two...
-
-        ...etc...
-
-    class MyTestCase2(unittest.TestCase):
-        ...same structure as MyTestCase1...
-
-    ...etc...
-
-    def test_main():
-        test_support.run_unittest(__name__)
-
-    if __name__ == "__main__":
-        test_main()
-
-This has the advantage that it allows the unittest module to be used
-as a script to run individual tests as well as working well with the
-regrtest framework.
-
-.. _Extreme Programming: http://www.extremeprogramming.org/
-.. _JUnit: http://www.junit.org/
-
-doctest based tests
--------------------
-Tests written to use doctest_ are actually part of the docstrings for
-the module being tested.  Each test is written as a display of an
-interactive session, including the Python prompts, statements that would
-be typed by the user, and the output of those statements (including
-tracebacks, although only the exception msg needs to be retained then).
-The module in the test package is simply a wrapper that causes doctest
-to run over the tests in the module.  The test for the difflib module
-provides a convenient example::
-
-    import difflib
-    from test import test_support
-    test_support.run_doctest(difflib)
-
-If the test is successful, nothing is written to stdout (so you should not
-create a corresponding output/test_difflib file), but running regrtest
-with -v will give a detailed report, the same as if passing -v to doctest.
-
-A second argument can be passed to run_doctest to tell doctest to search
-``sys.argv`` for -v instead of using test_support's idea of verbosity.  This
-is useful for writing doctest-based tests that aren't simply running a
-doctest'ed Lib module, but contain the doctests themselves.  Then at
-times you may want to run such a test directly as a doctest, independent
-of the regrtest framework.  The tail end of test_descrtut.py is a good
-example::
-
-    def test_main(verbose=None):
-        from test import test_support, test_descrtut
-        test_support.run_doctest(test_descrtut, verbose)
-
-    if __name__ == "__main__":
-        test_main(1)
-
-If run via regrtest, ``test_main()`` is called (by regrtest) without
-specifying verbose, and then test_support's idea of verbosity is used.  But
-when run directly, ``test_main(1)`` is called, and then doctest's idea of
-verbosity is used.
-
-See the documentation for the doctest module for information on
-writing tests using the doctest framework.
-
-"traditional" Python test modules
----------------------------------
-The mechanics of how the "traditional" test system operates are fairly
-straightforward.  When a test case is run, the output is compared with the
-expected output that is stored in .../Lib/test/output.  If the test runs to
-completion and the actual and expected outputs match, the test succeeds, if
-not, it fails.  If an ``ImportError`` or ``test_support.TestSkipped`` error
-is raised, the test is not run.
-
-Executing Test Cases
-====================
-If you are writing test cases for module spam, you need to create a file
-in .../Lib/test named test_spam.py.  In addition, if the tests are expected
-to write to stdout during a successful run, you also need to create an
-expected output file in .../Lib/test/output named test_spam ("..."
-represents the top-level directory in the Python source tree, the directory
-containing the configure script).  If needed, generate the initial version
-of the test output file by executing::
-
-    ./python Lib/test/regrtest.py -g test_spam.py
-
-from the top-level directory.
-
-Any time you modify test_spam.py you need to generate a new expected
-output file.  Don't forget to desk check the generated output to make sure
-it's really what you expected to find!  All in all it's usually better
-not to have an expected-out file (note that doctest- and unittest-based
-tests do not).
-
-To run a single test after modifying a module, simply run regrtest.py
-without the -g flag::
-
-    ./python Lib/test/regrtest.py test_spam.py
-
-While debugging a regression test, you can of course execute it
-independently of the regression testing framework and see what it prints::
-
-    ./python Lib/test/test_spam.py
-
-To run the entire test suite:
-
-- [UNIX, + other platforms where "make" works] Make the "test" target at the
-  top level::
-
-    make test
-
-- [WINDOWS] Run rt.bat from your PCBuild directory.  Read the comments at
-  the top of rt.bat for the use of special -d, -O and -q options processed
-  by rt.bat.
-
-- [OTHER] You can simply execute the two runs of regrtest (optimized and
-  non-optimized) directly::
-
-    ./python Lib/test/regrtest.py
-    ./python -O Lib/test/regrtest.py
-
-But note that this way picks up whatever .pyc and .pyo files happen to be
-around.  The makefile and rt.bat ways run the tests twice, the first time
-removing all .pyc and .pyo files from the subtree rooted at Lib/.
-
-Test cases generate output based upon values computed by the test code.
-When executed, regrtest.py compares the actual output generated by executing
-the test case with the expected output and reports success or failure.  It
-stands to reason that if the actual and expected outputs are to match, they
-must not contain any machine dependencies.  This means your test cases
-should not print out absolute machine addresses (e.g. the return value of
-the id() builtin function) or floating point numbers with large numbers of
-significant digits (unless you understand what you are doing!).
-
-
-Test Case Writing Tips
-======================
-Writing good test cases is a skilled task and is too complex to discuss in
-detail in this short document.  Many books have been written on the subject.
-I'll show my age by suggesting that Glenford Myers' `"The Art of Software
-Testing"`_, published in 1979, is still the best introduction to the subject
-available.  It is short (177 pages), easy to read, and discusses the major
-elements of software testing, though its publication predates the
-object-oriented software revolution, so doesn't cover that subject at all.
-Unfortunately, it is very expensive (about $100 new).  If you can borrow it
-or find it used (around $20), I strongly urge you to pick up a copy.
-
-The most important goal when writing test cases is to break things.  A test
-case that doesn't uncover a bug is much less valuable than one that does.
-In designing test cases you should pay attention to the following:
-
-    * Your test cases should exercise all the functions and objects defined
-      in the module, not just the ones meant to be called by users of your
-      module.  This may require you to write test code that uses the module
-      in ways you don't expect (explicitly calling internal functions, for
-      example - see test_atexit.py).
-
-    * You should consider any boundary values that may tickle exceptional
-      conditions (e.g. if you were writing regression tests for division,
-      you might well want to generate tests with numerators and denominators
-      at the limits of floating point and integer numbers on the machine
-      performing the tests as well as a denominator of zero).
-
-    * You should exercise as many paths through the code as possible.  This
-      may not always be possible, but is a goal to strive for.  In
-      particular, when considering if statements (or their equivalent), you
-      want to create test cases that exercise both the true and false
-      branches.  For loops, you should create test cases that exercise the
-      loop zero, one and multiple times.
-
-    * You should test with obviously invalid input.  If you know that a
-      function requires an integer input, try calling it with other types of
-      objects to see how it responds.
-
-    * You should test with obviously out-of-range input.  If the domain of a
-      function is only defined for positive integers, try calling it with a
-      negative integer.
-
-    * If you are going to fix a bug that wasn't uncovered by an existing
-      test, try to write a test case that exposes the bug (preferably before
-      fixing it).
-
-    * If you need to create a temporary file, you can use the filename in
-      ``test_support.TESTFN`` to do so.  It is important to remove the file
-      when done; other tests should be able to use the name without cleaning
-      up after your test.
-
-.. _"The Art of Software Testing": 
-        http://www.amazon.com/exec/obidos/ISBN=0471043281
-
-Regression Test Writing Rules
-=============================
-Each test case is different.  There is no "standard" form for a Python
-regression test case, though there are some general rules (note that
-these mostly apply only to the "classic" tests; unittest_- and doctest_-
-based tests should follow the conventions natural to those frameworks)::
-
-    * If your test case detects a failure, raise ``TestFailed`` (found in
-      ``test.test_support``).
-
-    * Import everything you'll need as early as possible.
-
-    * If you'll be importing objects from a module that is at least
-      partially platform-dependent, only import those objects you need for
-      the current test case to avoid spurious ``ImportError`` exceptions
-      that prevent the test from running to completion.
-
-    * Print all your test case results using the ``print`` statement.  For
-      non-fatal errors, print an error message (or omit a successful
-      completion print) to indicate the failure, but proceed instead of
-      raising ``TestFailed``.
-
-    * Use ``assert`` sparingly, if at all.  It's usually better to just print
-      what you got, and rely on regrtest's got-vs-expected comparison to
-      catch deviations from what you expect.  ``assert`` statements aren't
-      executed at all when regrtest is run in -O mode; and, because they
-      cause the test to stop immediately, can lead to a long & tedious
-      test-fix, test-fix, test-fix, ... cycle when things are badly broken
-      (and note that "badly broken" often includes running the test suite
-      for the first time on new platforms or under new implementations of
-      the language).
-
-Miscellaneous
-=============
-There is a test_support module in the test package you can import for
-your test case.  Import this module using either::
-
-    import test.test_support
-
-or::
-
-    from test import test_support
-
-test_support provides the following useful objects:
-
-    * ``TestFailed`` - raise this exception when your regression test detects
-      a failure.
-
-    * ``TestSkipped`` - raise this if the test could not be run because the
-      platform doesn't offer all the required facilities (like large
-      file support), even if all the required modules are available.
-
-    * ``ResourceDenied`` - this is raised when a test requires a resource that
-      is not available.  Primarily used by 'requires'.
-
-    * ``verbose`` - you can use this variable to control print output.  Many
-      modules use it.  Search for "verbose" in the test_*.py files to see
-      lots of examples.
-
-    * ``forget(module_name)`` - attempts to cause Python to "forget" that it
-      loaded a module and erase any PYC files.
-
-    * ``is_resource_enabled(resource)`` - Returns a boolean based on whether
-      the resource is enabled or not.
-
-    * ``requires(resource [, msg])`` - if the required resource is not
-      available the ResourceDenied exception is raised.
-    
-    * ``verify(condition, reason='test failed')``.  Use this instead of::
-
-          assert condition[, reason]
-
-      ``verify()`` has two advantages over ``assert``:  it works even in -O
-      mode, and it raises ``TestFailed`` on failure instead of
-      ``AssertionError``.
-
-    * ``is_jython`` - true if the interpreter is Jython, false otherwise.
-
-    * ``TESTFN`` - a string that should always be used as the filename when
-      you need to create a temp file.  Also use ``try``/``finally`` to
-      ensure that your temp files are deleted before your test completes.
-      Note that you cannot unlink an open file on all operating systems, so
-      also be sure to close temp files before trying to unlink them.
-
-    * ``sortdict(dict)`` - acts like ``repr(dict.items())``, but sorts the
-      items first.  This is important when printing a dict value, because
-      the order of items produced by ``dict.items()`` is not defined by the
-      language.
-
-    * ``findfile(file)`` - you can call this function to locate a file
-      somewhere along sys.path or in the Lib/test tree - see
-      test_ossaudiodev.py for an example of its use.
-
-    * ``fcmp(x,y)`` - you can call this function to compare two floating
-      point numbers when you expect them to only be approximately equal
-      withing a fuzz factor (``test_support.FUZZ``, which defaults to 1e-6).
-
-    * ``check_syntax_error(testcase, statement)`` - make sure that the
-      statement is *not* correct Python syntax.
-
-
-Some Non-Obvious regrtest Features
-==================================
-    * Automagic test detection:  When you create a new test file
-      test_spam.py, you do not need to modify regrtest (or anything else)
-      to advertise its existence.  regrtest searches for and runs all
-      modules in the test directory with names of the form test_xxx.py.
-
-    * Miranda output:  If, when running test_spam.py, regrtest does not
-      find an expected-output file test/output/test_spam, regrtest
-      pretends that it did find one, containing the single line
-
-      test_spam
-
-      This allows new tests that don't expect to print anything to stdout
-      to not bother creating expected-output files.
-
-    * Two-stage testing:  To run test_spam.py, regrtest imports test_spam
-      as a module.  Most tests run to completion as a side-effect of
-      getting imported.  After importing test_spam, regrtest also executes
-      ``test_spam.test_main()``, if test_spam has a ``test_main`` attribute.
-      This is rarely required with the "traditional" Python tests, and
-      you shouldn't create a module global with name test_main unless
-      you're specifically exploiting this gimmick.  This usage does
-      prove useful with unittest-based tests as well, however; defining
-      a ``test_main()`` which is run by regrtest and a script-stub in the
-      test module ("``if __name__ == '__main__': test_main()``") allows
-      the test to be used like any other Python test and also work
-      with the unittest.py-as-a-script approach, allowing a developer
-      to run specific tests from the command line.
diff --git a/Lib/test/test_pprint.py b/Lib/test/test_pprint.py
index f9b679e..1469ff0 100644
--- a/Lib/test/test_pprint.py
+++ b/Lib/test/test_pprint.py
@@ -115,10 +115,10 @@ class QueryTestCase(unittest.TestCase):
                        {}, dict2(), dict3(),
                        verify, pprint,
                        -6, -6, -6-6j, -1.5, "x", b"x", (3,), [3], {3: 6},
-                       (1,2), [3,4], {5: 6, 7: 8},
+                       (1,2), [3,4], {5: 6},
                        tuple2((1,2)), tuple3((1,2)), tuple3(range(100)),
                        [3,4], list2([3,4]), list3([3,4]), list3(range(100)),
-                       {5: 6, 7: 8}, dict2({5: 6}), dict3({5: 6}),
+                       dict2({5: 6}), dict3({5: 6}),
                        range(10, -11, -1)
                       ):
             native = repr(simple)
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index b81c4fe..474d855 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -225,6 +225,11 @@ class SysModuleTest(unittest.TestCase):
             sys.setdlopenflags(oldflags)
 
     def test_refcount(self):
+        # n here must be a global in order for this test to pass while
+        # tracing with a python function.  Tracing calls PyFrame_FastToLocals
+        # which will add a copy of any locals to the frame object, causing
+        # the reference count to increase by 2 instead of 1.
+        global n
         self.assertRaises(TypeError, sys.getrefcount)
         c = sys.getrefcount(None)
         n = None
diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py
index 956672d..eabd7f4 100644
--- a/Lib/test/test_threading.py
+++ b/Lib/test/test_threading.py
@@ -84,11 +84,24 @@ class ThreadTests(unittest.TestCase):
             t.join(NUMTASKS)
             self.assert_(not t.is_alive())
             self.failIfEqual(t.ident, 0)
+            self.assertFalse(t.ident is None)
             self.assert_(re.match('<TestThread\(.*, \w+ -?\d+\)>', repr(t)))
         if verbose:
             print('all tasks done')
         self.assertEqual(numrunning.get(), 0)
 
+    def test_ident_of_no_threading_threads(self):
+        # The ident still must work for the main thread and dummy threads.
+        self.assertFalse(threading.currentThread().ident is None)
+        def f():
+            ident.append(threading.currentThread().ident)
+            done.set()
+        done = threading.Event()
+        ident = []
+        _thread.start_new_thread(f, ())
+        done.wait()
+        self.assertFalse(ident[0] is None)
+
     # run with a small(ish) thread stack size (256kB)
     def test_various_ops_small_stack(self):
         if verbose:
@@ -187,7 +200,8 @@ class ThreadTests(unittest.TestCase):
         # Now raise an exception in the worker thread.
         if verbose:
             print("    waiting for worker thread to get started")
-        worker_started.wait()
+        ret = worker_started.wait()
+        self.assertTrue(ret)
         if verbose:
             print("    verifying worker hasn't exited")
         self.assert_(not t.finished)
diff --git a/Lib/threading.py b/Lib/threading.py
index b541d77..d4fcbb0 100644
--- a/Lib/threading.py
+++ b/Lib/threading.py
@@ -375,6 +375,7 @@ class _Event(_Verbose):
         try:
             if not self._flag:
                 self._cond.wait(timeout)
+            return self._flag
         finally:
             self._cond.release()
 
@@ -450,9 +451,8 @@ class Thread(_Verbose):
             raise RuntimeError("thread already started")
         if __debug__:
             self._note("%s.start(): starting thread", self)
-        _active_limbo_lock.acquire()
-        _limbo[self] = self
-        _active_limbo_lock.release()
+        with _active_limbo_lock:
+            _limbo[self] = self
         _start_new_thread(self._bootstrap, ())
         self._started.wait()
 
@@ -485,14 +485,16 @@ class Thread(_Verbose):
                 return
             raise
 
+    def _set_ident(self):
+        self._ident = _get_ident()
+
     def _bootstrap_inner(self):
         try:
-            self._ident = _get_ident()
+            self._set_ident()
             self._started.set()
-            _active_limbo_lock.acquire()
-            _active[self._ident] = self
-            del _limbo[self]
-            _active_limbo_lock.release()
+            with _active_limbo_lock:
+                _active[self._ident] = self
+                del _limbo[self]
             if __debug__:
                 self._note("%s._bootstrap(): thread started", self)
 
@@ -721,9 +723,9 @@ class _MainThread(Thread):
     def __init__(self):
         Thread.__init__(self, name="MainThread")
         self._started.set()
-        _active_limbo_lock.acquire()
-        _active[_get_ident()] = self
-        _active_limbo_lock.release()
+        self._set_ident()
+        with _active_limbo_lock:
+            _active[self._ident] = self
 
     def _set_daemon(self):
         return False
@@ -768,9 +770,9 @@ class _DummyThread(Thread):
 
 
         self._started.set()
-        _active_limbo_lock.acquire()
-        _active[_get_ident()] = self
-        _active_limbo_lock.release()
+        self._set_ident()
+        with _active_limbo_lock:
+            _active[self._ident] = self
 
     def _set_daemon(self):
         return True
@@ -791,18 +793,14 @@ def current_thread():
 currentThread = current_thread
 
 def active_count():
-    _active_limbo_lock.acquire()
-    count = len(_active) + len(_limbo)
-    _active_limbo_lock.release()
-    return count
+    with _active_limbo_lock:
+        return len(_active) + len(_limbo)
 
 activeCount = active_count
 
 def enumerate():
-    _active_limbo_lock.acquire()
-    active = list(_active.values()) + list(_limbo.values())
-    _active_limbo_lock.release()
-    return active
+    with _active_limbo_lock:
+        return list(_active.values()) + list(_limbo.values())
 
 from _thread import stack_size