diff --git a/Doc/library/2to3.rst b/Doc/library/2to3.rst
index 90284af..9b2b4e4 100644
--- a/Doc/library/2to3.rst
+++ b/Doc/library/2to3.rst
@@ -352,6 +352,7 @@
    :synopsis: the 2to3 library
 .. moduleauthor:: Guido van Rossum
 .. moduleauthor:: Collin Winter
+.. moduleauthor:: Benjamin Peterson <benjamin@python.org>
 
 
 .. note::
diff --git a/Doc/library/collections.rst b/Doc/library/collections.rst
index c334dc7..fca84bd 100644
--- a/Doc/library/collections.rst
+++ b/Doc/library/collections.rst
@@ -169,7 +169,7 @@
    class is similar to bags or multisets in other languages.
 
    Elements are counted from an *iterable* or initialized from another
-   *mapping* (or counter)::
+   *mapping* (or counter):
 
         >>> c = Counter()                           # a new, empty counter
         >>> c = Counter('gallahad')                 # a new counter from an iterable
@@ -177,7 +177,7 @@
         >>> c = Counter(cats=4, dogs=8)             # a new counter from keyword args
 
    Counter objects have a dictionary interface except that they return a zero
-   count for missing items instead of raising a :exc:`KeyError`::
+   count for missing items instead of raising a :exc:`KeyError`:
 
         >>> c = Counter(['eggs', 'ham'])
         >>> c['bacon']                              # count of a missing element is zero
@@ -210,7 +210,7 @@
       Return a list of the *n* most common elements and their counts from the
       most common to the least.  If *n* is not specified, :func:`most_common`
       returns *all* elements in the counter.  Elements with equal counts are
-      ordered arbitrarily::
+      ordered arbitrarily:
 
             >>> Counter('abracadabra').most_common(3)
             [('a', 5), ('r', 2), ('b', 2)]
diff --git a/Doc/library/decimal.rst b/Doc/library/decimal.rst
index 2b4d156..a27fbf4 100644
--- a/Doc/library/decimal.rst
+++ b/Doc/library/decimal.rst
@@ -1746,7 +1746,7 @@
    >>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))
    Traceback (most recent call last):
       ...
-   Inexact
+   Inexact: None
 
 Q. Once I have valid two place inputs, how do I maintain that invariant
 throughout an application?
diff --git a/Doc/library/json.rst b/Doc/library/json.rst
index 819c339..955c25b 100644
--- a/Doc/library/json.rst
+++ b/Doc/library/json.rst
@@ -165,12 +165,12 @@
    document) to a Python object.
 
    *object_hook* is an optional function that will be called with the result of
-   any object literal decode (a :class:`dict`).  The return value of
+   any object literal decoded (a :class:`dict`).  The return value of
    *object_hook* will be used instead of the :class:`dict`.  This feature can be used
    to implement custom decoders (e.g. JSON-RPC class hinting).
 
    *object_pairs_hook* is an optional function that will be called with the
