diff --git a/Lib/test/test_bufio.py b/Lib/test/test_bufio.py
index e65951d..7d617d3 100644
--- a/Lib/test/test_bufio.py
+++ b/Lib/test/test_bufio.py
@@ -1,9 +1,12 @@
 import unittest
 from test import support
 
-# Simple test to ensure that optimizations in fileobject.c deliver
-# the expected results.  For best testing, run this under a debug-build
-# Python too (to exercise asserts in the C code).
+import io # C implementation.
+import _pyio as pyio # Python implementation.
+
+# Simple test to ensure that optimizations in the IO library deliver the
+# expected results.  For best testing, run this under a debug-build Python too
+# (to exercise asserts in the C code).
 
 lengths = list(range(1, 257)) + [512, 1000, 1024, 2048, 4096, 8192, 10000,
                                  16384, 32768, 65536, 1000000]
@@ -18,7 +21,7 @@
 
         # Since C doesn't guarantee we can write/read arbitrary bytes in text
         # files, use binary mode.
-        f = open(support.TESTFN, "wb")
+        f = self.open(support.TESTFN, "wb")
         try:
             # write once with \n and once without
             f.write(s)
@@ -58,8 +61,16 @@
     def test_nullpat(self):
         self.drive_one(bytes(1000))
 
+
+class CBufferSizeTest(BufferSizeTest):
+    open = io.open
+
+class PyBufferSizeTest(BufferSizeTest):
+    open = staticmethod(pyio.open)
+
+
 def test_main():
-    support.run_unittest(BufferSizeTest)
+    support.run_unittest(CBufferSizeTest, PyBufferSizeTest)
 
 if __name__ == "__main__":
     test_main()
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 8d43d7a..0554fc2 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -2605,10 +2605,10 @@
 
     def test_descrdoc(self):
         # Testing descriptor doc strings...
-        from _fileio import _FileIO
+        from _io import FileIO
         def check(descr, what):
             self.assertEqual(descr.__doc__, what)
-        check(_FileIO.closed, "True if the file is closed") # getset descriptor
+        check(FileIO.closed, "True if the file is closed") # getset descriptor
         check(complex.real, "the real part of a complex number") # member descriptor
 
     def test_doc_descriptor(self):
diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py
index 7a68b2f..3360121 100644
--- a/Lib/test/test_file.py
+++ b/Lib/test/test_file.py
@@ -4,6 +4,9 @@
 from array import array
 from weakref import proxy
 
+import io
+import _pyio as pyio
+
 from test.support import TESTFN, findfile, run_unittest
 from collections import UserList
 
@@ -11,7 +14,7 @@
     # file tests for which a test file is automatically set up
 
     def setUp(self):
-        self.f = open(TESTFN, 'wb')
+        self.f = self.open(TESTFN, 'wb')
 
     def tearDown(self):
         if self.f:
@@ -39,7 +42,7 @@
         self.f.write(b'12')
         self.f.close()
         a = array('b', b'x'*10)
-        self.f = open(TESTFN, 'rb')
+        self.f = self.open(TESTFN, 'rb')
         n = self.f.readinto(a)
         self.assertEquals(b'12', a.tostring()[:n])
 
@@ -47,7 +50,7 @@
         # verify readinto refuses text files
         a = array('b', b'x'*10)
         self.f.close()
-        self.f = open(TESTFN, 'r')
+        self.f = self.open(TESTFN, 'r')
         if hasattr(self.f, "readinto"):
             self.assertRaises(TypeError, self.f.readinto, a)
 
@@ -56,7 +59,7 @@
         l = UserList([b'1', b'2'])
         self.f.writelines(l)
         self.f.close()
-        self.f = open(TESTFN, 'rb')
+        self.f = self.open(TESTFN, 'rb')
         buf = self.f.read()
         self.assertEquals(buf, b'12')
 
@@ -126,13 +129,20 @@
     def testReadWhenWriting(self):
         self.assertRaises(IOError, self.f.read)
 
+class CAutoFileTests(AutoFileTests):
+    open = io.open
+
+class PyAutoFileTests(AutoFileTests):
+    open = staticmethod(pyio.open)
+
+
 class OtherFileTests(unittest.TestCase):
 
     def testModeStrings(self):
         # check invalid mode strings
         for mode in ("", "aU", "wU+"):
             try:
-                f = open(TESTFN, mode)
+                f = self.open(TESTFN, mode)
             except ValueError:
                 pass
             else:
@@ -153,7 +163,7 @@
         # verify that we get a sensible error message for bad mode argument
         bad_mode = "qwerty"
         try:
-            f = open(TESTFN, bad_mode)
+            f = self.open(TESTFN, bad_mode)
         except ValueError as msg:
             if msg.args[0] != 0:
                 s = str(msg)
@@ -170,11 +180,11 @@
         # misbehaviour especially with repeated close() calls
         for s in (-1, 0, 1, 512):
             try:
-                f = open(TESTFN, 'wb', s)
+                f = self.open(TESTFN, 'wb', s)
                 f.write(str(s).encode("ascii"))
                 f.close()
                 f.close()
-                f = open(TESTFN, 'rb', s)
+                f = self.open(TESTFN, 'rb', s)
                 d = int(f.read().decode("ascii"))
                 f.close()
                 f.close()
@@ -187,13 +197,13 @@
         # "file.truncate fault on windows"
 
         os.unlink(TESTFN)
-        f = open(TESTFN, 'wb')
+        f = self.open(TESTFN, 'wb')
 
         try:
             f.write(b'12345678901')   # 11 bytes
             f.close()
 
-            f = open(TESTFN,'rb+')
+            f = self.open(TESTFN,'rb+')
             data = f.read(5)
             if data != b'12345':
                 self.fail("Read on file opened for update failed %r" % data)
@@ -233,13 +243,13 @@
 
         try:
             # Prepare the testfile
-            bag = open(TESTFN, "wb")
+            bag = self.open(TESTFN, "wb")
             bag.write(filler * nchunks)
             bag.writelines(testlines)
             bag.close()
             # Test for appropriate errors mixing read* and iteration
             for methodname, args in methods:
-                f = open(TESTFN, 'rb')
+                f = self.open(TESTFN, 'rb')
                 if next(f) != filler:
                     self.fail, "Broken testfile"
                 meth = getattr(f, methodname)
@@ -253,7 +263,7 @@
             # ("h", "a", "m", "\n"), so 4096 lines of that should get us
             # exactly on the buffer boundary for any power-of-2 buffersize
             # between 4 and 16384 (inclusive).
-            f = open(TESTFN, 'rb')
+            f = self.open(TESTFN, 'rb')
             for i in range(nchunks):
                 next(f)
             testline = testlines.pop(0)
@@ -295,7 +305,7 @@
                 self.fail("readlines() after next() with empty buffer "
                           "failed. Got %r, expected %r" % (line, testline))
             # Reading after iteration hit EOF shouldn't hurt either
-            f = open(TESTFN, 'rb')
+            f = self.open(TESTFN, 'rb')
             try:
                 for line in f:
                     pass
@@ -311,12 +321,19 @@
         finally:
             os.unlink(TESTFN)
 
+class COtherFileTests(OtherFileTests):
+    open = io.open
+
+class PyOtherFileTests(OtherFileTests):
+    open = staticmethod(pyio.open)
+
 
 def test_main():
     # Historically, these tests have been sloppy about removing TESTFN.
     # So get rid of it no matter what.
     try:
-        run_unittest(AutoFileTests, OtherFileTests)
+        run_unittest(CAutoFileTests, PyAutoFileTests,
+                     COtherFileTests, PyOtherFileTests)
     finally:
         if os.path.exists(TESTFN):
             os.unlink(TESTFN)
diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py
index 497914f..615361e 100644
--- a/Lib/test/test_fileio.py
+++ b/Lib/test/test_fileio.py
@@ -10,13 +10,13 @@
                           make_bad_fd)
 from collections import UserList
 
-import _fileio
+from _io import FileIO as _FileIO
 
 class AutoFileTests(unittest.TestCase):
     # file tests for which a test file is automatically set up
 
     def setUp(self):
-        self.f = _fileio._FileIO(TESTFN, 'w')
+        self.f = _FileIO(TESTFN, 'w')
 
     def tearDown(self):
         if self.f:
@@ -63,13 +63,13 @@
         self.f.write(bytes([1, 2]))
         self.f.close()
         a = array('b', b'x'*10)
