Lib/test/test_StringIO.py

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