-   result of any object literal decode with an ordered list of pairs.  The
+   result of any object literal decoded with an ordered list of pairs.  The
    return value of *object_pairs_hook* will be used instead of the
    :class:`dict`.  This feature can be used to implement custom decoders that
    rely on the order that the key and value pairs are decoded (for example,
diff --git a/Doc/library/shelve.rst b/Doc/library/shelve.rst
index 8121004..8c1f08b 100644
--- a/Doc/library/shelve.rst
+++ b/Doc/library/shelve.rst
@@ -1,4 +1,3 @@
-
 :mod:`shelve` --- Python object persistence
 ===========================================
 
@@ -35,7 +34,7 @@
    accessed entries are written back (there is no way to determine which accessed
    entries are mutable, nor which ones were actually mutated).
 
-Shelve objects support all methods supported by dictionaries.  This eases the
+Shelf objects support all methods supported by dictionaries.  This eases the
 transition from dictionary based scripts to those requiring persistent storage.
 
 One additional method is supported:
diff --git a/Doc/library/subprocess.rst b/Doc/library/subprocess.rst
index 3b6c8cc..7952f68 100644
--- a/Doc/library/subprocess.rst
+++ b/Doc/library/subprocess.rst
@@ -174,13 +174,13 @@
    :attr:`returncode`
    attribute and output in the :attr:`output` attribute.
 
-   The arguments are the same as for the :class:`Popen` constructor.  Example:
+   The arguments are the same as for the :class:`Popen` constructor.  Example::
 
       >>> subprocess.check_output(["ls", "-l", "/dev/null"])
       'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'
 
    The stdout argument is not allowed as it is used internally.
-   To capture standard error in the result, use stderr=subprocess.STDOUT.
+   To capture standard error in the result, use ``stderr=subprocess.STDOUT``::
 
       >>> subprocess.check_output(
               ["/bin/sh", "-c", "ls non_existent_file ; exit 0"],
diff --git a/Doc/library/traceback.rst b/Doc/library/traceback.rst
index 6929c1d..5c42740 100644
--- a/Doc/library/traceback.rst
+++ b/Doc/library/traceback.rst
@@ -228,7 +228,7 @@
    *** extract_tb:
    [('<doctest...>', 10, '<module>', 'lumberjack()'),
     ('<doctest...>', 4, 'lumberjack', 'bright_side_of_death()'),
-    (u'<doctest...>', 7, 'bright_side_of_death', 'return tuple()[0]')]
+    ('<doctest...>', 7, 'bright_side_of_death', 'return tuple()[0]')]
    *** format_tb:
    ['  File "<doctest...>", line 10, in <module>\n    lumberjack()\n',
     '  File "<doctest...>", line 4, in lumberjack\n    bright_side_of_death()\n',
diff --git a/Doc/library/unittest.rst b/Doc/library/unittest.rst
index 675114a..abeb8a0 100644
--- a/Doc/library/unittest.rst
+++ b/Doc/library/unittest.rst
@@ -954,7 +954,6 @@
       along with the method name.
 
       .. versionchanged:: 3.1
-
          In earlier versions this only returned the first line of the test
          method's docstring, if available or the :const:`None`.  That led to
          undesirable behavior of not printing the test name when someone was
@@ -978,6 +977,36 @@
       .. versionadded:: 3.1
 
 
+   .. method:: addCleanup(function[, *args[, **kwargs]])
+
+      Add a function to be called after :meth:`tearDown` to cleanup resources
+      used during the test. Functions will be called in reverse order to the
+      order they are added (LIFO). They are called with any arguments and
+      keyword arguments passed into :meth:`addCleanup` when they are
+      added.
+
+      If :meth:`setUp` fails, meaning that :meth:`tearDown` is not called,
+      then any cleanup functions added will still be called.
+
+      .. versionadded:: 2.7
+
+
+   .. method:: doCleanups()
+
+      This method is called uncoditionally after :meth:`tearDown`, or
+      after :meth:`setUp` if :meth:`setUp` raises an exception.
+
+      It is responsible for calling all the cleanup functions added by
+      :meth:`addCleanup`. If you need cleanup functions to be called
+      *prior* to :meth:`tearDown` then you can call :meth:`doCleanups`
+      yourself.
+
+      :meth:`doCleanups` pops methods off the stack of cleanup
+      functions one at a time, so it can be called at any time.
+
+      .. versionadded:: 2.7
+
+
 .. class:: FunctionTestCase(testFunc[, setUp[, tearDown[, description]]])
 
    This class implements the portion of the :class:`TestCase` interface which
@@ -1046,6 +1075,20 @@
       Return the number of tests represented by this test object, including all
       individual tests and sub-suites.
 
+
+   .. method:: __iter__()
+
+      Tests grouped by a :class:`TestSuite` are always accessed by iteration.
+      Subclasses can lazily provide tests by overriding :meth:`__iter__`. Note
+      that this method maybe called several times on a single suite
+      (for example when counting tests or comparing for equality)
+      so the tests returned must be the same for repeated iterations.
+
+      .. versionchanged:: 2.7
+         In earlier versions the :class:`TestSuite` accessed tests directly rather
+         than through iteration, so overriding :meth:`__iter__` wasn't sufficient
+         for providing tests.
+
    In the typical usage of a :class:`TestSuite` object, the :meth:`run` method
    is invoked by a :class:`TestRunner` rather than by the end-user test harness.
 
@@ -1190,7 +1233,6 @@
       holding formatted tracebacks. Each tuple represents a test which raised an
       unexpected exception.
 
-
    .. attribute:: failures
 
       A list containing 2-tuples of :class:`TestCase` instances and strings
@@ -1266,6 +1308,20 @@
       The default implementation does nothing.
 
 
+   .. method:: startTestRun(test)
+
+      Called once before any tests are executed.
+
+      .. versionadded:: 2.7
+
+
+   .. method:: stopTestRun(test)
+
+      Called once before any tests are executed.
+
+      .. versionadded:: 2.7
+
+
    .. method:: addError(test, err)
 
       Called when the test case *test* raises an unexpected exception *err* is a
@@ -1335,8 +1391,14 @@
    has a few configurable parameters, but is essentially very simple.  Graphical
    applications which run test suites should provide alternate implementations.
 
+   .. method:: _makeResult()
 
-.. function:: main([module[, defaultTest[, argv[, testRunner[, testLoader]]]]])
+      This method returns the instance of ``TestResult`` used by :meth:`run`.
+      It is not intended to be called directly, but can be overridden in
+      subclasses to provide a custom ``TestResult``.
+
+
+.. function:: main([module[, defaultTest[, argv[, testRunner[, testLoader[, exit]]]]]])
 
    A command-line program that runs a set of tests; this is primarily for making
    test modules conveniently executable.  The simplest use for this function is to
@@ -1346,4 +1408,18 @@
           unittest.main()
 
    The *testRunner* argument can either be a test runner class or an already
-   created instance of it.
+   created instance of it. By default ``main`` calls :func:`sys.exit` with
+   an exit code indicating success or failure of the tests run.
+
+   ``main`` supports being used from the interactive interpreter by passing in the
+   argument ``exit=False``. This displays the result on standard output without
+   calling :func:`sys.exit`::
+
+      >>> from unittest import main
+      >>> main(module='test_module', exit=False)
+
+   Calling ``main`` actually returns an instance of the ``TestProgram`` class.
+   This stores the result of the tests run as the ``result`` attribute.
+
+   .. versionchanged:: 2.7
+      The ``exit`` parameter was added.