1# Tests StringIO and cStringIO
2
3import unittest
4import StringIO
5import cStringIO
6import types
7from test import test_support
8
9
10class TestGenericStringIO(unittest.TestCase):
11    # use a class variable MODULE to define which module is being tested
12
13    # Line of data to test as string
14    _line = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!'
15
16    # Constructor to use for the test data (._line is passed to this
17    # constructor)
18    constructor = str
19
20    def setUp(self):
21        self._line = self.constructor(self._line)
22        self._lines = self.constructor((self._line + '\n') * 5)
23        self._fp = self.MODULE.StringIO(self._lines)
24
25    def test_reads(self):
26        eq = self.assertEqual
27        self.assertRaises(TypeError, self._fp.seek)
28        eq(self._fp.read(10), self._line[:10])
29        eq(self._fp.readline(), self._line[10:] + '\n')
30        eq(len(self._fp.readlines(60)), 2)
31        self._fp.seek(0)
32        eq(self._fp.readline(-1), self._line + '\n')
33
34    def test_writes(self):
35        f = self.MODULE.StringIO()
36        self.assertRaises(TypeError, f.seek)
37        f.write(self._line[:6])
38        f.seek(3)
39        f.write(self._line[20:26])
40        f.write(self._line[52])
41        self.assertEqual(f.getvalue(), 'abcuvwxyz!')
42
43    def test_writelines(self):
44        f = self.MODULE.StringIO()
45        f.writelines([self._line[0], self._line[1], self._line[2]])
46        f.seek(0)
47        self.assertEqual(f.getvalue(), 'abc')
48
49    def test_writelines_error(self):
50        def errorGen():
51            yield 'a'
52            raise KeyboardInterrupt()
53        f = self.MODULE.StringIO()
54        self.assertRaises(KeyboardInterrupt, f.writelines, errorGen())
55
56    def test_truncate(self):
57        eq = self.assertEqual
58        f = self.MODULE.StringIO()
59        f.write(self._lines)
60        f.seek(10)
61        f.truncate()
62        eq(f.getvalue(), 'abcdefghij')
63        f.truncate(5)
64        eq(f.getvalue(), 'abcde')
65        f.write('xyz')
66        eq(f.getvalue(), 'abcdexyz')
67        self.assertRaises(IOError, f.truncate, -1)
68        f.close()
69        self.assertRaises(ValueError, f.write, 'frobnitz')
70
71    def test_closed_flag(self):
72        f = self.MODULE.StringIO()
73        self.assertEqual(f.closed, False)
74        f.close()
75        self.assertEqual(f.closed, True)
76        f = self.MODULE.StringIO("abc")
77        self.assertEqual(f.closed, False)
78        f.close()
79        self.assertEqual(f.closed, True)
80
81    def test_isatty(self):
82        f = self.MODULE.StringIO()
83        self.assertRaises(TypeError, f.isatty, None)
84        self.assertEqual(f.isatty(), False)
85        f.close()
86        self.assertRaises(ValueError, f.isatty)
87
88    def test_iterator(self):
89        eq = self.assertEqual
90        unless = self.assertTrue
91        eq(iter(self._fp), self._fp)
92        # Does this object support the iteration protocol?
93        unless(hasattr(self._fp, '__iter__'))
94        unless(hasattr(self._fp, 'next'))
95        i = 0
96        for line in self._fp:
97            eq(line, self._line + '\n')
98            i += 1
99        eq(i, 5)
100        self._fp.close()
101        self.assertRaises(ValueError, self._fp.next)
102
103    def test_getvalue(self):
104        self._fp.close()
105        self.assertRaises(ValueError, self._fp.getvalue)
106
107class TestStringIO(TestGenericStringIO):
108    MODULE = StringIO
109
110    def test_unicode(self):
111
112        if not test_support.have_unicode: return
113
114        # The StringIO module also supports concatenating Unicode
115        # snippets to larger Unicode strings. This is tested by this
116        # method. Note that cStringIO does not support this extension.
117
118        f = self.MODULE.StringIO()
119        f.write(self._line[:6])
120        f.seek(3)
121        f.write(unicode(self._line[20:26]))
122        f.write(unicode(self._line[52]))
123        s = f.getvalue()
124        self.assertEqual(s, unicode('abcuvwxyz!'))
125        self.assertEqual(type(s), types.UnicodeType)
126
127class TestcStringIO(TestGenericStringIO):
128    MODULE = cStringIO
129
130import sys
131if sys.platform.startswith('java'):
132    # Jython doesn't have a buffer object, so we just do a useless
133    # fake of the buffer tests.
134    buffer = str
135
136class TestBufferStringIO(TestStringIO):
137    constructor = buffer
138
139class TestBuffercStringIO(TestcStringIO):
140    constructor = buffer
141
142
143def test_main():
144    test_support.run_unittest(TestStringIO, TestcStringIO)
145    with test_support.check_py3k_warnings(("buffer.. not supported",
146                                             DeprecationWarning)):
147        test_support.run_unittest(TestBufferStringIO, TestBuffercStringIO)
148
149if __name__ == '__main__':
150    test_main()
151