# Tests StringIO and cStringIO

import unittest

import StringIO

import cStringIO

import types

from test import test_support

class TestGenericStringIO(unittest.TestCase):

    # use a class variable MODULE to define which module is being tested

    # Line of data to test as string

    _line = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!'

    # Constructor to use for the test data (._line is passed to this

    # constructor)

    constructor = str

    def setUp(self):

        self._line = self.constructor(self._line)

        self._lines = self.constructor((self._line + '\n') * 5)

        self._fp = self.MODULE.StringIO(self._lines)

    def test_reads(self):

        eq = self.assertEqual

        self.assertRaises(TypeError, self._fp.seek)

        eq(self._fp.read(10), self._line[:10])

        eq(self._fp.readline(), self._line[10:] + '\n')

        eq(len(self._fp.readlines(60)), 2)

    def test_writes(self):

        f = self.MODULE.StringIO()

        self.assertRaises(TypeError, f.seek)

        f.write(self._line[:6])

        f.seek(3)

        f.write(self._line[20:26])

        f.write(self._line[52])

        self.assertEqual(f.getvalue(), 'abcuvwxyz!')

    def test_writelines(self):

        f = self.MODULE.StringIO()

        f.writelines([self._line[0], self._line[1], self._line[2]])

        f.seek(0)

        self.assertEqual(f.getvalue(), 'abc')

    def test_writelines_error(self):

        def errorGen():

            yield 'a'

            raise KeyboardInterrupt()

        f = self.MODULE.StringIO()

        self.assertRaises(KeyboardInterrupt, f.writelines, errorGen())

    def test_truncate(self):

        eq = self.assertEqual

        f = self.MODULE.StringIO()

        f.write(self._lines)

        f.seek(10)

        f.truncate()

        eq(f.getvalue(), 'abcdefghij')

        f.truncate(5)

        eq(f.getvalue(), 'abcde')

        f.write('xyz')

        eq(f.getvalue(), 'abcdexyz')

        f.close()

        self.assertRaises(ValueError, f.write, 'frobnitz')

    def test_closed_flag(self):

        f = self.MODULE.StringIO()

        self.assertEqual(f.closed, False)

        f.close()

        self.assertEqual(f.closed, True)

        f = self.MODULE.StringIO("abc")

        self.assertEqual(f.closed, False)

        f.close()

        self.assertEqual(f.closed, True)

    def test_isatty(self):

        f = self.MODULE.StringIO()

        self.assertRaises(TypeError, f.isatty, None)

        self.assertEqual(f.isatty(), False)

        f.close()

        self.assertRaises(ValueError, f.isatty)

    def test_iterator(self):

        eq = self.assertEqual

        unless = self.failUnless

        eq(iter(self._fp), self._fp)

        # Does this object support the iteration protocol?

        unless(hasattr(self._fp, '__iter__'))

        unless(hasattr(self._fp, 'next'))

        i = 0

        for line in self._fp:

            eq(line, self._line + '\n')

            i += 1

        eq(i, 5)

        self._fp.close()

        self.assertRaises(ValueError, self._fp.next)

class TestStringIO(TestGenericStringIO):

    MODULE = StringIO

    def test_unicode(self):

        if not test_support.have_unicode: return

        # The StringIO module also supports concatenating Unicode

        # snippets to larger Unicode strings. This is tested by this

        # method. Note that cStringIO does not support this extension.

        f = self.MODULE.StringIO()

        f.write(self._line[:6])

        f.seek(3)

        f.write(unicode(self._line[20:26]))

        f.write(unicode(self._line[52]))

        s = f.getvalue()

        self.assertEqual(s, unicode('abcuvwxyz!'))

        self.assertEqual(type(s), types.UnicodeType)

class TestcStringIO(TestGenericStringIO):

    MODULE = cStringIO

import sys

if sys.platform.startswith('java'):

    # Jython doesn't have a buffer object, so we just do a useless

    # fake of the buffer tests.

    buffer = str

class TestBufferStringIO(TestStringIO):

    constructor = buffer

class TestBuffercStringIO(TestcStringIO):

    constructor = buffer

def test_main():

    test_support.run_unittest(

        TestStringIO,

        TestcStringIO,

        TestBufferStringIO,

        TestBuffercStringIO

    )

if __name__ == '__main__':

    test_main()