-        self.f = _fileio._FileIO(TESTFN, 'r')
+        self.f = _FileIO(TESTFN, 'r')
         n = self.f.readinto(a)
         self.assertEquals(array('b', [1, 2]), a[:n])
 
     def testRepr(self):
         self.assertEquals(repr(self.f),
-                          "_fileio._FileIO(%d, %s)" % (self.f.fileno(),
+                          "io.FileIO(%d, %s)" % (self.f.fileno(),
                                                        repr(self.f.mode)))
 
     def testErrors(self):
@@ -80,7 +80,7 @@
         self.assertRaises(ValueError, f.read, 10) # Open for reading
         f.close()
         self.assert_(f.closed)
-        f = _fileio._FileIO(TESTFN, 'r')
+        f = _FileIO(TESTFN, 'r')
         self.assertRaises(TypeError, f.readinto, "")
         self.assert_(not f.closed)
         f.close()
@@ -106,7 +106,7 @@
         # Windows always returns "[Errno 13]: Permission denied
         # Unix calls dircheck() and returns "[Errno 21]: Is a directory"
         try:
-            _fileio._FileIO('.', 'r')
+            _FileIO('.', 'r')
         except IOError as e:
             self.assertNotEqual(e.errno, 0)
             self.assertEqual(e.filename, ".")
@@ -118,19 +118,19 @@
 
     def testAbles(self):
         try:
-            f = _fileio._FileIO(TESTFN, "w")
+            f = _FileIO(TESTFN, "w")
             self.assertEquals(f.readable(), False)
             self.assertEquals(f.writable(), True)
             self.assertEquals(f.seekable(), True)
             f.close()
 
-            f = _fileio._FileIO(TESTFN, "r")
+            f = _FileIO(TESTFN, "r")
             self.assertEquals(f.readable(), True)
             self.assertEquals(f.writable(), False)
             self.assertEquals(f.seekable(), True)
             f.close()
 
-            f = _fileio._FileIO(TESTFN, "a+")
+            f = _FileIO(TESTFN, "a+")
             self.assertEquals(f.readable(), True)
             self.assertEquals(f.writable(), True)
             self.assertEquals(f.seekable(), True)
@@ -139,14 +139,14 @@
 
             if sys.platform != "win32":
                 try:
-                    f = _fileio._FileIO("/dev/tty", "a")
+                    f = _FileIO("/dev/tty", "a")
                 except EnvironmentError:
                     # When run in a cron job there just aren't any
                     # ttys, so skip the test.  This also handles other
                     # OS'es that don't support /dev/tty.
                     pass
                 else:
-                    f = _fileio._FileIO("/dev/tty", "a")
+                    f = _FileIO("/dev/tty", "a")
                     self.assertEquals(f.readable(), False)
                     self.assertEquals(f.writable(), True)
                     if sys.platform != "darwin" and \
@@ -163,7 +163,7 @@
         # check invalid mode strings
         for mode in ("", "aU", "wU+", "rw", "rt"):
             try:
-                f = _fileio._FileIO(TESTFN, mode)
+                f = _FileIO(TESTFN, mode)
             except ValueError:
                 pass
             else:
@@ -172,10 +172,26 @@
 
     def testUnicodeOpen(self):
         # verify repr works for unicode too
-        f = _fileio._FileIO(str(TESTFN), "w")
+        f = _FileIO(str(TESTFN), "w")
         f.close()
         os.unlink(TESTFN)
 
+    def testBytesOpen(self):
+        # Opening a bytes filename
+        try:
+            fn = TESTFN.encode("ascii")
+        except UnicodeEncodeError:
+            # Skip test
+            return
+        f = _FileIO(fn, "w")
+        try:
+            f.write(b"abc")
+            f.close()
+            with open(TESTFN, "rb") as f:
+                self.assertEquals(f.read(), b"abc")
+        finally:
+            os.unlink(TESTFN)
+
     def testInvalidFd(self):
         self.assertRaises(ValueError, _fileio._FileIO, -10)
         self.assertRaises(OSError, _fileio._FileIO, make_bad_fd())
@@ -184,7 +200,7 @@
         # verify that we get a sensible error message for bad mode argument
         bad_mode = "qwerty"
         try:
-            f = _fileio._FileIO(TESTFN, bad_mode)
+            f = _FileIO(TESTFN, bad_mode)
         except ValueError as msg:
             if msg.args[0] != 0:
                 s = str(msg)
@@ -200,11 +216,11 @@
         def bug801631():
             # SF bug <http://www.python.org/sf/801631>
             # "file.truncate fault on windows"
-            f = _fileio._FileIO(TESTFN, 'w')
+            f = _FileIO(TESTFN, 'w')
             f.write(bytes(range(11)))
             f.close()
 
-            f = _fileio._FileIO(TESTFN,'r+')
+            f = _FileIO(TESTFN,'r+')
             data = f.read(5)
             if data != bytes(range(5)):
                 self.fail("Read on file opened for update failed %r" % data)
@@ -244,14 +260,14 @@
                 pass
 
     def testInvalidInit(self):
-        self.assertRaises(TypeError, _fileio._FileIO, "1", 0, 0)
+        self.assertRaises(TypeError, _FileIO, "1", 0, 0)
 
     def testWarnings(self):
         with check_warnings() as w:
             self.assertEqual(w.warnings, [])
-            self.assertRaises(TypeError, _fileio._FileIO, [])
+            self.assertRaises(TypeError, _FileIO, [])
             self.assertEqual(w.warnings, [])
-            self.assertRaises(ValueError, _fileio._FileIO, "/some/invalid/name", "rt")
+            self.assertRaises(ValueError, _FileIO, "/some/invalid/name", "rt")
             self.assertEqual(w.warnings, [])
 
 
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index 30869ac..58f33a2 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -1,4 +1,23 @@
-"""Unit tests for io.py."""
+"""Unit tests for the io module."""
+
+# Tests of io are scattered over the test suite:
+# * test_bufio - tests file buffering
+# * test_memoryio - tests BytesIO and StringIO
+# * test_fileio - tests FileIO
+# * test_file - tests the file interface
+# * test_io - tests everything else in the io module
+# * test_univnewlines - tests universal newline support
+# * test_largefile - tests operations on a file greater than 2**32 bytes
+#     (only enabled with -ulargefile)
+
+################################################################################
+# ATTENTION TEST WRITERS!!!
+################################################################################
+# When writing tests for io, it's important to test both the C and Python
+# implementations. This is usually done by writing a base test that refers to
+# the type it is testing as a attribute. Then it provides custom subclasses to
+# test both implementations. This file has lots of examples.
+################################################################################
 
 import os
 import sys
@@ -7,27 +26,40 @@
 import threading
 import random
 import unittest
-from itertools import chain, cycle
+import weakref
+import gc
+import abc
+from itertools import chain, cycle, count
+from collections import deque
 from test import support
 
 import codecs
-import io  # The module under test
+import io  # C implementation of io
+import _pyio as pyio # Python implementation of io
 
 
-class MockRawIO(io.RawIOBase):
+def _default_chunk_size():
+    """Get the default TextIOWrapper chunk size"""
+    with open(__file__, "r", encoding="latin1") as f:
+        return f._CHUNK_SIZE
+
+
+class MockRawIO:
 
     def __init__(self, read_stack=()):
         self._read_stack = list(read_stack)
         self._write_stack = []
+        self._reads = 0
 
     def read(self, n=None):
+        self._reads += 1
         try:
             return self._read_stack.pop(0)
         except:
             return b""
 
     def write(self, b):
-        self._write_stack.append(b[:])
+        self._write_stack.append(bytes(b))
         return len(b)
 
     def writable(self):
@@ -43,41 +75,148 @@
         return True
 
     def seek(self, pos, whence):
-        pass
+        return 0   # wrong but we gotta return something
 
     def tell(self):
-        return 42
+        return 0   # same comment as above
+
+    def readinto(self, buf):
+        self._reads += 1
+        max_len = len(buf)
+        try:
+            data = self._read_stack[0]
+        except IndexError:
+            return 0
+        if data is None:
+            del self._read_stack[0]
+            return None
+        n = len(data)
+        if len(data) <= max_len:
+            del self._read_stack[0]
+            buf[:n] = data
+            return n
+        else:
+            buf[:] = data[:max_len]
+            self._read_stack[0] = data[max_len:]
+            return max_len
+
+    def truncate(self, pos=None):
+        return pos
+
+class CMockRawIO(MockRawIO, io.RawIOBase):
+    pass
+
+class PyMockRawIO(MockRawIO, pyio.RawIOBase):
+    pass
 
 
-class MockFileIO(io.BytesIO):
+class MisbehavedRawIO(MockRawIO):
+    def write(self, b):
+        return super().write(b) * 2
+
+    def read(self, n=None):
+        return super().read(n) * 2
+
+    def seek(self, pos, whence):
+        return -123
+
+    def tell(self):
+        return -456
+
+    def readinto(self, buf):
+        super().readinto(buf)
+        return len(buf) * 5
+
+class CMisbehavedRawIO(MisbehavedRawIO, io.RawIOBase):
+    pass
+
+class PyMisbehavedRawIO(MisbehavedRawIO, pyio.RawIOBase):
+    pass
+
+
+class CloseFailureIO(MockRawIO):
+    closed = 0
+
+    def close(self):
+        if not self.closed:
+            self.closed = 1
+            raise IOError
+
+class CCloseFailureIO(CloseFailureIO, io.RawIOBase):
+    pass
+
+class PyCloseFailureIO(CloseFailureIO, pyio.RawIOBase):
+    pass
+
+
+class MockFileIO:
 
     def __init__(self, data):
         self.read_history = []
-        io.BytesIO.__init__(self, data)
+        super().__init__(data)
 
     def read(self, n=None):
-        res = io.BytesIO.read(self, n)
+        res = super().read(n)
         self.read_history.append(None if res is None else len(res))
         return res
 
+    def readinto(self, b):
+        res = super().readinto(b)
+        self.read_history.append(res)
+        return res
 
-class MockNonBlockWriterIO(io.RawIOBase):
+class CMockFileIO(MockFileIO, io.BytesIO):
+    pass
 
-    def __init__(self, blocking_script):
-        self._blocking_script = list(blocking_script)
+class PyMockFileIO(MockFileIO, pyio.BytesIO):
+    pass
+
+
+class MockNonBlockWriterIO:
+
+    def __init__(self):
         self._write_stack = []
+        self._blocker_char = None
 
-    def write(self, b):
-        self._write_stack.append(b[:])
-        n = self._blocking_script.pop(0)
-        if (n < 0):
-            raise io.BlockingIOError(0, "test blocking", -n)
-        else:
-            return n
+    def pop_written(self):
+        s = b"".join(self._write_stack)
+        self._write_stack[:] = []
+        return s
+
+    def block_on(self, char):
+        """Block when a given char is encountered."""
+        self._blocker_char = char
+
+    def readable(self):
+        return True
+
+    def seekable(self):
+        return True
 
     def writable(self):
         return True
 
+    def write(self, b):
+        b = bytes(b)
+        n = -1
+        if self._blocker_char:
+            try:
+                n = b.index(self._blocker_char)
+            except ValueError:
+                pass
+            else:
+                self._blocker_char = None
+                self._write_stack.append(b[:n])
+                raise self.BlockingIOError(0, "test blocking", n)
+        self._write_stack.append(b)
+        return len(b)
+
+class CMockNonBlockWriterIO(MockNonBlockWriterIO, io.RawIOBase):
+    BlockingIOError = io.BlockingIOError
+
+class PyMockNonBlockWriterIO(MockNonBlockWriterIO, pyio.RawIOBase):
+    BlockingIOError = pyio.BlockingIOError
+
 
 class IOTest(unittest.TestCase):
 
@@ -151,13 +290,13 @@
         self.assertEqual(f.read(2), b"x")
 
     def test_raw_file_io(self):
-        f = io.open(support.TESTFN, "wb", buffering=0)
+        f = self.open(support.TESTFN, "wb", buffering=0)
         self.assertEqual(f.readable(), False)
         self.assertEqual(f.writable(), True)
         self.assertEqual(f.seekable(), True)
         self.write_ops(f)
         f.close()
-        f = io.open(support.TESTFN, "rb", buffering=0)
+        f = self.open(support.TESTFN, "rb", buffering=0)
         self.assertEqual(f.readable(), True)
         self.assertEqual(f.writable(), False)
         self.assertEqual(f.seekable(), True)
@@ -165,13 +304,13 @@
         f.close()
 
     def test_buffered_file_io(self):
-        f = io.open(support.TESTFN, "wb")
+        f = self.open(support.TESTFN, "wb")
         self.assertEqual(f.readable(), False)
         self.assertEqual(f.writable(), True)
         self.assertEqual(f.seekable(), True)
         self.write_ops(f)
         f.close()
-        f = io.open(support.TESTFN, "rb")
+        f = self.open(support.TESTFN, "rb")
         self.assertEqual(f.readable(), True)
         self.assertEqual(f.writable(), False)
         self.assertEqual(f.seekable(), True)
@@ -180,22 +319,23 @@
 
     def test_readline(self):
         f = io.open(support.TESTFN, "wb")
-        f.write(b"abc\ndef\nxyzzy\nfoo")
+        f.write(b"abc\ndef\nxyzzy\nfoo\x00bar\nanother line")
         f.close()
-        f = io.open(support.TESTFN, "rb")
+        f = self.open(support.TESTFN, "rb")
         self.assertEqual(f.readline(), b"abc\n")
         self.assertEqual(f.readline(10), b"def\n")
         self.assertEqual(f.readline(2), b"xy")
         self.assertEqual(f.readline(4), b"zzy\n")
-        self.assertEqual(f.readline(), b"foo")
+        self.assertEqual(f.readline(), b"foo\x00bar\n")
+        self.assertEqual(f.readline(), b"another line")
         f.close()
 
     def test_raw_bytes_io(self):
-        f = io.BytesIO()
+        f = self.BytesIO()
         self.write_ops(f)
         data = f.getvalue()
         self.assertEqual(data, b"hello world\n")
-        f = io.BytesIO(data)
+        f = self.BytesIO(data)
         self.read_ops(f, True)
 
     def test_large_file_ops(self):
@@ -211,12 +351,10 @@
                 print("Use 'regrtest.py -u largefile test_io' to run it.",
                       file=sys.stderr)
                 return
-        f = io.open(support.TESTFN, "w+b", 0)
-        self.large_file_ops(f)
-        f.close()
-        f = io.open(support.TESTFN, "w+b")
-        self.large_file_ops(f)
-        f.close()
+        with self.open(support.TESTFN, "w+b", 0) as f:
+            self.large_file_ops(f)
+        with self.open(support.TESTFN, "w+b") as f:
+            self.large_file_ops(f)
 
     def test_with_open(self):
         for bufsize in (0, 1, 100):
@@ -235,59 +373,107 @@
 
     # issue 5008
     def test_append_mode_tell(self):
-        with io.open(support.TESTFN, "wb") as f:
+        with self.open(support.TESTFN, "wb") as f:
             f.write(b"xxx")
-        with io.open(support.TESTFN, "ab", buffering=0) as f:
+        with self.open(support.TESTFN, "ab", buffering=0) as f:
             self.assertEqual(f.tell(), 3)
-        with io.open(support.TESTFN, "ab") as f:
+        with self.open(support.TESTFN, "ab") as f:
             self.assertEqual(f.tell(), 3)
-        with io.open(support.TESTFN, "a") as f:
+        with self.open(support.TESTFN, "a") as f:
             self.assert_(f.tell() > 0)
 
     def test_destructor(self):
         record = []
-        class MyFileIO(io.FileIO):
+        class MyFileIO(self.FileIO):
             def __del__(self):
                 record.append(1)
-                io.FileIO.__del__(self)
+                try:
+                    f = super().__del__
+                except AttributeError:
+                    pass
+                else:
+                    f()
             def close(self):
                 record.append(2)
-                io.FileIO.close(self)
+                super().close()
             def flush(self):
                 record.append(3)
-                io.FileIO.flush(self)
-        f = MyFileIO(support.TESTFN, "w")
-        f.write("xxx")
+                super().flush()
+        f = MyFileIO(support.TESTFN, "wb")
+        f.write(b"xxx")
+        del f
+        self.assertEqual(record, [1, 2, 3])
+        f = open(support.TESTFN, "rb")
+        self.assertEqual(f.read(), b"xxx")
+
+    def _check_base_destructor(self, base):
+        record = []
+        class MyIO(base):
+            def __init__(self):
+                # This exercises the availability of attributes on object
+                # destruction.
+                # (in the C version, close() is called by the tp_dealloc
+                # function, not by __del__)
+                self.on_del = 1
+                self.on_close = 2
+                self.on_flush = 3
+            def __del__(self):
+                record.append(self.on_del)
+                try:
+                    f = super().__del__
+                except AttributeError:
+                    pass
+                else:
+                    f()
+            def close(self):
+                record.append(self.on_close)
+                super().close()
+            def flush(self):
+                record.append(self.on_flush)
+                super().flush()
+        f = MyIO()
         del f
         self.assertEqual(record, [1, 2, 3])
 
+    def test_IOBase_destructor(self):
+        self._check_base_destructor(self.IOBase)
+
+    def test_RawIOBase_destructor(self):
+        self._check_base_destructor(self.RawIOBase)
+
+    def test_BufferedIOBase_destructor(self):
+        self._check_base_destructor(self.BufferedIOBase)
+
+    def test_TextIOBase_destructor(self):
+        self._check_base_destructor(self.TextIOBase)
+
     def test_close_flushes(self):
-        f = io.open(support.TESTFN, "wb")
+        f = self.open(support.TESTFN, "wb")
         f.write(b"xxx")
         f.close()
-        f = io.open(support.TESTFN, "rb")
+        f = self.open(support.TESTFN, "rb")
         self.assertEqual(f.read(), b"xxx")
         f.close()
 
     def test_array_writes(self):
         a = array.array('i', range(10))
         n = len(a.tostring())
-        f = io.open(support.TESTFN, "wb", 0)
+        f = self.open(support.TESTFN, "wb", 0)
         self.assertEqual(f.write(a), n)
         f.close()
-        f = io.open(support.TESTFN, "wb")
+        f = self.open(support.TESTFN, "wb")
         self.assertEqual(f.write(a), n)
         f.close()
 
     def test_closefd(self):
-        self.assertRaises(ValueError, io.open, support.TESTFN, 'w',
+        self.assertRaises(ValueError, self.open, support.TESTFN, 'w',
                           closefd=False)
 
-    def testReadClosed(self):
-        with io.open(support.TESTFN, "w") as f:
+    def test_read_closed(self):
+        with self.open(support.TESTFN, "w") as f:
             f.write("egg\n")
-        with io.open(support.TESTFN, "r") as f:
-            file = io.open(f.fileno(), "r", closefd=False)
+        with self.open(support.TESTFN, "r") as f:
+            file = self.open(f.fileno(), "r", closefd=False)
             self.assertEqual(file.read(), "egg\n")
             file.seek(0)
             file.close()
@@ -295,85 +481,168 @@
 
     def test_no_closefd_with_filename(self):
         # can't use closefd in combination with a file name
-        self.assertRaises(ValueError, io.open, support.TESTFN, "r", closefd=False)
+        self.assertRaises(ValueError, self.open, support.TESTFN, "r", closefd=False)
 
     def test_closefd_attr(self):
-        with io.open(support.TESTFN, "wb") as f:
+        with self.open(support.TESTFN, "wb") as f:
             f.write(b"egg\n")
-        with io.open(support.TESTFN, "r") as f:
+        with self.open(support.TESTFN, "r") as f:
             self.assertEqual(f.buffer.raw.closefd, True)
-            file = io.open(f.fileno(), "r", closefd=False)
+            file = self.open(f.fileno(), "r", closefd=False)
             self.assertEqual(file.buffer.raw.closefd, False)
 
+    def test_garbage_collection(self):
+        # FileIO objects are collected, and collecting them flushes
+        # all data to disk.
+        f = self.FileIO(support.TESTFN, "wb")
+        f.write(b"abcxxx")
+        f.f = f
+        wr = weakref.ref(f)
+        del f
+        gc.collect()
+        self.assert_(wr() is None, wr)
+        with open(support.TESTFN, "rb") as f:
+            self.assertEqual(f.read(), b"abcxxx")
 
-class MemorySeekTestMixin:
+class CIOTest(IOTest):
+    pass
 
-    def testInit(self):
-        buf = self.buftype("1234567890")
-        bytesIo = self.ioclass(buf)
-
-    def testRead(self):
-        buf = self.buftype("1234567890")
-        bytesIo = self.ioclass(buf)
-
-        self.assertEquals(buf[:1], bytesIo.read(1))
-        self.assertEquals(buf[1:5], bytesIo.read(4))
-        self.assertEquals(buf[5:], bytesIo.read(900))
-        self.assertEquals(self.EOF, bytesIo.read())
-
-    def testReadNoArgs(self):
-        buf = self.buftype("1234567890")
-        bytesIo = self.ioclass(buf)
-
-        self.assertEquals(buf, bytesIo.read())
-        self.assertEquals(self.EOF, bytesIo.read())
-
-    def testSeek(self):
-        buf = self.buftype("1234567890")
-        bytesIo = self.ioclass(buf)
-
-        bytesIo.read(5)
-        bytesIo.seek(0)
-        self.assertEquals(buf, bytesIo.read())
-
-        bytesIo.seek(3)
-        self.assertEquals(buf[3:], bytesIo.read())
-        self.assertRaises(TypeError, bytesIo.seek, 0.0)
-
-    def testTell(self):
-        buf = self.buftype("1234567890")
-        bytesIo = self.ioclass(buf)
-
-        self.assertEquals(0, bytesIo.tell())
-        bytesIo.seek(5)
-        self.assertEquals(5, bytesIo.tell())
-        bytesIo.seek(10000)
-        self.assertEquals(10000, bytesIo.tell())
+class PyIOTest(IOTest):
+    pass
 
 
-class BytesIOTest(MemorySeekTestMixin, unittest.TestCase):
-    @staticmethod
-    def buftype(s):
-        return s.encode("utf-8")
-    ioclass = io.BytesIO
-    EOF = b""
+class CommonBufferedTests:
+    # Tests common to BufferedReader, BufferedWriter and BufferedRandom
+
+    def test_fileno(self):
+        rawio = self.MockRawIO()
+        bufio = self.tp(rawio)
+
+        self.assertEquals(42, bufio.fileno())
+
+    def test_no_fileno(self):
+        # XXX will we always have fileno() function? If so, kill
+        # this test. Else, write it.
+        pass
+
+    def test_invalid_args(self):
+        rawio = self.MockRawIO()
+        bufio = self.tp(rawio)
+        # Invalid whence
+        self.assertRaises(ValueError, bufio.seek, 0, -1)
+        self.assertRaises(ValueError, bufio.seek, 0, 3)
+
+    def test_override_destructor(self):
+        tp = self.tp
+        record = []
+        class MyBufferedIO(tp):
+            def __del__(self):
+                record.append(1)
+                try:
+                    f = super().__del__
+                except AttributeError:
+                    pass
+                else:
+                    f()
+            def close(self):
+                record.append(2)
+                super().close()
+            def flush(self):
+                record.append(3)
+                super().flush()
+        rawio = self.MockRawIO()
+        bufio = MyBufferedIO(rawio)
+        writable = bufio.writable()
+        del bufio
+        if writable:
+            self.assertEqual(record, [1, 2, 3])
+        else:
+            self.assertEqual(record, [1, 2])
+
+    def test_context_manager(self):
+        # Test usability as a context manager
+        rawio = self.MockRawIO()
+        bufio = self.tp(rawio)
+        def _with():
+            with bufio:
+                pass
+        _with()
+        # bufio should now be closed, and using it a second time should raise
+        # a ValueError.
+        self.assertRaises(ValueError, _with)
+
+    def test_error_through_destructor(self):
+        # Test that the exception state is not modified by a destructor,
+        # even if close() fails.
+        rawio = self.CloseFailureIO()
+        def f():
+            self.tp(rawio).xyzzy
+        with support.captured_output("stderr") as s:
+            self.assertRaises(AttributeError, f)
+        s = s.getvalue().strip()
+        if s:
+            # The destructor *may* have printed an unraisable error, check it
+            self.assertEqual(len(s.splitlines()), 1)
+            self.assert_(s.startswith("Exception IOError: "), s)
+            self.assert_(s.endswith(" ignored"), s)
 
 
-class StringIOTest(MemorySeekTestMixin, unittest.TestCase):
-    buftype = str
-    ioclass = io.StringIO
-    EOF = ""
+class BufferedReaderTest(unittest.TestCase, CommonBufferedTests):
+    read_mode = "rb"
 
+    def test_constructor(self):
+        rawio = self.MockRawIO([b"abc"])
+        bufio = self.tp(rawio)
+        bufio.__init__(rawio)
+        bufio.__init__(rawio, buffer_size=1024)
+        bufio.__init__(rawio, buffer_size=16)
+        self.assertEquals(b"abc", bufio.read())
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
+        rawio = self.MockRawIO([b"abc"])
+        bufio.__init__(rawio)
+        self.assertEquals(b"abc", bufio.read())
 
-class BufferedReaderTest(unittest.TestCase):
-
-    def testRead(self):
-        rawio = MockRawIO((b"abc", b"d", b"efg"))
-        bufio = io.BufferedReader(rawio)
-
+    def test_read(self):
+        rawio = self.MockRawIO((b"abc", b"d", b"efg"))
+        bufio = self.tp(rawio)
         self.assertEquals(b"abcdef", bufio.read(6))
+        # Invalid args
+        self.assertRaises(ValueError, bufio.read, -2)
 
-    def testBuffering(self):
+    def test_read1(self):
+        rawio = self.MockRawIO((b"abc", b"d", b"efg"))
+        bufio = self.tp(rawio)
+        self.assertEquals(b"a", bufio.read(1))
+        self.assertEquals(b"b", bufio.read1(1))
+        self.assertEquals(rawio._reads, 1)
+        self.assertEquals(b"c", bufio.read1(100))
+        self.assertEquals(rawio._reads, 1)
+        self.assertEquals(b"d", bufio.read1(100))
+        self.assertEquals(rawio._reads, 2)
+        self.assertEquals(b"efg", bufio.read1(100))
+        self.assertEquals(rawio._reads, 3)
+        self.assertEquals(b"", bufio.read1(100))
+        # Invalid args
+        self.assertRaises(ValueError, bufio.read1, -1)
+
+    def test_readinto(self):
+        rawio = self.MockRawIO((b"abc", b"d", b"efg"))
+        bufio = self.tp(rawio)
+        b = bytearray(2)
+        self.assertEquals(bufio.readinto(b), 2)
+        self.assertEquals(b, b"ab")
+        self.assertEquals(bufio.readinto(b), 2)
+        self.assertEquals(b, b"cd")
+        self.assertEquals(bufio.readinto(b), 2)
+        self.assertEquals(b, b"ef")
+        self.assertEquals(bufio.readinto(b), 1)
+        self.assertEquals(b, b"gf")
+        self.assertEquals(bufio.readinto(b), 0)
+        self.assertEquals(b, b"gf")
+
+    def test_buffering(self):
         data = b"abcdefghi"
         dlen = len(data)
 
@@ -384,49 +653,40 @@
         ]
 
         for bufsize, buf_read_sizes, raw_read_sizes in tests:
-            rawio = MockFileIO(data)
-            bufio = io.BufferedReader(rawio, buffer_size=bufsize)
+            rawio = self.MockFileIO(data)
+            bufio = self.tp(rawio, buffer_size=bufsize)
             pos = 0
             for nbytes in buf_read_sizes:
                 self.assertEquals(bufio.read(nbytes), data[pos:pos+nbytes])
                 pos += nbytes
+            # this is mildly implementation-dependent
             self.assertEquals(rawio.read_history, raw_read_sizes)
 
-    def testReadNonBlocking(self):
+    def test_read_non_blocking(self):
         # Inject some None's in there to simulate EWOULDBLOCK
-        rawio = MockRawIO((b"abc", b"d", None, b"efg", None, None))
-        bufio = io.BufferedReader(rawio)
+        rawio = self.MockRawIO((b"abc", b"d", None, b"efg", None, None, None))
+        bufio = self.tp(rawio)
 
         self.assertEquals(b"abcd", bufio.read(6))
         self.assertEquals(b"e", bufio.read(1))
         self.assertEquals(b"fg", bufio.read())
+        self.assertEquals(b"", bufio.peek(1))
         self.assert_(None is bufio.read())
         self.assertEquals(b"", bufio.read())
 
-    def testReadToEof(self):
-        rawio = MockRawIO((b"abc", b"d", b"efg"))
-        bufio = io.BufferedReader(rawio)
+    def test_read_past_eof(self):
+        rawio = self.MockRawIO((b"abc", b"d", b"efg"))
+        bufio = self.tp(rawio)
 
         self.assertEquals(b"abcdefg", bufio.read(9000))
 
-    def testReadNoArgs(self):
-        rawio = MockRawIO((b"abc", b"d", b"efg"))
-        bufio = io.BufferedReader(rawio)
+    def test_read_all(self):
+        rawio = self.MockRawIO((b"abc", b"d", b"efg"))
+        bufio = self.tp(rawio)
 
         self.assertEquals(b"abcdefg", bufio.read())
 
-    def testFileno(self):
-        rawio = MockRawIO((b"abc", b"d", b"efg"))
-        bufio = io.BufferedReader(rawio)
-
-        self.assertEquals(42, bufio.fileno())
-
-    def testFilenoNoFileno(self):
-        # XXX will we always have fileno() function? If so, kill
-        # this test. Else, write it.
-        pass
-
-    def testThreads(self):
+    def test_threads(self):
         try:
             # Write out many bytes with exactly the same number of 0's,
             # 1's... 255's. This will help us check that concurrent reading
@@ -437,8 +697,8 @@
             s = bytes(bytearray(l))
             with io.open(support.TESTFN, "wb") as f:
                 f.write(s)
-            with io.open(support.TESTFN, "rb", buffering=0) as raw:
-                bufio = io.BufferedReader(raw, 8)
+            with io.open(support.TESTFN, self.read_mode, buffering=0) as raw:
+                bufio = self.tp(raw, 8)
                 errors = []
                 results = []
                 def f():
@@ -468,80 +728,230 @@
         finally:
             support.unlink(support.TESTFN)
 
+    def test_misbehaved_io(self):
+        rawio = self.MisbehavedRawIO((b"abc", b"d", b"efg"))
+        bufio = self.tp(rawio)
+        self.assertRaises(IOError, bufio.seek, 0)
+        self.assertRaises(IOError, bufio.tell)
+
+class CBufferedReaderTest(BufferedReaderTest):
+    tp = io.BufferedReader
+
+    def test_constructor(self):
+        BufferedReaderTest.test_constructor(self)
+        # The allocation can succeed on 32-bit builds, e.g. with more
+        # than 2GB RAM and a 64-bit kernel.
+        if sys.maxsize > 0x7FFFFFFF:
+            rawio = self.MockRawIO()
+            bufio = self.tp(rawio)
+            self.assertRaises((OverflowError, MemoryError, ValueError),
+                bufio.__init__, rawio, sys.maxsize)
+
+    def test_initialization(self):
+        rawio = self.MockRawIO([b"abc"])
+        bufio = self.tp(rawio)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
+        self.assertRaises(ValueError, bufio.read)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
+        self.assertRaises(ValueError, bufio.read)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
+        self.assertRaises(ValueError, bufio.read)
+
+    def test_misbehaved_io_read(self):
+        rawio = self.MisbehavedRawIO((b"abc", b"d", b"efg"))
+        bufio = self.tp(rawio)
+        # _pyio.BufferedReader seems to implement reading different, so that
+        # checking this is not so easy.
+        self.assertRaises(IOError, bufio.read, 10)
+
+    def test_garbage_collection(self):
+        # C BufferedReader objects are collected.
+        # The Python version has __del__, so it ends into gc.garbage instead
+        rawio = self.FileIO(support.TESTFN, "w+b")
+        f = self.tp(rawio)
+        f.f = f
+        wr = weakref.ref(f)
+        del f
+        gc.collect()
+        self.assert_(wr() is None, wr)
+
+class PyBufferedReaderTest(BufferedReaderTest):
+    tp = pyio.BufferedReader
 
 
-class BufferedWriterTest(unittest.TestCase):
+class BufferedWriterTest(unittest.TestCase, CommonBufferedTests):
+    write_mode = "wb"
 
-    def testWrite(self):
+    def test_constructor(self):
+        rawio = self.MockRawIO()
+        bufio = self.tp(rawio)
+        bufio.__init__(rawio)
+        bufio.__init__(rawio, buffer_size=1024)
+        bufio.__init__(rawio, buffer_size=16)
+        self.assertEquals(3, bufio.write(b"abc"))
+        bufio.flush()
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
+        bufio.__init__(rawio)
+        self.assertEquals(3, bufio.write(b"ghi"))
+        bufio.flush()
+        self.assertEquals(b"".join(rawio._write_stack), b"abcghi")
+
+    def test_write(self):
         # Write to the buffered IO but don't overflow the buffer.
-        writer = MockRawIO()
-        bufio = io.BufferedWriter(writer, 8)
-
+        writer = self.MockRawIO()
+        bufio = self.tp(writer, 8)
         bufio.write(b"abc")
-
         self.assertFalse(writer._write_stack)
 
-    def testWriteOverflow(self):
-        writer = MockRawIO()
-        bufio = io.BufferedWriter(writer, 8)
+    def test_write_overflow(self):
+        writer = self.MockRawIO()
+        bufio = self.tp(writer, 8)
+        contents = b"abcdefghijklmnop"
+        for n in range(0, len(contents), 3):
+            bufio.write(contents[n:n+3])
+        flushed = b"".join(writer._write_stack)
+        # At least (total - 8) bytes were implicitly flushed, perhaps more
+        # depending on the implementation.
+        self.assert_(flushed.startswith(contents[:-8]), flushed)
 
-        bufio.write(b"abc")
-        bufio.write(b"defghijkl")
+    def check_writes(self, intermediate_func):
+        # Lots of writes, test the flushed output is as expected.
+        contents = bytes(range(256)) * 1000
+        n = 0
+        writer = self.MockRawIO()
+        bufio = self.tp(writer, 13)
+        # Generator of write sizes: repeat each N 15 times then proceed to N+1
+        def gen_sizes():
+            for size in count(1):
+                for i in range(15):
+                    yield size
+        sizes = gen_sizes()
+        while n < len(contents):
+            size = min(next(sizes), len(contents) - n)
+            self.assertEquals(bufio.write(contents[n:n+size]), size)
+            intermediate_func(bufio)
+            n += size
+        bufio.flush()
+        self.assertEquals(contents, b"".join(writer._write_stack))
 
-        self.assertEquals(b"abcdefghijkl", writer._write_stack[0])
+    def test_writes(self):
+        self.check_writes(lambda bufio: None)
 
-    def testWriteNonBlocking(self):
-        raw = MockNonBlockWriterIO((9, 2, 22, -6, 10, 12, 12))
-        bufio = io.BufferedWriter(raw, 8, 16)
+    def test_writes_and_flushes(self):
+        self.check_writes(lambda bufio: bufio.flush())
 
-        bufio.write(b"asdf")
-        bufio.write(b"asdfa")
-        self.assertEquals(b"asdfasdfa", raw._write_stack[0])
+    def test_writes_and_seeks(self):
+        def _seekabs(bufio):
+            pos = bufio.tell()
+            bufio.seek(pos + 1, 0)
+            bufio.seek(pos - 1, 0)
+            bufio.seek(pos, 0)
+        self.check_writes(_seekabs)
+        def _seekrel(bufio):
+            pos = bufio.seek(0, 1)
+            bufio.seek(+1, 1)
+            bufio.seek(-1, 1)
+            bufio.seek(pos, 0)
+        self.check_writes(_seekrel)
 
-        bufio.write(b"asdfasdfasdf")
-        self.assertEquals(b"asdfasdfasdf", raw._write_stack[1])
-        bufio.write(b"asdfasdfasdf")
-        self.assertEquals(b"dfasdfasdf", raw._write_stack[2])
-        self.assertEquals(b"asdfasdfasdf", raw._write_stack[3])
+    def test_writes_and_truncates(self):
+        self.check_writes(lambda bufio: bufio.truncate(bufio.tell()))
 
-        bufio.write(b"asdfasdfasdf")
+    def test_write_non_blocking(self):
+        raw = self.MockNonBlockWriterIO()
+        bufio = self.tp(raw, 8, 8)
 
-        # XXX I don't like this test. It relies too heavily on how the
-        # algorithm actually works, which we might change. Refactor
-        # later.
+        self.assertEquals(bufio.write(b"abcd"), 4)
+        self.assertEquals(bufio.write(b"efghi"), 5)
+        # 1 byte will be written, the rest will be buffered
+        raw.block_on(b"k")
+        self.assertEquals(bufio.write(b"jklmn"), 5)
 
-    def testFileno(self):
-        rawio = MockRawIO((b"abc", b"d", b"efg"))
-        bufio = io.BufferedWriter(rawio)
+        # 8 bytes will be written, 8 will be buffered and the rest will be lost
+        raw.block_on(b"0")
+        try:
+            bufio.write(b"opqrwxyz0123456789")
+        except self.BlockingIOError as e:
+            written = e.characters_written
+        else:
+            self.fail("BlockingIOError should have been raised")
+        self.assertEquals(written, 16)
+        self.assertEquals(raw.pop_written(),
+            b"abcdefghijklmnopqrwxyz")
 
-        self.assertEquals(42, bufio.fileno())
+        self.assertEquals(bufio.write(b"ABCDEFGHI"), 9)
+        s = raw.pop_written()
+        # Previously buffered bytes were flushed
+        self.assertTrue(s.startswith(b"01234567A"), s)
 
-    def testFlush(self):
-        writer = MockRawIO()
-        bufio = io.BufferedWriter(writer, 8)
+    def test_write_and_rewind(self):
+        raw = io.BytesIO()
+        bufio = self.tp(raw, 4)
+        self.assertEqual(bufio.write(b"abcdef"), 6)
+        self.assertEqual(bufio.tell(), 6)
+        bufio.seek(0, 0)
+        self.assertEqual(bufio.write(b"XY"), 2)
+        bufio.seek(6, 0)
+        self.assertEqual(raw.getvalue(), b"XYcdef")
+        self.assertEqual(bufio.write(b"123456"), 6)
+        bufio.flush()
+        self.assertEqual(raw.getvalue(), b"XYcdef123456")
 
+    def test_flush(self):
+        writer = self.MockRawIO()
+        bufio = self.tp(writer, 8)
         bufio.write(b"abc")
         bufio.flush()
-
         self.assertEquals(b"abc", writer._write_stack[0])
 
-    def testThreads(self):
-        # BufferedWriter should not raise exceptions or crash
-        # when called from multiple threads.
+    def test_destructor(self):
+        writer = self.MockRawIO()
+        bufio = self.tp(writer, 8)
+        bufio.write(b"abc")
+        del bufio
+        self.assertEquals(b"abc", writer._write_stack[0])
+
+    def test_truncate(self):
+        # Truncate implicitly flushes the buffer.
+        with io.open(support.TESTFN, self.write_mode, buffering=0) as raw:
+            bufio = self.tp(raw, 8)
+            bufio.write(b"abcdef")
+            self.assertEqual(bufio.truncate(3), 3)
+            self.assertEqual(bufio.tell(), 3)
+        with io.open(support.TESTFN, "rb", buffering=0) as f:
+            self.assertEqual(f.read(), b"abc")
+
+    def test_threads(self):
         try:
+            # Write out many bytes from many threads and test they were
+            # all flushed.
+            N = 1000
+            contents = bytes(range(256)) * N
+            sizes = cycle([1, 19])
+            n = 0
+            queue = deque()
+            while n < len(contents):
+                size = next(sizes)
+                queue.append(contents[n:n+size])
+                n += size
+            del contents
             # We use a real file object because it allows us to
             # exercise situations where the GIL is released before
             # writing the buffer to the raw streams. This is in addition
             # to concurrency issues due to switching threads in the middle
             # of Python code.
-            with io.open(support.TESTFN, "wb", buffering=0) as raw:
-                bufio = io.BufferedWriter(raw, 8)
+            with io.open(support.TESTFN, self.write_mode, buffering=0) as raw:
+                bufio = self.tp(raw, 8)
                 errors = []
                 def f():
                     try:
-                        # Write enough bytes to flush the buffer
-                        s = b"a" * 19
-                        for i in range(50):
+                        while True:
+                            try:
+                                s = queue.popleft()
+                            except IndexError:
+                                return
                             bufio.write(s)
                     except Exception as e:
                         errors.append(e)
@@ -554,37 +964,102 @@
                     t.join()
                 self.assertFalse(errors,
                     "the following exceptions were caught: %r" % errors)
+                bufio.close()
+            with io.open(support.TESTFN, "rb") as f:
+                s = f.read()
+            for i in range(256):
+                self.assertEquals(s.count(bytes([i])), N)
         finally:
             support.unlink(support.TESTFN)
 
+    def test_misbehaved_io(self):
+        rawio = self.MisbehavedRawIO()
+        bufio = self.tp(rawio, 5)
+        self.assertRaises(IOError, bufio.seek, 0)
+        self.assertRaises(IOError, bufio.tell)
+        self.assertRaises(IOError, bufio.write, b"abcdef")
+
+class CBufferedWriterTest(BufferedWriterTest):
+    tp = io.BufferedWriter
+
+    def test_constructor(self):
+        BufferedWriterTest.test_constructor(self)
+        # The allocation can succeed on 32-bit builds, e.g. with more
+        # than 2GB RAM and a 64-bit kernel.
+        if sys.maxsize > 0x7FFFFFFF:
+            rawio = self.MockRawIO()
+            bufio = self.tp(rawio)
+            self.assertRaises((OverflowError, MemoryError, ValueError),
+                bufio.__init__, rawio, sys.maxsize)
+
+    def test_initialization(self):
+        rawio = self.MockRawIO()
+        bufio = self.tp(rawio)
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0)
+        self.assertRaises(ValueError, bufio.write, b"def")
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16)
+        self.assertRaises(ValueError, bufio.write, b"def")
+        self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1)
+        self.assertRaises(ValueError, bufio.write, b"def")
+
+    def test_garbage_collection(self):
+        # C BufferedWriter objects are collected, and collecting them flushes
+        # all data to disk.
+        # The Python version has __del__, so it ends into gc.garbage instead
+        rawio = self.FileIO(support.TESTFN, "w+b")
+        f = self.tp(rawio)
+        f.write(b"123xxx")
+        f.x = f
+        wr = weakref.ref(f)
+        del f
+        gc.collect()
+        self.assert_(wr() is None, wr)
+        with open(support.TESTFN, "rb") as f:
+            self.assertEqual(f.read(), b"123xxx")
+
+
+class PyBufferedWriterTest(BufferedWriterTest):
+    tp = pyio.BufferedWriter
 
 class BufferedRWPairTest(unittest.TestCase):
 
