diff --git a/Doc/howto/unicode.rst b/Doc/howto/unicode.rst
index 21ae1110882..561ce29f52e 100644
--- a/Doc/howto/unicode.rst
+++ b/Doc/howto/unicode.rst
@@ -410,9 +410,9 @@ either the first or second line of the source file::
     
 The syntax is inspired by Emacs's notation for specifying variables local to a
 file.  Emacs supports many different variables, but Python only supports
-'coding'.  The ``-*-`` symbols indicate that the comment is special; within
-them, you must supply the name ``coding`` and the name of your chosen encoding,
-separated by ``':'``.
+'coding'.  The ``-*-`` symbols indicate to Emacs that the comment is special;
+they have no significance to Python but are a convention.  Python looks for
+``coding: name`` or ``coding=name`` in the comment.
 
 If you don't include such a comment, the default encoding used will be ASCII.
 Versions of Python before 2.4 were Euro-centric and assumed Latin-1 as a default
diff --git a/Doc/library/bdb.rst b/Doc/library/bdb.rst
index 82a1c21eadd..3041b7bc00f 100644
--- a/Doc/library/bdb.rst
+++ b/Doc/library/bdb.rst
@@ -107,8 +107,9 @@ The :mod:`bdb` module also defines two classes:
 
       The *arg* parameter depends on the previous event.
 
-      For more information on trace functions, see :ref:`debugger-hooks`.  For
-      more information on code and frame objects, refer to :ref:`types`.
+      See the documentation for :func:`sys.settrace` for more information on the
+      trace function.  For more information on code and frame objects, refer to
+      :ref:`types`.
 
    .. method:: dispatch_line(frame)
 
diff --git a/Doc/library/collections.rst b/Doc/library/collections.rst
index 258b54fdc60..40ec9e8f10b 100644
--- a/Doc/library/collections.rst
+++ b/Doc/library/collections.rst
@@ -60,7 +60,7 @@ ABC                        Inherits               Abstract Methods        Mixin
                            :class:`Iterable`,     and ``__len__``         ``index``, and ``count``
                            :class:`Container`     
                                                   
-:class:`MutableSequnce`    :class:`Sequence`      ``__getitem__``         Inherited Sequence methods and
+:class:`MutableSequence`   :class:`Sequence`      ``__getitem__``         Inherited Sequence methods and
                                                   ``__delitem__``,        ``append``, ``reverse``, ``extend``, ``pop``,
                                                   ``insert``,             ``remove``, and ``__iadd__``
                                                   and ``__len__``
@@ -487,16 +487,16 @@ Named tuples assign meaning to each position in a tuple and allow for more reada
 self-documenting code.  They can be used wherever regular tuples are used, and
 they add the ability to access fields by name instead of position index.
 
-.. function:: namedtuple(typename, fieldnames, [verbose])
+.. function:: namedtuple(typename, field_names, [verbose])
 
    Returns a new tuple subclass named *typename*.  The new subclass is used to
    create tuple-like objects that have fields accessible by attribute lookup as
    well as being indexable and iterable.  Instances of the subclass also have a
-   helpful docstring (with typename and fieldnames) and a helpful :meth:`__repr__`
+   helpful docstring (with typename and field_names) and a helpful :meth:`__repr__`
    method which lists the tuple contents in a ``name=value`` format.
 
-   The *fieldnames* are a single string with each fieldname separated by whitespace
-   and/or commas, for example ``'x y'`` or ``'x, y'``.  Alternatively, *fieldnames*
+   The *field_names* are a single string with each fieldname separated by whitespace
+   and/or commas, for example ``'x y'`` or ``'x, y'``.  Alternatively, *field_names*
    can be a sequence of strings such as ``['x', 'y']``.
 
    Any valid Python identifier may be used for a fieldname except for names
diff --git a/Doc/library/ctypes.rst b/Doc/library/ctypes.rst
index 8e920f8056d..0e3733295ff 100644
--- a/Doc/library/ctypes.rst
+++ b/Doc/library/ctypes.rst
@@ -1370,7 +1370,7 @@ function exported by these libraries, and reacquired afterwards.
 
 All these classes can be instantiated by calling them with at least one
 argument, the pathname of the shared library.  If you have an existing handle to
