def test_2StringIO(self):
     """
     Python 2's L{StringIO} and L{cStringIO} modules are both binary I/O.
     """
     from cStringIO import StringIO as cStringIO
     from StringIO import StringIO
     self.assertEqual(ioType(StringIO()), bytes)
     self.assertEqual(ioType(cStringIO()), bytes)

 def test_codecsOpenBytes(self):
     """
     The L{codecs} module, oddly, returns a file-like object which returns
     bytes when not passed an 'encoding' argument.
     """
     with codecs.open(self.mktemp(), 'wb') as f:
         self.assertEqual(ioType(f), bytes)

 def test_codecsOpenText(self):
     """
     When passed an encoding, however, the L{codecs} module returns unicode.
     """
     self.assertEquals(ioType(codecs.open(self.mktemp(), 'wb',
                                          encoding='utf-8')),
                       unicodeCompat)

def _streamWriteWrapper(stream):
    if ioType(stream) == bytes:
        def w(s):
            if isinstance(s, unicode):
                s = s.encode("utf-8")
            stream.write(s)
    else:
        def w(s):
            if isinstance(s, bytes):
                s = s.decode("utf-8")
            stream.write(s)
    return w

    def __init__(self, outFile, formatEvent):
        """
        @param outFile: A file-like object.  Ideally one should be passed which
            accepts L{unicode} data.  Otherwise, UTF-8 L{bytes} will be used.
        @type outFile: L{io.IOBase}

        @param formatEvent: A callable that formats an event.
        @type formatEvent: L{callable} that takes an C{event} argument and
            returns a formatted event as L{unicode}.
        """
        if ioType(outFile) is not unicode:
            self._encoding = "utf-8"
        else:
            self._encoding = None

        self._outFile = outFile
        self.formatEvent = formatEvent

    def test_2openTextMode(self):
        """
        The special built-in console file in Python 2 which has an 'encoding'
        attribute should qualify as a special type, since it accepts both bytes
        and text faithfully.
        """
        class VerySpecificLie(file):
            """
            In their infinite wisdom, the CPython developers saw fit not to
            allow us a writable 'encoding' attribute on the built-in 'file'
            type in Python 2, despite making it writable in C with
            PyFile_SetEncoding.

            Pretend they did not do that.
            """
            encoding = 'utf-8'

        self.assertEqual(ioType(VerySpecificLie(self.mktemp(), "wb")),
                          basestring)

 def test_2openBinaryMode(self):
     """
     The normal 'open' builtin in Python 2 will always result in bytes I/O.
     """
     with open(self.mktemp(), "w") as f:
         self.assertEqual(ioType(f), bytes)

 def test_3openBinaryMode(self):
     """
     A file opened via 'io.open' in binary mode accepts and returns bytes.
     """
     with io.open(self.mktemp(), "wb") as f:
         self.assertEqual(ioType(f), bytes)

 def test_3openTextMode(self):
     """
     A file opened via 'io.open' in text mode accepts and returns text.
     """
     with io.open(self.mktemp(), "w") as f:
         self.assertEqual(ioType(f), unicodeCompat)

 def test_3BytesIO(self):
     """
     An L{io.BytesIO} accepts and returns bytes.
     """
     self.assertEqual(ioType(io.BytesIO()), bytes)

 def test_3StringIO(self):
     """
     An L{io.StringIO} accepts and returns text.
     """
     self.assertEqual(ioType(io.StringIO()), unicodeCompat)

 def test_defaultToText(self):
     """
     When passed an object about which no sensible decision can be made, err
     on the side of unicode.
     """
     self.assertEqual(ioType(object()), unicodeCompat)