-    def testRWPair(self):
-        r = MockRawIO(())
-        w = MockRawIO()
-        pair = io.BufferedRWPair(r, w)
+    def test_basic(self):
+        r = self.MockRawIO(())
+        w = self.MockRawIO()
+        pair = self.tp(r, w)
         self.assertFalse(pair.closed)
 
         # XXX More Tests
 
+class CBufferedRWPairTest(BufferedRWPairTest):
+    tp = io.BufferedRWPair
 
-class BufferedRandomTest(unittest.TestCase):
+class PyBufferedRWPairTest(BufferedRWPairTest):
+    tp = pyio.BufferedRWPair
 
-    def testReadAndWrite(self):
-        raw = MockRawIO((b"asdf", b"ghjk"))
-        rw = io.BufferedRandom(raw, 8, 12)
+
+class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest):
+    read_mode = "rb+"
+    write_mode = "wb+"
+
+    def test_constructor(self):
+        BufferedReaderTest.test_constructor(self)
+        BufferedWriterTest.test_constructor(self)
+
+    def test_read_and_write(self):
+        raw = self.MockRawIO((b"asdf", b"ghjk"))
+        rw = self.tp(raw, 8, 12)
 
         self.assertEqual(b"as", rw.read(2))
         rw.write(b"ddd")
         rw.write(b"eee")
         self.assertFalse(raw._write_stack) # Buffer writes