-an already loaded shard library, it can be passed as the ``handle`` named
+an already loaded shared library, it can be passed as the ``handle`` named
 parameter, otherwise the underlying platforms ``dlopen`` or :meth:`LoadLibrary`
 function is used to load the library into the process, and to get a handle to
 it.
diff --git a/Doc/library/io.rst b/Doc/library/io.rst
index 18df0e0514f..25d5f16dbae 100644
--- a/Doc/library/io.rst
+++ b/Doc/library/io.rst
@@ -214,8 +214,10 @@ I/O Base Classes
 
    .. method:: close()
 
-      Flush and close this stream.  This method has no effect if the file is
-      already closed.
+      Flush and close this stream. This method has no effect if the file is
+      already closed. Once the file is closed, any operation on the file 
+      (e.g. reading or writing) will raise an :exc:`IOError`. The internal
+      file descriptor isn't closed if *closefd* was False.
 
    .. attribute:: closed
 
diff --git a/Doc/library/multiprocessing.rst b/Doc/library/multiprocessing.rst
index 7a131837cf1..e1992cc68a9 100644
--- a/Doc/library/multiprocessing.rst
+++ b/Doc/library/multiprocessing.rst
@@ -919,7 +919,7 @@ inherited by child processes.
 
    Note that *lock* is a keyword only argument.
 
-   Note that an array of :data:`ctypes.c_char` has *value* and *rawvalue*
+   Note that an array of :data:`ctypes.c_char` has *value* and *raw*
    attributes which allow one to use it to store and retrieve strings.
 
 
@@ -968,7 +968,7 @@ processes.
    :func:`Value` instead to make sure that access is automatically synchronized
    using a lock.
 
-   Note that an array of :data:`ctypes.c_char` has ``value`` and ``rawvalue``
+   Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw``
    attributes which allow one to use it to store and retrieve strings -- see
    documentation for :mod:`ctypes`.
 
diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 14784fad663..1cb450b6abe 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -933,10 +933,10 @@ Files and Directories
 
 .. function:: listdir(path)
 
-   Return a list containing the names of the entries in the directory. The list is
-   in arbitrary order.  It does not include the special entries ``'.'`` and
-   ``'..'`` even if they are present in the directory. Availability:
-   Unix, Windows.
+   Return a list containing the names of the entries in the directory given by
+   *path*.  The list is in arbitrary order.  It does not include the special
+   entries ``'.'`` and ``'..'`` even if they are present in the
+   directory.  Availability: Unix, Windows.
 
    .. versionchanged:: 2.3
       On Windows NT/2k/XP and Unix, if *path* is a Unicode object, the result will be
diff --git a/Doc/library/pdb.rst b/Doc/library/pdb.rst
index c1a0bcd1c14..384c7d9f38b 100644
--- a/Doc/library/pdb.rst
+++ b/Doc/library/pdb.rst
@@ -351,68 +351,3 @@ run [*args* ...]
 
 q(uit)
    Quit from the debugger. The program being executed is aborted.