-        self.assertEqual(b"ghjk", rw.read()) # This read forces write flush
+        self.assertEqual(b"ghjk", rw.read())
         self.assertEquals(b"dddeee", raw._write_stack[0])
 
-    def testSeekAndTell(self):
-        raw = io.BytesIO(b"asdfghjkl")
-        rw = io.BufferedRandom(raw)
+    def test_seek_and_tell(self):
+        raw = self.BytesIO(b"asdfghjkl")
+        rw = self.tp(raw)
 
         self.assertEquals(b"as", rw.read(2))
         self.assertEquals(2, rw.tell())
@@ -602,6 +1077,115 @@
         self.assertEquals(b"fl", rw.read(11))
         self.assertRaises(TypeError, rw.seek, 0.0)
 
+    def check_flush_and_read(self, read_func):
+        raw = self.BytesIO(b"abcdefghi")
+        bufio = self.tp(raw)
+
+        self.assertEquals(b"ab", read_func(bufio, 2))
+        bufio.write(b"12")
+        self.assertEquals(b"ef", read_func(bufio, 2))
+        self.assertEquals(6, bufio.tell())
+        bufio.flush()
+        self.assertEquals(6, bufio.tell())
+        self.assertEquals(b"ghi", read_func(bufio))
+        raw.seek(0, 0)
+        raw.write(b"XYZ")
+        # flush() resets the read buffer
+        bufio.flush()
+        bufio.seek(0, 0)
+        self.assertEquals(b"XYZ", read_func(bufio, 3))
+
+    def test_flush_and_read(self):
+        self.check_flush_and_read(lambda bufio, *args: bufio.read(*args))
+
+    def test_flush_and_readinto(self):
+        def _readinto(bufio, n=-1):
+            b = bytearray(n if n >= 0 else 9999)
+            n = bufio.readinto(b)
+            return bytes(b[:n])
+        self.check_flush_and_read(_readinto)
+
+    def test_flush_and_peek(self):
+        def _peek(bufio, n=-1):
+            # This relies on the fact that the buffer can contain the whole
+            # raw stream, otherwise peek() can return less.
+            b = bufio.peek(n)
+            if n != -1:
+                b = b[:n]
+            bufio.seek(len(b), 1)
+            return b
+        self.check_flush_and_read(_peek)
+
+    def test_flush_and_write(self):
+        raw = self.BytesIO(b"abcdefghi")
+        bufio = self.tp(raw)
+
+        bufio.write(b"123")
+        bufio.flush()
+        bufio.write(b"45")
+        bufio.flush()
+        bufio.seek(0, 0)
+        self.assertEquals(b"12345fghi", raw.getvalue())
+        self.assertEquals(b"12345fghi", bufio.read())
+
+    def test_threads(self):
+        BufferedReaderTest.test_threads(self)
+        BufferedWriterTest.test_threads(self)
+
+    def test_writes_and_peek(self):
+        def _peek(bufio):
+            bufio.peek(1)
+        self.check_writes(_peek)
+        def _peek(bufio):
+            pos = bufio.tell()
+            bufio.seek(-1, 1)
+            bufio.peek(1)
+            bufio.seek(pos, 0)
+        self.check_writes(_peek)
+
+    def test_writes_and_reads(self):
+        def _read(bufio):
+            bufio.seek(-1, 1)
+            bufio.read(1)
+        self.check_writes(_read)
+
+    def test_writes_and_read1s(self):
+        def _read1(bufio):
+            bufio.seek(-1, 1)
+            bufio.read1(1)
+        self.check_writes(_read1)
+
+    def test_writes_and_readintos(self):
+        def _read(bufio):
+            bufio.seek(-1, 1)
+            bufio.readinto(bytearray(1))
+        self.check_writes(_read)
+
+    def test_misbehaved_io(self):
+        BufferedReaderTest.test_misbehaved_io(self)
+        BufferedWriterTest.test_misbehaved_io(self)
+
+class CBufferedRandomTest(BufferedRandomTest):
+    tp = io.BufferedRandom
+
+    def test_constructor(self):
+        BufferedRandomTest.test_constructor(self)
+        # The allocation can succeed on 32-bit builds, e.g. with more
+        # than 2GB RAM and a 64-bit kernel.
+        if sys.maxsize > 0x7FFFFFFF:
+            rawio = self.MockRawIO()
+            bufio = self.tp(rawio)
+            self.assertRaises((OverflowError, MemoryError, ValueError),
+                bufio.__init__, rawio, sys.maxsize)
+
+    def test_garbage_collection(self):
+        CBufferedReaderTest.test_garbage_collection(self)
+        CBufferedWriterTest.test_garbage_collection(self)
+
+class PyBufferedRandomTest(BufferedRandomTest):
+    tp = pyio.BufferedRandom
+
+
 # To fully exercise seek/tell, the StatefulIncrementalDecoder has these
 # properties:
 #   - A single output character can correspond to many bytes of input.
@@ -735,7 +1319,7 @@
          'm--------------.')
     ]
 
-    def testDecoder(self):
+    def test_decoder(self):
         # Try a few one-shot test cases.
         for input, eof, output in self.test_cases:
             d = StatefulIncrementalDecoder()
@@ -756,10 +1340,24 @@
     def tearDown(self):
         support.unlink(support.TESTFN)
 
-    def testLineBuffering(self):
-        r = io.BytesIO()
-        b = io.BufferedWriter(r, 1000)
-        t = io.TextIOWrapper(b, newline="\n", line_buffering=True)
+    def test_constructor(self):
+        r = self.BytesIO(b"\xc3\xa9\n\n")
+        b = self.BufferedReader(r, 1000)
+        t = self.TextIOWrapper(b)
+        t.__init__(b, encoding="latin1", newline="\r\n")
+        self.assertEquals(t.encoding, "latin1")
+        self.assertEquals(t.line_buffering, False)
+        t.__init__(b, encoding="utf8", line_buffering=True)
+        self.assertEquals(t.encoding, "utf8")
+        self.assertEquals(t.line_buffering, True)
+        self.assertEquals("\xe9\n", t.readline())
+        self.assertRaises(TypeError, t.__init__, b, newline=42)
+        self.assertRaises(ValueError, t.__init__, b, newline='xyzzy')
+
+    def test_line_buffering(self):
+        r = self.BytesIO()
+        b = self.BufferedWriter(r, 1000)
+        t = self.TextIOWrapper(b, newline="\n", line_buffering=True)
         t.write("X")
         self.assertEquals(r.getvalue(), b"")  # No flush happened
         t.write("Y\nZ")
@@ -767,83 +1365,58 @@
         t.write("A\rB")
         self.assertEquals(r.getvalue(), b"XY\nZA\rB")
 
-    def testEncodingErrorsReading(self):
+    def test_encoding(self):
+        # Check the encoding attribute is always set, and valid
+        b = self.BytesIO()
+        t = self.TextIOWrapper(b, encoding="utf8")
+        self.assertEqual(t.encoding, "utf8")
+        t = self.TextIOWrapper(b)
+        self.assert_(t.encoding is not None)
+        codecs.lookup(t.encoding)
+
+    def test_encoding_errors_reading(self):
         # (1) default
-        b = io.BytesIO(b"abc\n\xff\n")
-        t = io.TextIOWrapper(b, encoding="ascii")
+        b = self.BytesIO(b"abc\n\xff\n")
+        t = self.TextIOWrapper(b, encoding="ascii")
         self.assertRaises(UnicodeError, t.read)
         # (2) explicit strict
-        b = io.BytesIO(b"abc\n\xff\n")
-        t = io.TextIOWrapper(b, encoding="ascii", errors="strict")
+        b = self.BytesIO(b"abc\n\xff\n")
+        t = self.TextIOWrapper(b, encoding="ascii", errors="strict")
         self.assertRaises(UnicodeError, t.read)
         # (3) ignore
-        b = io.BytesIO(b"abc\n\xff\n")
-        t = io.TextIOWrapper(b, encoding="ascii", errors="ignore")
+        b = self.BytesIO(b"abc\n\xff\n")
+        t = self.TextIOWrapper(b, encoding="ascii", errors="ignore")
         self.assertEquals(t.read(), "abc\n\n")
         # (4) replace
-        b = io.BytesIO(b"abc\n\xff\n")
-        t = io.TextIOWrapper(b, encoding="ascii", errors="replace")
+        b = self.BytesIO(b"abc\n\xff\n")
+        t = self.TextIOWrapper(b, encoding="ascii", errors="replace")
         self.assertEquals(t.read(), "abc\n\ufffd\n")
 
-    def testEncodingErrorsWriting(self):
+    def test_encoding_errors_writing(self):
         # (1) default
-        b = io.BytesIO()
-        t = io.TextIOWrapper(b, encoding="ascii")
+        b = self.BytesIO()
+        t = self.TextIOWrapper(b, encoding="ascii")
         self.assertRaises(UnicodeError, t.write, "\xff")
         # (2) explicit strict
-        b = io.BytesIO()
-        t = io.TextIOWrapper(b, encoding="ascii", errors="strict")
+        b = self.BytesIO()
+        t = self.TextIOWrapper(b, encoding="ascii", errors="strict")
         self.assertRaises(UnicodeError, t.write, "\xff")
         # (3) ignore