-
-
-.. _debugger-hooks:
-
-How It Works
-============
-
-Some changes were made to the interpreter:
-
-* ``sys.settrace(func)`` sets the global trace function
-
-* there can also a local trace function (see later)
-
-Trace functions have three arguments: *frame*, *event*, and *arg*. *frame* is
-the current stack frame.  *event* is a string: ``'call'``, ``'line'``,
-``'return'``, ``'exception'``, ``'c_call'``, ``'c_return'``, or
-``'c_exception'``. *arg* depends on the event type.
-
-The global trace function is invoked (with *event* set to ``'call'``) whenever a
-new local scope is entered; it should return a reference to the local trace
-function to be used that scope, or ``None`` if the scope shouldn't be traced.
-
-The local trace function should return a reference to itself (or to another
-function for further tracing in that scope), or ``None`` to turn off tracing in
-that scope.
-
-Instance methods are accepted (and very useful!) as trace functions.
-
-The events have the following meaning:
-
-``'call'``
-   A function is called (or some other code block entered).  The global trace
-   function is called; *arg* is ``None``; the return value specifies the local
-   trace function.
-
-``'line'``
-   The interpreter is about to execute a new line of code (sometimes multiple line
-   events on one line exist).  The local trace function is called; *arg* is
-   ``None``; the return value specifies the new local trace function.
-
-``'return'``
-   A function (or other code block) is about to return.  The local trace function
-   is called; *arg* is the value that will be returned.  The trace function's
-   return value is ignored.
-
-``'exception'``
-   An exception has occurred.  The local trace function is called; *arg* is a
-   triple ``(exception, value, traceback)``; the return value specifies the new
-   local trace function.
-
-``'c_call'``
-   A C function is about to be called.  This may be an extension function or a
-   builtin.  *arg* is the C function object.
-
-``'c_return'``
-   A C function has returned. *arg* is ``None``.
-
-``'c_exception'``
-   A C function has thrown an exception.  *arg* is ``None``.
-
-Note that as an exception is propagated down the chain of callers, an
-``'exception'`` event is generated at each level.
-
-For more information on code and frame objects, refer to :ref:`types`.
-
diff --git a/Doc/library/sys.rst b/Doc/library/sys.rst
index 111755068c1..fa7b7f098b7 100644
--- a/Doc/library/sys.rst
+++ b/Doc/library/sys.rst
@@ -712,11 +712,60 @@ always available.
       single: debugger
 
    Set the system's trace function, which allows you to implement a Python
-   source code debugger in Python.  See section :ref:`debugger-hooks` in the
-   chapter on the Python debugger.  The function is thread-specific; for a
+   source code debugger in Python.  The function is thread-specific; for a
    debugger to support multiple threads, it must be registered using
    :func:`settrace` for each thread being debugged.
 
+   Trace functions should have three arguments: *frame*, *event*, and
+   *arg*. *frame* is the current stack frame.  *event* is a string: ``'call'``,
+   ``'line'``, ``'return'``, ``'exception'``, ``'c_call'``, ``'c_return'``, or
+   ``'c_exception'``. *arg* depends on the event type.
+
+   The trace function is invoked (with *event* set to ``'call'``) whenever a new
+   local scope is entered; it should return a reference to a local trace
+   function to be used that scope, or ``None`` if the scope shouldn't be traced.
+
+   The local trace function should return a reference to itself (or to another
+   function for further tracing in that scope), or ``None`` to turn off tracing
+   in that scope.
+
+   The events have the following meaning:
+
+   ``'call'`` 
+      A function is called (or some other code block entered).  The
+      global trace function is called; *arg* is ``None``; the return value
+      specifies the local trace function.
+
+   ``'line'``
+      The interpreter is about to execute a new line of code (sometimes multiple
+      line events on one line exist).  The local trace function is called; *arg*
+      is ``None``; the return value specifies the new local trace function.
+
+   ``'return'``
+      A function (or other code block) is about to return.  The local trace
+      function is called; *arg* is the value that will be returned.  The trace
+      function's return value is ignored.
+
+   ``'exception'``
+      An exception has occurred.  The local trace function is called; *arg* is a
+      tuple ``(exception, value, traceback)``; the return value specifies the
+      new local trace function.
+
+   ``'c_call'``
+      A C function is about to be called.  This may be an extension function or
+      a builtin.  *arg* is the C function object.
+
+   ``'c_return'``
+      A C function has returned. *arg* is ``None``.
+
+   ``'c_exception'``
+      A C function has thrown an exception.  *arg* is ``None``.
+
+   Note that as an exception is propagated down the chain of callers, an
+   ``'exception'`` event is generated at each level.
+
+   For more information on code and frame objects, refer to :ref:`types`.
+
    .. note::
 
       The :func:`settrace` function is intended only for implementing debuggers,
diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst
index b1ab8fd97cc..7304c9c385c 100644
--- a/Doc/reference/datamodel.rst
+++ b/Doc/reference/datamodel.rst
@@ -1365,21 +1365,21 @@ Basic customization
       object: dictionary
       builtin: hash
 
-   Called for the key object for dictionary operations, and by the built-in
-   function :func:`hash`.  Should return an integer usable as a hash value
-   for dictionary operations.  The only required property is that objects which
-   compare equal have the same hash value; it is advised to somehow mix together
-   (e.g., using exclusive or) the hash values for the components of the object that
-   also play a part in comparison of objects.
+   Called by built-in function :func:`hash` and for operations on members of
+   hashed collections including :class:`set`, :class:`frozenset`, and
+   :class:`dict`.  :meth:`__hash__` should return an integer.  The only required
+   property is that objects which compare equal have the same hash value; it is
+   advised to somehow mix together (e.g. using exclusive or) the hash values for
+   the components of the object that also play a part in comparison of objects.
 
    If a class does not define a :meth:`__cmp__` or :meth:`__eq__` method it
    should not define a :meth:`__hash__` operation either; if it defines
    :meth:`__cmp__` or :meth:`__eq__` but not :meth:`__hash__`, its instances
-   will not be usable as dictionary keys.  If a class defines mutable objects
+   will not be usable in hashed collections.  If a class defines mutable objects
    and implements a :meth:`__cmp__` or :meth:`__eq__` method, it should not
-   implement :meth:`__hash__`, since the dictionary implementation requires that
-   a key's hash value is immutable (if the object's hash value changes, it will
-   be in the wrong hash bucket).
+   implement :meth:`__hash__`, since hashable collection implementations require
+   that a object's hash value is immutable (if the object's hash value changes,
+   it will be in the wrong hash bucket).
 
    User-defined classes have :meth:`__cmp__` and :meth:`__hash__` methods
    by default; with them, all objects compare unequal (except with themselves)
@@ -1389,13 +1389,13 @@ Basic customization
    change the meaning of :meth:`__cmp__` or :meth:`__eq__` such that the hash
    value returned is no longer appropriate (e.g. by switching to a value-based
    concept of equality instead of the default identity based equality) can
-   explicitly flag themselves as being unhashable by setting
-   ``__hash__ = None`` in the class definition. Doing so means that not only
-   will instances of the class raise an appropriate :exc:`TypeError` when
-   a program attempts to retrieve their hash value, but they will also be
-   correctly identified as unhashable when checking
-   ``isinstance(obj, collections.Hashable)`` (unlike classes which define
-   their own :meth:`__hash__` to explicitly raise :exc:`TypeError`).
+   explicitly flag themselves as being unhashable by setting ``__hash__ = None``
+   in the class definition. Doing so means that not only will instances of the
+   class raise an appropriate :exc:`TypeError` when a program attempts to
+   retrieve their hash value, but they will also be correctly identified as
+   unhashable when checking ``isinstance(obj, collections.Hashable)`` (unlike
+   classes which define their own :meth:`__hash__` to explicitly raise
+   :exc:`TypeError`).
 
    .. versionchanged:: 2.5
       :meth:`__hash__` may now also return a long integer object; the 32-bit