-        b = io.BytesIO()
-        t = io.TextIOWrapper(b, encoding="ascii", errors="ignore",
+        b = self.BytesIO()
+        t = self.TextIOWrapper(b, encoding="ascii", errors="ignore",
                              newline="\n")
         t.write("abc\xffdef\n")
         t.flush()
         self.assertEquals(b.getvalue(), b"abcdef\n")
         # (4) replace
-        b = io.BytesIO()
-        t = io.TextIOWrapper(b, encoding="ascii", errors="replace",
+        b = self.BytesIO()
+        t = self.TextIOWrapper(b, encoding="ascii", errors="replace",
                              newline="\n")
         t.write("abc\xffdef\n")
         t.flush()
         self.assertEquals(b.getvalue(), b"abc?def\n")
 
-    def testNewlinesInput(self):
-        testdata = b"AAA\nBBB\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
-        normalized = testdata.replace(b"\r\n", b"\n").replace(b"\r", b"\n")
-        for newline, expected in [
-            (None, normalized.decode("ascii").splitlines(True)),
-            ("", testdata.decode("ascii").splitlines(True)),
-            ("\n", ["AAA\n", "BBB\n", "CCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]),
-            ("\r\n", ["AAA\nBBB\nCCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]),
-            ("\r",  ["AAA\nBBB\nCCC\r", "DDD\r", "EEE\r", "\nFFF\r", "\nGGG"]),
-            ]:
-            buf = io.BytesIO(testdata)
-            txt = io.TextIOWrapper(buf, encoding="ascii", newline=newline)
-            self.assertEquals(txt.readlines(), expected)
-            txt.seek(0)
-            self.assertEquals(txt.read(), "".join(expected))
-
-    def testNewlinesOutput(self):
-        testdict = {
-            "": b"AAA\nBBB\nCCC\nX\rY\r\nZ",
-            "\n": b"AAA\nBBB\nCCC\nX\rY\r\nZ",
-            "\r": b"AAA\rBBB\rCCC\rX\rY\r\rZ",
-            "\r\n": b"AAA\r\nBBB\r\nCCC\r\nX\rY\r\r\nZ",
-            }
-        tests = [(None, testdict[os.linesep])] + sorted(testdict.items())
-        for newline, expected in tests:
-            buf = io.BytesIO()
-            txt = io.TextIOWrapper(buf, encoding="ascii", newline=newline)
-            txt.write("AAA\nB")
-            txt.write("BB\nCCC\n")
-            txt.write("X\rY\r\nZ")
-            txt.flush()
-            self.assertEquals(buf.closed, False)
-            self.assertEquals(buf.getvalue(), expected)
-
-    def testNewlines(self):
+    def test_newlines(self):
         input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ]
 
         tests = [
@@ -867,8 +1440,8 @@
             for do_reads in (False, True):
                 for bufsize in range(1, 10):
                     for newline, exp_lines in tests:
-                        bufio = io.BufferedReader(io.BytesIO(data), bufsize)
-                        textio = io.TextIOWrapper(bufio, newline=newline,
+                        bufio = self.BufferedReader(self.BytesIO(data), bufsize)
+                        textio = self.TextIOWrapper(bufio, newline=newline,
                                                   encoding=encoding)
                         if do_reads:
                             got_lines = []
@@ -885,60 +1458,100 @@
                             self.assertEquals(got_line, exp_line)
                         self.assertEquals(len(got_lines), len(exp_lines))
 
-    def testNewlinesInput(self):
-        testdata = b"AAA\nBBB\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
+    def test_newlines_input(self):
+        testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG"
         normalized = testdata.replace(b"\r\n", b"\n").replace(b"\r", b"\n")
         for newline, expected in [
             (None, normalized.decode("ascii").splitlines(True)),
             ("", testdata.decode("ascii").splitlines(True)),
-            ("\n", ["AAA\n", "BBB\n", "CCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]),
-            ("\r\n", ["AAA\nBBB\nCCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]),
-            ("\r",  ["AAA\nBBB\nCCC\r", "DDD\r", "EEE\r", "\nFFF\r", "\nGGG"]),
+            ("\n", ["AAA\n", "BB\x00B\n", "CCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]),
+            ("\r\n", ["AAA\nBB\x00B\nCCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]),
+            ("\r",  ["AAA\nBB\x00B\nCCC\r", "DDD\r", "EEE\r", "\nFFF\r", "\nGGG"]),
             ]:
-            buf = io.BytesIO(testdata)
-            txt = io.TextIOWrapper(buf, encoding="ascii", newline=newline)
+            buf = self.BytesIO(testdata)
+            txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline)
             self.assertEquals(txt.readlines(), expected)
             txt.seek(0)
             self.assertEquals(txt.read(), "".join(expected))
 
-    def testNewlinesOutput(self):
-        data = "AAA\nBBB\rCCC\n"
-        data_lf = b"AAA\nBBB\rCCC\n"
-        data_cr = b"AAA\rBBB\rCCC\r"
-        data_crlf = b"AAA\r\nBBB\rCCC\r\n"
-        save_linesep = os.linesep
-        try:
-            for os.linesep, newline, expected in [
-                ("\n", None, data_lf),
-                ("\r\n", None, data_crlf),
-                ("\n", "", data_lf),
-                ("\r\n", "", data_lf),
-                ("\n", "\n", data_lf),
-                ("\r\n", "\n", data_lf),
-                ("\n", "\r", data_cr),
-                ("\r\n", "\r", data_cr),
-                ("\n", "\r\n", data_crlf),
-                ("\r\n", "\r\n", data_crlf),
-                ]:
-                buf = io.BytesIO()
-                txt = io.TextIOWrapper(buf, encoding="ascii", newline=newline)
-                txt.write(data)
-                txt.close()
-                self.assertEquals(buf.closed, True)
-                self.assertRaises(ValueError, buf.getvalue)
-        finally:
-            os.linesep = save_linesep
+    def test_newlines_output(self):
+        testdict = {
+            "": b"AAA\nBBB\nCCC\nX\rY\r\nZ",
+            "\n": b"AAA\nBBB\nCCC\nX\rY\r\nZ",
+            "\r": b"AAA\rBBB\rCCC\rX\rY\r\rZ",
+            "\r\n": b"AAA\r\nBBB\r\nCCC\r\nX\rY\r\r\nZ",
+            }
+        tests = [(None, testdict[os.linesep])] + sorted(testdict.items())
+        for newline, expected in tests:
+            buf = self.BytesIO()
+            txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline)
+            txt.write("AAA\nB")
+            txt.write("BB\nCCC\n")
+            txt.write("X\rY\r\nZ")
+            txt.flush()
+            self.assertEquals(buf.closed, False)
+            self.assertEquals(buf.getvalue(), expected)
+
+    def test_destructor(self):
+        l = []
+        base = self.BytesIO
+        class MyBytesIO(base):
+            def close(self):
+                l.append(self.getvalue())
+                base.close(self)
+        b = MyBytesIO()
+        t = self.TextIOWrapper(b, encoding="ascii")
+        t.write("abc")
+        del t
+        self.assertEquals([b"abc"], l)
+
+    def test_override_destructor(self):
+        record = []
+        class MyTextIO(self.TextIOWrapper):
+            def __del__(self):
+                record.append(1)
+                try:
+                    f = super().__del__
+                except AttributeError:
+                    pass
+                else:
+                    f()
+            def close(self):
+                record.append(2)
+                super().close()
+            def flush(self):
+                record.append(3)
+                super().flush()
+        b = self.BytesIO()
+        t = MyTextIO(b, encoding="ascii")
+        del t
+        self.assertEqual(record, [1, 2, 3])
+
+    def test_error_through_destructor(self):
+        # Test that the exception state is not modified by a destructor,
+        # even if close() fails.
+        rawio = self.CloseFailureIO()
+        def f():
+            self.TextIOWrapper(rawio).xyzzy
+        with support.captured_output("stderr") as s:
+            self.assertRaises(AttributeError, f)
+        s = s.getvalue().strip()
+        if s:
+            # The destructor *may* have printed an unraisable error, check it
+            self.assertEqual(len(s.splitlines()), 1)
+            self.assert_(s.startswith("Exception IOError: "), s)
+            self.assert_(s.endswith(" ignored"), s)
 
     # Systematic tests of the text I/O API
 
-    def testBasicIO(self):
+    def test_basic_io(self):
         for chunksize in (1, 2, 3, 4, 5, 15, 16, 17, 31, 32, 33, 63, 64, 65):
             for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le":
-                f = io.open(support.TESTFN, "w+", encoding=enc)
+                f = self.open(support.TESTFN, "w+", encoding=enc)
                 f._CHUNK_SIZE = chunksize
                 self.assertEquals(f.write("abc"), 3)
                 f.close()
-                f = io.open(support.TESTFN, "r+", encoding=enc)
+                f = self.open(support.TESTFN, "r+", encoding=enc)
                 f._CHUNK_SIZE = chunksize
                 self.assertEquals(f.tell(), 0)
                 self.assertEquals(f.read(), "abc")
@@ -980,8 +1593,8 @@
             rlines.append((pos, line))
         self.assertEquals(rlines, wlines)
 
-    def testTelling(self):
-        f = io.open(support.TESTFN, "w+", encoding="utf8")
+    def test_telling(self):
+        f = self.open(support.TESTFN, "w+", encoding="utf8")
         p0 = f.tell()
         f.write("\xff\n")
         p1 = f.tell()
@@ -1000,8 +1613,8 @@
         self.assertEquals(f.tell(), p2)
         f.close()
 
-    def testSeeking(self):
-        chunk_size = io.TextIOWrapper._CHUNK_SIZE
+    def test_seeking(self):
+        chunk_size = _default_chunk_size()
         prefix_size = chunk_size - 2
         u_prefix = "a" * prefix_size
         prefix = bytes(u_prefix.encode("utf-8"))
@@ -1009,48 +1622,46 @@
         u_suffix = "\u8888\n"
         suffix = bytes(u_suffix.encode("utf-8"))
         line = prefix + suffix
-        f = io.open(support.TESTFN, "wb")
+        f = self.open(support.TESTFN, "wb")
         f.write(line*2)
         f.close()
-        f = io.open(support.TESTFN, "r", encoding="utf-8")
+        f = self.open(support.TESTFN, "r", encoding="utf-8")
         s = f.read(prefix_size)
         self.assertEquals(s, str(prefix, "ascii"))
         self.assertEquals(f.tell(), prefix_size)
         self.assertEquals(f.readline(), u_suffix)
 
-    def testSeekingToo(self):
+    def test_seeking_too(self):
         # Regression test for a specific bug
         data = b'\xe0\xbf\xbf\n'
-        f = io.open(support.TESTFN, "wb")
+        f = self.open(support.TESTFN, "wb")
         f.write(data)
         f.close()
-        f = io.open(support.TESTFN, "r", encoding="utf-8")
+        f = self.open(support.TESTFN, "r", encoding="utf-8")
         f._CHUNK_SIZE  # Just test that it exists
         f._CHUNK_SIZE = 2
         f.readline()
         f.tell()
 
-    def testSeekAndTell(self):
-        """Test seek/tell using the StatefulIncrementalDecoder."""
-        # Make this test faster by forcing a smaller (but large enough)
-        # chunk size. The bigger the chunker size, the slower seek() is,
-        # as it tries to replay character decoding one byte at a time.
-        CHUNK_SIZE = 256
+    def test_seek_and_tell(self):
+        #Test seek/tell using the StatefulIncrementalDecoder.
+        # Make test faster by doing smaller seeks
+        CHUNK_SIZE = 128
 
         def testSeekAndTellWithData(data, min_pos=0):
             """Tell/seek to various points within a data stream and ensure
             that the decoded data returned by read() is consistent."""
-            f = io.open(support.TESTFN, 'wb')
+            f = self.open(support.TESTFN, 'wb')
             f.write(data)
             f.close()
-            f = io.open(support.TESTFN, encoding='test_decoder')
+            f = self.open(support.TESTFN, encoding='test_decoder')
+            f._CHUNK_SIZE = CHUNK_SIZE
             decoded = f.read()
             f.close()
 
             for i in range(min_pos, len(decoded) + 1): # seek positions
                 for j in [1, 5, len(decoded) - i]: # read lengths
-                    f = io.open(support.TESTFN, encoding='test_decoder')
-                    f._CHUNK_SIZE = CHUNK_SIZE
+                    f = self.open(support.TESTFN, encoding='test_decoder')
                     self.assertEquals(f.read(i), decoded[:i])
                     cookie = f.tell()
                     self.assertEquals(f.read(j), decoded[i:i + j])
@@ -1079,7 +1690,7 @@
         finally:
             StatefulIncrementalDecoder.codecEnabled = 0
 
-    def testEncodedWrites(self):
+    def test_encoded_writes(self):
         data = "1234567890"
         tests = ("utf-16",
                  "utf-16-le",
@@ -1088,8 +1699,8 @@
                  "utf-32-le",
                  "utf-32-be")
         for encoding in tests:
-            buf = io.BytesIO()
-            f = io.TextIOWrapper(buf, encoding=encoding)
+            buf = self.BytesIO()
+            f = self.TextIOWrapper(buf, encoding=encoding)
             # Check if the BOM is written only once (see issue1753).
             f.write(data)
             f.write(data)
@@ -1097,45 +1708,8 @@
             self.assertEquals(f.read(), data * 2)
             self.assertEquals(buf.getvalue(), (data * 2).encode(encoding))
 
-    def timingTest(self):
-        timer = time.time
-        enc = "utf8"
-        line = "\0\x0f\xff\u0fff\uffff\U000fffff\U0010ffff"*3 + "\n"
-        nlines = 10000
-        nchars = len(line)
-        nbytes = len(line.encode(enc))
-        for chunk_size in (32, 64, 128, 256):
-            f = io.open(support.TESTFN, "w+", encoding=enc)
-            f._CHUNK_SIZE = chunk_size
-            t0 = timer()
-            for i in range(nlines):
-                f.write(line)
-            f.flush()
-            t1 = timer()
-            f.seek(0)
-            for line in f:
-                pass
-            t2 = timer()
-            f.seek(0)
-            while f.readline():
-                pass
-            t3 = timer()
-            f.seek(0)
-            while f.readline():
-                f.tell()
-            t4 = timer()
-            f.close()
-            if support.verbose:
-                print("\nTiming test: %d lines of %d characters (%d bytes)" %
-                      (nlines, nchars, nbytes))
-                print("File chunk size:          %6s" % f._CHUNK_SIZE)
-                print("Writing:                  %6.3f seconds" % (t1-t0))
-                print("Reading using iteration:  %6.3f seconds" % (t2-t1))
-                print("Reading using readline(): %6.3f seconds" % (t3-t2))
-                print("Using readline()+tell():  %6.3f seconds" % (t4-t3))
-
-    def testReadOneByOne(self):
-        txt = io.TextIOWrapper(io.BytesIO(b"AA\r\nBB"))
+    def test_read_one_by_one(self):
+        txt = self.TextIOWrapper(self.BytesIO(b"AA\r\nBB"))
         reads = ""
         while True:
             c = txt.read(1)
@@ -1145,9 +1719,9 @@
         self.assertEquals(reads, "AA\nBB")
 
     # read in amounts equal to TextIOWrapper._CHUNK_SIZE which is 128.
-    def testReadByChunk(self):
+    def test_read_by_chunk(self):
         # make sure "\r\n" straddles 128 char boundary.
-        txt = io.TextIOWrapper(io.BytesIO(b"A" * 127 + b"\r\nB"))
+        txt = self.TextIOWrapper(self.BytesIO(b"A" * 127 + b"\r\nB"))
         reads = ""
         while True:
             c = txt.read(128)
@@ -1157,7 +1731,7 @@
         self.assertEquals(reads, "A"*127+"\nB")
 
     def test_issue1395_1(self):
-        txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ascii")
+        txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
 
         # read one char at a time
         reads = ""
@@ -1169,7 +1743,7 @@
         self.assertEquals(reads, self.normalized)
 
     def test_issue1395_2(self):
-        txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ascii")
+        txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
 
         reads = ""
@@ -1181,7 +1755,7 @@
         self.assertEquals(reads, self.normalized)
 
     def test_issue1395_3(self):
-        txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ascii")
+        txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
 
         reads = txt.read(4)
@@ -1192,7 +1766,7 @@
         self.assertEquals(reads, self.normalized)
 
     def test_issue1395_4(self):
-        txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ascii")
+        txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
 
         reads = txt.read(4)
@@ -1200,7 +1774,7 @@
         self.assertEquals(reads, self.normalized)
 
     def test_issue1395_5(self):
-        txt = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ascii")
+        txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii")
         txt._CHUNK_SIZE = 4
 
         reads = txt.read(4)
@@ -1210,12 +1784,45 @@
         self.assertEquals(txt.read(4), "BBB\n")
 
     def test_issue2282(self):
-        buffer = io.BytesIO(self.testdata)
-        txt = io.TextIOWrapper(buffer, encoding="ascii")
+        buffer = self.BytesIO(self.testdata)
+        txt = self.TextIOWrapper(buffer, encoding="ascii")
 
         self.assertEqual(buffer.seekable(), txt.seekable())
 
-    def check_newline_decoder_utf8(self, decoder):
+class CTextIOWrapperTest(TextIOWrapperTest):
+
+    def test_initialization(self):
+        r = self.BytesIO(b"\xc3\xa9\n\n")
+        b = self.BufferedReader(r, 1000)
+        t = self.TextIOWrapper(b)
+        self.assertRaises(TypeError, t.__init__, b, newline=42)
+        self.assertRaises(ValueError, t.read)
+        self.assertRaises(ValueError, t.__init__, b, newline='xyzzy')
+        self.assertRaises(ValueError, t.read)
+
+    def test_garbage_collection(self):
+        # C TextIOWrapper objects are collected, and collecting them flushes
+        # all data to disk.
+        # The Python version has __del__, so it ends in gc.garbage instead.
+        rawio = io.FileIO(support.TESTFN, "wb")
+        b = self.BufferedWriter(rawio)
+        t = self.TextIOWrapper(b, encoding="ascii")
+        t.write("456def")
+        t.x = t
+        wr = weakref.ref(t)
+        del t
+        gc.collect()
+        self.assert_(wr() is None, wr)
+        with open(support.TESTFN, "rb") as f:
+            self.assertEqual(f.read(), b"456def")
+
+class PyTextIOWrapperTest(TextIOWrapperTest):
+    pass
+
+
+class IncrementalNewlineDecoderTest(unittest.TestCase):
+
+    def check_newline_decoding_utf8(self, decoder):
         # UTF-8 specific tests for a newline decoder
         def _check_decode(b, s, **kwargs):
             # We exercise getstate() / setstate() as well as decode()
@@ -1257,12 +1864,20 @@
         _check_decode(b'\xe8\xa2\x88\r', "\u8888")
         _check_decode(b'\n', "\n")
 
-    def check_newline_decoder(self, decoder, encoding):
+    def check_newline_decoding(self, decoder, encoding):
         result = []
-        encoder = codecs.getincrementalencoder(encoding)()
-        def _decode_bytewise(s):
-            for b in encoder.encode(s):
-                result.append(decoder.decode(bytes([b])))
+        if encoding is not None:
+            encoder = codecs.getincrementalencoder(encoding)()
+            def _decode_bytewise(s):
+                # Decode one byte at a time
+                for b in encoder.encode(s):
+                    result.append(decoder.decode(bytes([b])))
+        else:
+            encoder = None
+            def _decode_bytewise(s):
+                # Decode one char at a time
+                for c in s:
+                    result.append(decoder.decode(c))
         self.assertEquals(decoder.newlines, None)
         _decode_bytewise("abc\n\r")
         self.assertEquals(decoder.newlines, '\n')
@@ -1275,22 +1890,34 @@
         _decode_bytewise("abc\r")
         self.assertEquals("".join(result), "abc\n\nabcabc\nabcabc")
         decoder.reset()
-        self.assertEquals(decoder.decode("abc".encode(encoding)), "abc")
+        input = "abc"
+        if encoder is not None:
+            encoder.reset()
+            input = encoder.encode(input)
+        self.assertEquals(decoder.decode(input), "abc")
         self.assertEquals(decoder.newlines, None)
 
     def test_newline_decoder(self):
         encodings = (
-            'utf-8', 'latin-1',
+            # None meaning the IncrementalNewlineDecoder takes unicode input
+            # rather than bytes input
+            None, 'utf-8', 'latin-1',
             'utf-16', 'utf-16-le', 'utf-16-be',
             'utf-32', 'utf-32-le', 'utf-32-be',
         )
         for enc in encodings:
-            decoder = codecs.getincrementaldecoder(enc)()
-            decoder = io.IncrementalNewlineDecoder(decoder, translate=True)
-            self.check_newline_decoder(decoder, enc)
+            decoder = enc and codecs.getincrementaldecoder(enc)()
+            decoder = self.IncrementalNewlineDecoder(decoder, translate=True)
+            self.check_newline_decoding(decoder, enc)
         decoder = codecs.getincrementaldecoder("utf-8")()
-        decoder = io.IncrementalNewlineDecoder(decoder, translate=True)
-        self.check_newline_decoder_utf8(decoder)
+        decoder = self.IncrementalNewlineDecoder(decoder, translate=True)
+        self.check_newline_decoding_utf8(decoder)
+
+class CIncrementalNewlineDecoderTest(IncrementalNewlineDecoderTest):
+    pass
+
+class PyIncrementalNewlineDecoderTest(IncrementalNewlineDecoderTest):
+    pass
 
 
 # XXX Tests for open()
@@ -1300,24 +1927,23 @@
     def tearDown(self):
         support.unlink(support.TESTFN)
 
-    def testImport__all__(self):
-        for name in io.__all__:
-            obj = getattr(io, name, None)
+    def test___all__(self):
+        for name in self.io.__all__:
+            obj = getattr(self.io, name, None)
             self.assert_(obj is not None, name)
             if name == "open":
                 continue
             elif "error" in name.lower():
                 self.assert_(issubclass(obj, Exception), name)
             else:
-                self.assert_(issubclass(obj, io.IOBase))
-
+                self.assert_(issubclass(obj, self.IOBase), name)
 
     def test_attributes(self):
-        f = io.open(support.TESTFN, "wb", buffering=0)
+        f = self.open(support.TESTFN, "wb", buffering=0)
         self.assertEquals(f.mode, "wb")
         f.close()
 
-        f = io.open(support.TESTFN, "U")
+        f = self.open(support.TESTFN, "U")
         self.assertEquals(f.name,            support.TESTFN)
         self.assertEquals(f.buffer.name,     support.TESTFN)
         self.assertEquals(f.buffer.raw.name, support.TESTFN)
@@ -1326,12 +1952,12 @@
         self.assertEquals(f.buffer.raw.mode, "rb")
         f.close()
 
-        f = io.open(support.TESTFN, "w+")
+        f = self.open(support.TESTFN, "w+")
         self.assertEquals(f.mode,            "w+")
         self.assertEquals(f.buffer.mode,     "rb+") # Does it really matter?
         self.assertEquals(f.buffer.raw.mode, "rb+")
 
-        g = io.open(f.fileno(), "wb", closefd=False)
+        g = self.open(f.fileno(), "wb", closefd=False)
         self.assertEquals(g.mode,     "wb")
         self.assertEquals(g.raw.mode, "wb")
         self.assertEquals(g.name,     f.fileno())
@@ -1357,13 +1983,12 @@
                 {"mode": "w+", "buffering": 2},
                 {"mode": "w+b", "buffering": 0},
             ]:
-            f = io.open(support.TESTFN, **kwargs)
+            f = self.open(support.TESTFN, **kwargs)
             f.close()
             self.assertRaises(ValueError, f.flush)
             self.assertRaises(ValueError, f.fileno)
             self.assertRaises(ValueError, f.isatty)
             self.assertRaises(ValueError, f.__iter__)
-            self.assertRaises(ValueError, next, f)
             if hasattr(f, "peek"):
                 self.assertRaises(ValueError, f.peek, 1)
             self.assertRaises(ValueError, f.read)
@@ -1376,16 +2001,101 @@
             self.assertRaises(ValueError, f.seek, 0)
             self.assertRaises(ValueError, f.tell)
             self.assertRaises(ValueError, f.truncate)
-            self.assertRaises(ValueError, f.write, "")
+            self.assertRaises(ValueError, f.write,
+                              b"" if "b" in kwargs['mode'] else "")
             self.assertRaises(ValueError, f.writelines, [])
+            self.assertRaises(ValueError, next, f)
 
+    def test_blockingioerror(self):
+        # Various BlockingIOError issues
+        self.assertRaises(TypeError, self.BlockingIOError)
+        self.assertRaises(TypeError, self.BlockingIOError, 1)
+        self.assertRaises(TypeError, self.BlockingIOError, 1, 2, 3, 4)
+        self.assertRaises(TypeError, self.BlockingIOError, 1, "", None)
+        b = self.BlockingIOError(1, "")
+        self.assertEqual(b.characters_written, 0)
+        class C(str):
+            pass
+        c = C("")
+        b = self.BlockingIOError(1, c)
+        c.b = b
+        b.c = c
+        wr = weakref.ref(c)
+        del c, b
+        gc.collect()
+        self.assert_(wr() is None, wr)
+
+    def test_abcs(self):
+        # Test the visible base classes are ABCs.
+        self.assertTrue(isinstance(self.IOBase, abc.ABCMeta))
+        self.assertTrue(isinstance(self.RawIOBase, abc.ABCMeta))
+        self.assertTrue(isinstance(self.BufferedIOBase, abc.ABCMeta))
+        self.assertTrue(isinstance(self.TextIOBase, abc.ABCMeta))
+
+    def _check_abc_inheritance(self, abcmodule):
+        with self.open(support.TESTFN, "wb", buffering=0) as f:
+            self.assertTrue(isinstance(f, abcmodule.IOBase))
+            self.assertTrue(isinstance(f, abcmodule.RawIOBase))
+            self.assertFalse(isinstance(f, abcmodule.BufferedIOBase))
+            self.assertFalse(isinstance(f, abcmodule.TextIOBase))
+        with self.open(support.TESTFN, "wb") as f:
+            self.assertTrue(isinstance(f, abcmodule.IOBase))
+            self.assertFalse(isinstance(f, abcmodule.RawIOBase))
+            self.assertTrue(isinstance(f, abcmodule.BufferedIOBase))
+            self.assertFalse(isinstance(f, abcmodule.TextIOBase))
+        with self.open(support.TESTFN, "w") as f:
+            self.assertTrue(isinstance(f, abcmodule.IOBase))
+            self.assertFalse(isinstance(f, abcmodule.RawIOBase))
+            self.assertFalse(isinstance(f, abcmodule.BufferedIOBase))
+            self.assertTrue(isinstance(f, abcmodule.TextIOBase))
+
+    def test_abc_inheritance(self):
+        # Test implementations inherit from their respective ABCs
+        self._check_abc_inheritance(self)
+
+    def test_abc_inheritance_official(self):
+        # Test implementations inherit from the official ABCs of the
+        # baseline "io" module.
+        self._check_abc_inheritance(io)
+
+class CMiscIOTest(MiscIOTest):
+    io = io
+
+class PyMiscIOTest(MiscIOTest):
+    io = pyio
 
 def test_main():
-    support.run_unittest(IOTest, BytesIOTest, StringIOTest,
-                              BufferedReaderTest, BufferedWriterTest,
-                              BufferedRWPairTest, BufferedRandomTest,
-                              StatefulIncrementalDecoderTest,
-                              TextIOWrapperTest, MiscIOTest)
+    tests = (CIOTest, PyIOTest,
+             CBufferedReaderTest, PyBufferedReaderTest,
+             CBufferedWriterTest, PyBufferedWriterTest,
+             CBufferedRWPairTest, PyBufferedRWPairTest,
+             CBufferedRandomTest, PyBufferedRandomTest,
+             StatefulIncrementalDecoderTest,
+             CIncrementalNewlineDecoderTest, PyIncrementalNewlineDecoderTest,
+             CTextIOWrapperTest, PyTextIOWrapperTest,
+             CMiscIOTest, PyMiscIOTest,)
+
+    # Put the namespaces of the IO module we are testing and some useful mock
+    # classes in the __dict__ of each test.
+    mocks = (MockRawIO, MisbehavedRawIO, MockFileIO, CloseFailureIO,
+             MockNonBlockWriterIO)
+    all_members = io.__all__ + ["IncrementalNewlineDecoder"]
+    c_io_ns = {name : getattr(io, name) for name in all_members}
+    py_io_ns = {name : getattr(pyio, name) for name in all_members}
+    globs = globals()
+    c_io_ns.update((x.__name__, globs["C" + x.__name__]) for x in mocks)
+    py_io_ns.update((x.__name__, globs["Py" + x.__name__]) for x in mocks)
+    # Avoid turning open into a bound method.
+    py_io_ns["open"] = pyio.OpenWrapper
+    for test in tests:
+        if test.__name__.startswith("C"):
+            for name, obj in c_io_ns.items():
+                setattr(test, name, obj)
+        elif test.__name__.startswith("Py"):
+            for name, obj in py_io_ns.items():
+                setattr(test, name, obj)
+
+    support.run_unittest(*tests)
 
 if __name__ == "__main__":
-    unittest.main()
+    test_main()
diff --git a/Lib/test/test_largefile.py b/Lib/test/test_largefile.py
index 8060ea0..584a206 100644
--- a/Lib/test/test_largefile.py
+++ b/Lib/test/test_largefile.py
@@ -7,6 +7,8 @@
 import unittest
 from test.support import run_unittest, TESTFN, verbose, requires, \
                               TestSkipped, unlink
+import io  # C implementation of io
+import _pyio as pyio # Python implementation of io
 
 try:
     import signal
@@ -21,7 +23,7 @@
 size = 2500000000
 
 
-class TestCase(unittest.TestCase):
+class LargeFileTest(unittest.TestCase):
     """Test that each file function works as expected for a large
     (i.e. > 2GB, do  we have to check > 4GB) files.
 
@@ -34,7 +36,7 @@
     def test_seek(self):
         if verbose:
             print('create large file via seek (may be sparse file) ...')
-        with open(TESTFN, 'wb') as f:
+        with self.open(TESTFN, 'wb') as f:
             f.write(b'z')
             f.seek(0)
             f.seek(size)
@@ -52,7 +54,7 @@
     def test_seek_read(self):
         if verbose:
             print('play around with seek() and read() with the built largefile')
-        with open(TESTFN, 'rb') as f:
+        with self.open(TESTFN, 'rb') as f:
             self.assertEqual(f.tell(), 0)
             self.assertEqual(f.read(1), b'z')
             self.assertEqual(f.tell(), 1)
@@ -85,7 +87,7 @@
     def test_lseek(self):
         if verbose:
             print('play around with os.lseek() with the built largefile')
-        with open(TESTFN, 'rb') as f:
+        with self.open(TESTFN, 'rb') as f:
             self.assertEqual(os.lseek(f.fileno(), 0, 0), 0)
             self.assertEqual(os.lseek(f.fileno(), 42, 0), 42)
             self.assertEqual(os.lseek(f.fileno(), 42, 1), 84)
@@ -100,7 +102,7 @@
     def test_truncate(self):
         if verbose:
             print('try truncate')
-        with open(TESTFN, 'r+b') as f:
+        with self.open(TESTFN, 'r+b') as f:
             # this is already decided before start running the test suite
             # but we do it anyway for extra protection
             if not hasattr(f, 'truncate'):
@@ -143,7 +145,7 @@
         # Only run if the current filesystem supports large files.
         # (Skip this test on Windows, since we now always support
         # large files.)
-        f = open(TESTFN, 'wb')
+        f = open(TESTFN, 'wb', buffering=0)
         try:
             # 2**31 == 2147483648
             f.seek(2147483649)
@@ -158,14 +160,19 @@
         else:
             f.close()
     suite = unittest.TestSuite()
-    suite.addTest(TestCase('test_seek'))
-    suite.addTest(TestCase('test_osstat'))
-    suite.addTest(TestCase('test_seek_read'))
-    suite.addTest(TestCase('test_lseek'))
-    with open(TESTFN, 'w') as f:
-        if hasattr(f, 'truncate'):
-            suite.addTest(TestCase('test_truncate'))
-    unlink(TESTFN)
+    for _open, prefix in [(io.open, 'C'), (pyio.open, 'Py')]:
+        class TestCase(LargeFileTest):
+            pass
+        TestCase.open = staticmethod(_open)
+        TestCase.__name__ = prefix + LargeFileTest.__name__
+        suite.addTest(TestCase('test_seek'))
+        suite.addTest(TestCase('test_osstat'))
+        suite.addTest(TestCase('test_seek_read'))
+        suite.addTest(TestCase('test_lseek'))
+        with _open(TESTFN, 'wb') as f:
+            if hasattr(f, 'truncate'):
+                suite.addTest(TestCase('test_truncate'))
+        unlink(TESTFN)
     try:
         run_unittest(suite)
     finally:
diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py
index d1745bc..b3fc042 100644
--- a/Lib/test/test_memoryio.py
+++ b/Lib/test/test_memoryio.py
@@ -7,13 +7,52 @@
 from test import support
 
 import io
+import _pyio as pyio
 import sys
 
-try:
-    import _bytesio, _stringio
-    has_c_implementation = True
-except ImportError:
-    has_c_implementation = False
+class MemorySeekTestMixin:
+
+    def testInit(self):
+        buf = self.buftype("1234567890")
+        bytesIo = self.ioclass(buf)
+
+    def testRead(self):
+        buf = self.buftype("1234567890")
+        bytesIo = self.ioclass(buf)
+
+        self.assertEquals(buf[:1], bytesIo.read(1))
+        self.assertEquals(buf[1:5], bytesIo.read(4))
+        self.assertEquals(buf[5:], bytesIo.read(900))
+        self.assertEquals(self.EOF, bytesIo.read())
+
+    def testReadNoArgs(self):
+        buf = self.buftype("1234567890")
+        bytesIo = self.ioclass(buf)
+
+        self.assertEquals(buf, bytesIo.read())
+        self.assertEquals(self.EOF, bytesIo.read())
+
+    def testSeek(self):
+        buf = self.buftype("1234567890")
+        bytesIo = self.ioclass(buf)
+
+        bytesIo.read(5)
+        bytesIo.seek(0)
+        self.assertEquals(buf, bytesIo.read())
+
+        bytesIo.seek(3)
+        self.assertEquals(buf[3:], bytesIo.read())
+        self.assertRaises(TypeError, bytesIo.seek, 0.0)
+
+    def testTell(self):
+        buf = self.buftype("1234567890")
+        bytesIo = self.ioclass(buf)
+
+        self.assertEquals(0, bytesIo.tell())
+        bytesIo.seek(5)
+        self.assertEquals(5, bytesIo.tell())
+        bytesIo.seek(10000)
+        self.assertEquals(10000, bytesIo.tell())
 
 
 class MemoryTestMixin:
@@ -148,7 +187,7 @@
         self.assertEqual(memio.readline(), self.EOF)
         memio.seek(0)
         self.assertEqual(type(memio.readline()), type(buf))
-        self.assertEqual(memio.readline(None), buf)
+        self.assertEqual(memio.readline(), buf)
         self.assertRaises(TypeError, memio.readline, '')
         memio.close()
         self.assertRaises(ValueError,  memio.readline)
@@ -296,11 +335,11 @@
         self.assertEqual(test2(), buf)
 
 
-class PyBytesIOTest(MemoryTestMixin, unittest.TestCase):
+class PyBytesIOTest(MemoryTestMixin, MemorySeekTestMixin, unittest.TestCase):
     @staticmethod
     def buftype(s):
         return s.encode("ascii")
-    ioclass = io._BytesIO
+    ioclass = pyio.BytesIO
     EOF = b""
 
     def test_read1(self):
@@ -371,11 +410,32 @@
         self.assertEqual(memio.getvalue(), buf)
 
 
-class PyStringIOTest(MemoryTestMixin, unittest.TestCase):
+class PyStringIOTest(MemoryTestMixin, MemorySeekTestMixin, unittest.TestCase):
     buftype = str
-    ioclass = io._StringIO
+    ioclass = pyio.StringIO
     EOF = ""
 
+    # TextIO-specific behaviour.
+
+    def test_newlines_property(self):
+        memio = self.ioclass(newline=None)
+        # The C StringIO decodes newlines in write() calls, but the Python
+        # implementation only does when reading.  This function forces them to
+        # be decoded for testing.
+        def force_decode():
+            memio.seek(0)
+            memio.read()
+        self.assertEqual(memio.newlines, None)
+        memio.write("a\n")
+        force_decode()
+        self.assertEqual(memio.newlines, "\n")
+        memio.write("b\r\n")
+        force_decode()
+        self.assertEqual(memio.newlines, ("\n", "\r\n"))
+        memio.write("c\rd")
+        force_decode()
+        self.assertEqual(memio.newlines, ("\r", "\n", "\r\n"))
+
     def test_relative_seek(self):
         memio = self.ioclass()
 
@@ -386,32 +446,99 @@
         self.assertRaises(IOError, memio.seek, 1, 1)
         self.assertRaises(IOError, memio.seek, 1, 2)
 
+    def test_textio_properties(self):
+        memio = self.ioclass()
+
+        # These are just dummy values but we nevertheless check them for fear
+        # of unexpected breakage.
+        self.assertEqual(memio.encoding, "utf-8")
+        self.assertEqual(memio.errors, "strict")
+        self.assertEqual(memio.line_buffering, False)
+
+    def test_newline_none(self):
+        # newline=None
+        memio = self.ioclass("a\nb\r\nc\rd", newline=None)
+        self.assertEqual(list(memio), ["a\n", "b\n", "c\n", "d"])
+        memio.seek(0)
+        self.assertEqual(memio.read(1), "a")
+        self.assertEqual(memio.read(2), "\nb")
+        self.assertEqual(memio.read(2), "\nc")
+        self.assertEqual(memio.read(1), "\n")
+        memio = self.ioclass(newline=None)
+        self.assertEqual(2, memio.write("a\n"))
+        self.assertEqual(3, memio.write("b\r\n"))
+        self.assertEqual(3, memio.write("c\rd"))
+        memio.seek(0)
+        self.assertEqual(memio.read(), "a\nb\nc\nd")
+        memio = self.ioclass("a\r\nb", newline=None)
+        self.assertEqual(memio.read(3), "a\nb")
+
+    def test_newline_empty(self):
+        # newline=""
+        memio = self.ioclass("a\nb\r\nc\rd", newline="")
+        self.assertEqual(list(memio), ["a\n", "b\r\n", "c\r", "d"])
+        memio.seek(0)
+        self.assertEqual(memio.read(4), "a\nb\r")
+        self.assertEqual(memio.read(2), "\nc")
+        self.assertEqual(memio.read(1), "\r")
+        memio = self.ioclass(newline="")
+        self.assertEqual(2, memio.write("a\n"))
+        self.assertEqual(2, memio.write("b\r"))
+        self.assertEqual(2, memio.write("\nc"))
+        self.assertEqual(2, memio.write("\rd"))
+        memio.seek(0)
+        self.assertEqual(list(memio), ["a\n", "b\r\n", "c\r", "d"])
+
+    def test_newline_lf(self):
+        # newline="\n"
+        memio = self.ioclass("a\nb\r\nc\rd")
+        self.assertEqual(list(memio), ["a\n", "b\r\n", "c\rd"])
+
+    def test_newline_cr(self):
+        # newline="\r"
+        memio = self.ioclass("a\nb\r\nc\rd", newline="\r")
+        memio.seek(0)
+        self.assertEqual(memio.read(), "a\rb\r\rc\rd")
+        memio.seek(0)
+        self.assertEqual(list(memio), ["a\r", "b\r", "\r", "c\r", "d"])
+
+    def test_newline_crlf(self):
+        # newline="\r\n"
+        memio = self.ioclass("a\nb\r\nc\rd", newline="\r\n")
+        memio.seek(0)
+        self.assertEqual(memio.read(), "a\r\nb\r\r\nc\rd")
+        memio.seek(0)
+        self.assertEqual(list(memio), ["a\r\n", "b\r\r\n", "c\rd"])
+
+    def test_issue5265(self):
+        # StringIO can duplicate newlines in universal newlines mode
+        memio = self.ioclass("a\r\nb\r\n", newline=None)
+        self.assertEqual(memio.read(5), "a\nb\n")
+
+
+class CBytesIOTest(PyBytesIOTest):
+    ioclass = io.BytesIO
+
+class CStringIOTest(PyStringIOTest):
+    ioclass = io.StringIO
+
     # XXX: For the Python version of io.StringIO, this is highly
     # dependent on the encoding used for the underlying buffer.
-    # def test_widechar(self):
-    #     buf = self.buftype("\U0002030a\U00020347")
-    #     memio = self.ioclass(buf)
-    #
-    #     self.assertEqual(memio.getvalue(), buf)
-    #     self.assertEqual(memio.write(buf), len(buf))
-    #     self.assertEqual(memio.tell(), len(buf))
-    #     self.assertEqual(memio.getvalue(), buf)
-    #     self.assertEqual(memio.write(buf), len(buf))
-    #     self.assertEqual(memio.tell(), len(buf) * 2)
-    #     self.assertEqual(memio.getvalue(), buf + buf)
+    def test_widechar(self):
+        buf = self.buftype("\U0002030a\U00020347")
+        memio = self.ioclass(buf)
 
-if has_c_implementation:
-    class CBytesIOTest(PyBytesIOTest):
-        ioclass = io.BytesIO
-
-    class CStringIOTest(PyStringIOTest):
-        ioclass = io.StringIO
+        self.assertEqual(memio.getvalue(), buf)
+        self.assertEqual(memio.write(buf), len(buf))
+        self.assertEqual(memio.tell(), len(buf))
+        self.assertEqual(memio.getvalue(), buf)
+        self.assertEqual(memio.write(buf), len(buf))
+        self.assertEqual(memio.tell(), len(buf) * 2)
+        self.assertEqual(memio.getvalue(), buf + buf)
 
 
 def test_main():
-    tests = [PyBytesIOTest, PyStringIOTest]
-    if has_c_implementation:
-        tests.extend([CBytesIOTest, CStringIOTest])
+    tests = [PyBytesIOTest, PyStringIOTest, CBytesIOTest, CStringIOTest]
     support.run_unittest(*tests)
 
 if __name__ == '__main__':
diff --git a/Lib/test/test_univnewlines.py b/Lib/test/test_univnewlines.py
index c4e4a3f..a6b9909 100644
--- a/Lib/test/test_univnewlines.py
+++ b/Lib/test/test_univnewlines.py
@@ -1,4 +1,6 @@
 # Tests universal newline support for both reading and parsing files.
+import io
+import _pyio as pyio
 import unittest
 import os
 import sys
@@ -35,7 +37,7 @@
     WRITEMODE = 'wb'
 
     def setUp(self):
-        fp = open(support.TESTFN, self.WRITEMODE)
+        fp = self.open(support.TESTFN, self.WRITEMODE)
         data = self.DATA
         if "b" in self.WRITEMODE:
             data = data.encode("ascii")
@@ -49,19 +51,19 @@
             pass
 
     def test_read(self):
-        fp = open(support.TESTFN, self.READMODE)
+        fp = self.open(support.TESTFN, self.READMODE)
         data = fp.read()
         self.assertEqual(data, DATA_LF)
         self.assertEqual(repr(fp.newlines), repr(self.NEWLINE))
 
     def test_readlines(self):
-        fp = open(support.TESTFN, self.READMODE)
+        fp = self.open(support.TESTFN, self.READMODE)
         data = fp.readlines()
         self.assertEqual(data, DATA_SPLIT)
         self.assertEqual(repr(fp.newlines), repr(self.NEWLINE))
 
     def test_readline(self):
-        fp = open(support.TESTFN, self.READMODE)
+        fp = self.open(support.TESTFN, self.READMODE)
         data = []
         d = fp.readline()
         while d:
@@ -71,7 +73,7 @@
         self.assertEqual(repr(fp.newlines), repr(self.NEWLINE))
 
     def test_seek(self):
-        fp = open(support.TESTFN, self.READMODE)
+        fp = self.open(support.TESTFN, self.READMODE)
         fp.readline()
         pos = fp.tell()
         data = fp.readlines()
@@ -94,7 +96,7 @@
     DATA = DATA_CRLF
 
     def test_tell(self):
-        fp = open(support.TESTFN, self.READMODE)
+        fp = self.open(support.TESTFN, self.READMODE)
         self.assertEqual(repr(fp.newlines), repr(None))
         data = fp.readline()
         pos = fp.tell()
@@ -106,12 +108,22 @@
 
 
 def test_main():
-    support.run_unittest(
-        TestCRNewlines,
-        TestLFNewlines,
-        TestCRLFNewlines,
-        TestMixedNewlines
-     )
+    base_tests = (TestCRNewlines,
+                  TestLFNewlines,
+                  TestCRLFNewlines,
+                  TestMixedNewlines)
+    tests = []
+    # Test the C and Python implementations.
+    for test in base_tests:
+        class CTest(test):
+            open = io.open
+        CTest.__name__ = "C" + test.__name__
+        class PyTest(test):
+            open = staticmethod(pyio.open)
+        PyTest.__name__ = "Py" + test.__name__
+        tests.append(CTest)
+        tests.append(PyTest)
+    support.run_unittest(*tests)
 
 if __name__ == '__main__':
     test_main()
diff --git a/Lib/test/test_uu.py b/Lib/test/test_uu.py
index d2b6e73..a54f2c1 100644
--- a/Lib/test/test_uu.py
+++ b/Lib/test/test_uu.py
@@ -32,6 +32,8 @@
                                      encoding=encoding,
                                      errors=errors,
                                      newline=newline)
+        self._encoding = encoding
+        self._errors = errors
         if initial_value:
             if not isinstance(initial_value, str):
                 initial_value = str(initial_value)