diff --git a/Lib/doctest.py b/Lib/doctest.py
index 8806d6e7f84..8a5a22c1ca8 100644
--- a/Lib/doctest.py
+++ b/Lib/doctest.py
@@ -854,12 +854,12 @@ class DocTestFinder:
         """
         if module is None:
             return True
+        elif inspect.getmodule(object) is not None:
+            return module is inspect.getmodule(object)
         elif inspect.isfunction(object):
             return module.__dict__ is object.func_globals
         elif inspect.isclass(object):
             return module.__name__ == object.__module__
-        elif inspect.getmodule(object) is not None:
-            return module is inspect.getmodule(object)
         elif hasattr(object, '__module__'):
             return module.__name__ == object.__module__
         elif isinstance(object, property):
diff --git a/Lib/io.py b/Lib/io.py
index 8462dd5e6a7..110804e607f 100644
--- a/Lib/io.py
+++ b/Lib/io.py
@@ -238,8 +238,6 @@ def open(file, mode="r", buffering=None, encoding=None, errors=None,
         raise ValueError("invalid buffering size")
     if buffering == 0:
         if binary:
-            raw._name = file
-            raw._mode = mode
             return raw
         raise ValueError("can't have unbuffered text I/O")
     if updating:
@@ -251,11 +249,8 @@ def open(file, mode="r", buffering=None, encoding=None, errors=None,
     else:
         raise ValueError("unknown mode: %r" % mode)
     if binary:
-        buffer.name = file
-        buffer.mode = mode
         return buffer
     text = TextIOWrapper(buffer, encoding, errors, newline, line_buffering)
-    text.name = file
     text.mode = mode
     return text
 
@@ -622,6 +617,10 @@ class FileIO(_fileio._FileIO, RawIOBase):
     # that _fileio._FileIO inherits from io.RawIOBase (which would be hard
     # to do since _fileio.c is written in C).
 
+    def __init__(self, name, mode="r", closefd=True):
+        _fileio._FileIO.__init__(self, name, mode, closefd)
+        self._name = name
+
     def close(self):
         _fileio._FileIO.close(self)
         RawIOBase.close(self)
@@ -630,10 +629,6 @@ class FileIO(_fileio._FileIO, RawIOBase):
     def name(self):
         return self._name
 
-    @property
-    def mode(self):
-        return self._mode
-
 
 class BufferedIOBase(IOBase):
 
@@ -767,6 +762,14 @@ class _BufferedIOMixin(BufferedIOBase):
     def closed(self):
         return self.raw.closed
 
+    @property
+    def name(self):
+        return self.raw.name
+
+    @property
+    def mode(self):
+        return self.raw.mode
+
     ### Lower-level APIs ###
 
     def fileno(self):
@@ -1473,6 +1476,10 @@ class TextIOWrapper(TextIOBase):
     def closed(self):
         return self.buffer.closed
 
+    @property
+    def name(self):
+        return self.buffer.name
+
     def fileno(self):
         return self.buffer.fileno()
 
diff --git a/Lib/multiprocessing/pool.py b/Lib/multiprocessing/pool.py
index cb9f02ab8d5..9da27d48edf 100644
--- a/Lib/multiprocessing/pool.py
+++ b/Lib/multiprocessing/pool.py
@@ -149,7 +149,7 @@ class Pool(object):
 
     def imap(self, func, iterable, chunksize=1):
         '''
-        Equivalent of `itertool.imap()` -- can be MUCH slower than `Pool.map()`
+        Equivalent of `itertools.imap()` -- can be MUCH slower than `Pool.map()`
         '''
         assert self._state == RUN
         if chunksize == 1:
diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index 6e5ffa9fa20..45df1f34b5f 100644
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -725,7 +725,7 @@ class ByteArrayTest(BaseBytesTest):
         # Issue 4348.  Make sure that operations that don't mutate the array
         # copy the bytes.
         b = bytearray(b'abc')
-        #self.assertFalse(b is b.replace(b'abc', b'cde', 0))
+        self.assertFalse(b is b.replace(b'abc', b'cde', 0))
 
         t = bytearray([i for i in range(256)])
         x = bytearray(b'')
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 9ef2a818b3d..c9bd38ddffb 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -272,6 +272,30 @@ class IOTest(unittest.TestCase):
         self.assertRaises(ValueError, io.open, test_support.TESTFN, 'w',
                           closefd=False)
 
+    def testReadClosed(self):
+        with io.open(test_support.TESTFN, "w") as f:
+            f.write("egg\n")
+        with io.open(test_support.TESTFN, "r") as f:
+            file = io.open(f.fileno(), "r", closefd=False)
+            self.assertEqual(file.read(), "egg\n")
+            file.seek(0)
+            file.close()
+            self.assertRaises(ValueError, file.read)
+
+    def test_no_closefd_with_filename(self):
+        # can't use closefd in combination with a file name
+        self.assertRaises(ValueError,
+                          io.open, test_support.TESTFN, "r", closefd=False)
+
+    def test_closefd_attr(self):
+        with io.open(test_support.TESTFN, "wb") as f:
+            f.write(b"egg\n")
+        with io.open(test_support.TESTFN, "r") as f:
+            self.assertEqual(f.buffer.raw.closefd, True)
+            file = io.open(f.fileno(), "r", closefd=False)
+            self.assertEqual(file.buffer.raw.closefd, False)
+
+
 class MemorySeekTestMixin:
 
     def testInit(self):
@@ -1225,6 +1249,9 @@ class TextIOWrapperTest(unittest.TestCase):
 
 class MiscIOTest(unittest.TestCase):
 
+    def tearDown(self):
+        test_support.unlink(test_support.TESTFN)
+
     def testImport__all__(self):
         for name in io.__all__:
             obj = getattr(io, name, None)
@@ -1237,6 +1264,34 @@ class MiscIOTest(unittest.TestCase):
                 self.assert_(issubclass(obj, io.IOBase))
 
 
+    def test_attributes(self):
+        f = io.open(test_support.TESTFN, "wb", buffering=0)
+        self.assertEquals(f.mode, "w")
+        f.close()
+
+        f = io.open(test_support.TESTFN, "U")
+        self.assertEquals(f.name,            test_support.TESTFN)
+        self.assertEquals(f.buffer.name,     test_support.TESTFN)
+        self.assertEquals(f.buffer.raw.name, test_support.TESTFN)
+        self.assertEquals(f.mode,            "U")
+        self.assertEquals(f.buffer.mode,     "r")
+        self.assertEquals(f.buffer.raw.mode, "r")
+        f.close()
+
+        f = io.open(test_support.TESTFN, "w+")
+        self.assertEquals(f.mode,            "w+")
+        self.assertEquals(f.buffer.mode,     "r+") # Does it really matter?
+        self.assertEquals(f.buffer.raw.mode, "r+")
+
+        g = io.open(f.fileno(), "wb", closefd=False)
+        self.assertEquals(g.mode,     "w")
+        self.assertEquals(g.raw.mode, "w")
+        self.assertEquals(g.name,     f.fileno())
+        self.assertEquals(g.raw.name, f.fileno())
+        f.close()
+        g.close()
+
+
 def test_main():
     test_support.run_unittest(IOTest, BytesIOTest, StringIOTest,
                               BufferedReaderTest, BufferedWriterTest,
diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py
index bbdb93eddd2..c9294b13605 100644
--- a/Lib/test/test_xmlrpc.py
+++ b/Lib/test/test_xmlrpc.py
@@ -9,6 +9,7 @@ import threading
 import mimetools
 import httplib
 import socket
+import StringIO
 import os
 from test import test_support
 
@@ -639,9 +640,93 @@ class CGIHandlerTestCase(unittest.TestCase):
         os.remove("xmldata.txt")
         os.remove(test_support.TESTFN)
 
+class FakeSocket:
+
+    def __init__(self):
+        self.data = StringIO.StringIO()
+
+    def send(self, buf):
+        self.data.write(buf)
+        return len(buf)
+
+    def sendall(self, buf):
+        self.data.write(buf)
+
+    def getvalue(self):
+        return self.data.getvalue()
+
+    def makefile(self, x, y):
+        raise RuntimeError
+
+class FakeTransport(xmlrpclib.Transport):
+    """A Transport instance that records instead of sending a request.
+
+    This class replaces the actual socket used by httplib with a
+    FakeSocket object that records the request.  It doesn't provide a
+    response.
+    """
+
+    def make_connection(self, host):
+        conn = xmlrpclib.Transport.make_connection(self, host)
+        conn._conn.sock = self.fake_socket = FakeSocket()
+        return conn
+
+class TransportSubclassTestCase(unittest.TestCase):
+
+    def issue_request(self, transport_class):
+        """Return an HTTP request made via transport_class."""
+        transport = transport_class()
+        proxy = xmlrpclib.ServerProxy("http://example.com/",
+                                      transport=transport)
+        try:
+            proxy.pow(6, 8)
+        except RuntimeError:
+            return transport.fake_socket.getvalue()
+        return None
+
+    def test_custom_user_agent(self):
+        class TestTransport(FakeTransport):
+
+            def send_user_agent(self, conn):
+                xmlrpclib.Transport.send_user_agent(self, conn)
+                conn.putheader("X-Test", "test_custom_user_agent")
+
+        req = self.issue_request(TestTransport)
+        self.assert_("X-Test: test_custom_user_agent\r\n" in req)
+
+    def test_send_host(self):
+        class TestTransport(FakeTransport):
+
+            def send_host(self, conn, host):
+                xmlrpclib.Transport.send_host(self, conn, host)
+                conn.putheader("X-Test", "test_send_host")
+
+        req = self.issue_request(TestTransport)
+        self.assert_("X-Test: test_send_host\r\n" in req)
+
+    def test_send_request(self):
+        class TestTransport(FakeTransport):
+
+            def send_request(self, conn, url, body):
+                xmlrpclib.Transport.send_request(self, conn, url, body)
+                conn.putheader("X-Test", "test_send_request")
+
+        req = self.issue_request(TestTransport)
+        self.assert_("X-Test: test_send_request\r\n" in req)
+
+    def test_send_content(self):
+        class TestTransport(FakeTransport):
+
+            def send_content(self, conn, body):
+                conn.putheader("X-Test", "test_send_content")
+                xmlrpclib.Transport.send_content(self, conn, body)
+
+        req = self.issue_request(TestTransport)
+        self.assert_("X-Test: test_send_content\r\n" in req)
+
 def test_main():
     xmlrpc_tests = [XMLRPCTestCase, HelperTestCase, DateTimeTestCase,
-         BinaryTestCase, FaultTestCase]
+         BinaryTestCase, FaultTestCase, TransportSubclassTestCase]
 
     # The test cases against a SimpleXMLRPCServer raise a socket error
     # 10035 (WSAEWOULDBLOCK) in the server thread handle_request call when
diff --git a/Misc/NEWS b/Misc/NEWS
index a2aacc1f0f0..af50cf76c13 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -12,6 +12,11 @@ What's New in Python 2.6.2
 Core and Builtins
 -----------------
 
+- Issue #4233: Changed semantic of ``_fileio.FileIO``'s ``close()`` 
+  method on file objects with closefd=False. The file descriptor is still
+  kept open but the file object behaves like a closed file. The ``FileIO``
+  object also got a new readonly attribute ``closefd``.
+
 Library
 -------
 
diff --git a/Modules/_fileio.c b/Modules/_fileio.c
index 49bc29c7317..b9310f380ca 100644
--- a/Modules/_fileio.c
+++ b/Modules/_fileio.c
@@ -61,10 +61,7 @@ static PyObject *
 fileio_close(PyFileIOObject *self)
 {
 	if (!self->closefd) {
-		if (PyErr_WarnEx(PyExc_RuntimeWarning,
-				 "Trying to close unclosable fd!", 3) < 0) {
-			return NULL;
-		}
+		self->fd = -1;
 		Py_RETURN_NONE;
 	}
 	errno = internal_close(self);
@@ -820,6 +817,12 @@ get_closed(PyFileIOObject *self, void *closure)
 	return PyBool_FromLong((long)(self->fd < 0));
 }
 
+static PyObject *
+get_closefd(PyFileIOObject *self, void *closure)
+{
+	return PyBool_FromLong((long)(self->closefd));
+}
+
 static PyObject *
 get_mode(PyFileIOObject *self, void *closure)
 {
@@ -828,6 +831,8 @@ get_mode(PyFileIOObject *self, void *closure)
 
 static PyGetSetDef fileio_getsetlist[] = {
 	{"closed", (getter)get_closed, NULL, "True if the file is closed"},
+	{"closefd", (getter)get_closefd, NULL, 
+		"True if the file descriptor will be closed"},
 	{"mode", (getter)get_mode, NULL, "String giving the file mode"},
 	{0},
 };