| # NOTE: this file tests the new `io` library backported from Python 3.x. |
| # Similar tests for the builtin file object can be found in test_file2k.py. |
| |
| from __future__ import print_function |
| |
| import sys |
| import os |
| import unittest |
| from array import array |
| from weakref import proxy |
| |
| import io |
| import _pyio as pyio |
| |
| from test.test_support import TESTFN, run_unittest |
| from UserList import UserList |
| |
| class AutoFileTests(unittest.TestCase): |
| # file tests for which a test file is automatically set up |
| |
| def setUp(self): |
| self.f = self.open(TESTFN, 'wb') |
| |
| def tearDown(self): |
| if self.f: |
| self.f.close() |
| os.remove(TESTFN) |
| |
| def testWeakRefs(self): |
| # verify weak references |
| p = proxy(self.f) |
| p.write(b'teststring') |
| self.assertEqual(self.f.tell(), p.tell()) |
| self.f.close() |
| self.f = None |
| self.assertRaises(ReferenceError, getattr, p, 'tell') |
| |
| def testAttributes(self): |
| # verify expected attributes exist |
| f = self.f |
| f.name # merely shouldn't blow up |
| f.mode # ditto |
| f.closed # ditto |
| |
| def testReadinto(self): |
| # verify readinto |
| self.f.write(b'12') |
| self.f.close() |
| a = array('b', b'x'*10) |
| self.f = self.open(TESTFN, 'rb') |
| n = self.f.readinto(a) |
| self.assertEqual(b'12', a.tostring()[:n]) |
| |
| def testReadinto_text(self): |
| # verify readinto refuses text files |
| a = array('b', b'x'*10) |
| self.f.close() |
| self.f = self.open(TESTFN, 'r') |
| if hasattr(self.f, "readinto"): |
| self.assertRaises(TypeError, self.f.readinto, a) |
| |
| def testWritelinesUserList(self): |
| # verify writelines with instance sequence |
| l = UserList([b'1', b'2']) |
| self.f.writelines(l) |
| self.f.close() |
| self.f = self.open(TESTFN, 'rb') |
| buf = self.f.read() |
| self.assertEqual(buf, b'12') |
| |
| def testWritelinesIntegers(self): |
| # verify writelines with integers |
| self.assertRaises(TypeError, self.f.writelines, [1, 2, 3]) |
| |
| def testWritelinesIntegersUserList(self): |
| # verify writelines with integers in UserList |
| l = UserList([1,2,3]) |
| self.assertRaises(TypeError, self.f.writelines, l) |
| |
| def testWritelinesNonString(self): |
| # verify writelines with non-string object |
| class NonString: |
| pass |
| |
| self.assertRaises(TypeError, self.f.writelines, |
| [NonString(), NonString()]) |
| |
| def testErrors(self): |
| f = self.f |
| self.assertEqual(f.name, TESTFN) |
| self.assertTrue(not f.isatty()) |
| self.assertTrue(not f.closed) |
| |
| if hasattr(f, "readinto"): |
| self.assertRaises((IOError, TypeError), f.readinto, "") |
| f.close() |
| self.assertTrue(f.closed) |
| |
| def testMethods(self): |
| methods = [('fileno', ()), |
| ('flush', ()), |
| ('isatty', ()), |
| ('next', ()), |
| ('read', ()), |
| ('write', (b"",)), |
| ('readline', ()), |
| ('readlines', ()), |
| ('seek', (0,)), |
| ('tell', ()), |
| ('write', (b"",)), |
| ('writelines', ([],)), |
| ('__iter__', ()), |
| ] |
| if not sys.platform.startswith('atheos'): |
| methods.append(('truncate', ())) |
| |
| # __exit__ should close the file |
| self.f.__exit__(None, None, None) |
| self.assertTrue(self.f.closed) |
| |
| for methodname, args in methods: |
| method = getattr(self.f, methodname) |
| # should raise on closed file |
| self.assertRaises(ValueError, method, *args) |
| |
| # file is closed, __exit__ shouldn't do anything |
| self.assertEqual(self.f.__exit__(None, None, None), None) |
| # it must also return None if an exception was given |
| try: |
| 1 // 0 |
| except: |
| self.assertEqual(self.f.__exit__(*sys.exc_info()), None) |
| |
| 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 = self.open(TESTFN, mode) |
| except ValueError: |
| pass |
| else: |
| f.close() |
| self.fail('%r is an invalid file mode' % mode) |
| |
| def testBadModeArgument(self): |
| # verify that we get a sensible error message for bad mode argument |
| bad_mode = "qwerty" |
| try: |
| f = self.open(TESTFN, bad_mode) |
| except ValueError as msg: |
| if msg.args[0] != 0: |
| s = str(msg) |
| if TESTFN in s or bad_mode not in s: |
| self.fail("bad error message for invalid mode: %s" % s) |
| # if msg.args[0] == 0, we're probably on Windows where there may be |
| # no obvious way to discover why open() failed. |
| else: |
| f.close() |
| self.fail("no error for invalid mode: %s" % bad_mode) |
| |
| def testSetBufferSize(self): |
| # make sure that explicitly setting the buffer size doesn't cause |
| # misbehaviour especially with repeated close() calls |
| for s in (-1, 0, 1, 512): |
| try: |
| f = self.open(TESTFN, 'wb', s) |
| f.write(str(s).encode("ascii")) |
| f.close() |
| f.close() |
| f = self.open(TESTFN, 'rb', s) |
| d = int(f.read().decode("ascii")) |
| f.close() |
| f.close() |
| except IOError as msg: |
| self.fail('error setting buffer size %d: %s' % (s, str(msg))) |
| self.assertEqual(d, s) |
| |
| def testTruncateOnWindows(self): |
| # SF bug <http://www.python.org/sf/801631> |
| # "file.truncate fault on windows" |
| |
| os.unlink(TESTFN) |
| f = self.open(TESTFN, 'wb') |
| |
| try: |
| f.write(b'12345678901') # 11 bytes |
| f.close() |
| |
| f = self.open(TESTFN,'rb+') |
| data = f.read(5) |
| if data != b'12345': |
| self.fail("Read on file opened for update failed %r" % data) |
| if f.tell() != 5: |
| self.fail("File pos after read wrong %d" % f.tell()) |
| |
| f.truncate() |
| if f.tell() != 5: |
| self.fail("File pos after ftruncate wrong %d" % f.tell()) |
| |
| f.close() |
| size = os.path.getsize(TESTFN) |
| if size != 5: |
| self.fail("File size after ftruncate wrong %d" % size) |
| finally: |
| f.close() |
| os.unlink(TESTFN) |
| |
| def testIteration(self): |
| # Test the complex interaction when mixing file-iteration and the |
| # various read* methods. |
| dataoffset = 16384 |
| filler = b"ham\n" |
| assert not dataoffset % len(filler), \ |
| "dataoffset must be multiple of len(filler)" |
| nchunks = dataoffset // len(filler) |
| testlines = [ |
| b"spam, spam and eggs\n", |
| b"eggs, spam, ham and spam\n", |
| b"saussages, spam, spam and eggs\n", |
| b"spam, ham, spam and eggs\n", |
| b"spam, spam, spam, spam, spam, ham, spam\n", |
| b"wonderful spaaaaaam.\n" |
| ] |
| methods = [("readline", ()), ("read", ()), ("readlines", ()), |
| ("readinto", (array("b", b" "*100),))] |
| |
| try: |
| # Prepare the testfile |
| 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 = self.open(TESTFN, 'rb') |
| if next(f) != filler: |
| self.fail, "Broken testfile" |
| meth = getattr(f, methodname) |
| meth(*args) # This simply shouldn't fail |
| f.close() |
| |
| # Test to see if harmless (by accident) mixing of read* and |
| # iteration still works. This depends on the size of the internal |
| # iteration buffer (currently 8192,) but we can test it in a |
| # flexible manner. Each line in the bag o' ham is 4 bytes |
| # ("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 = self.open(TESTFN, 'rb') |
| for i in range(nchunks): |
| next(f) |
| testline = testlines.pop(0) |
| try: |
| line = f.readline() |
| except ValueError: |
| self.fail("readline() after next() with supposedly empty " |
| "iteration-buffer failed anyway") |
| if line != testline: |
| self.fail("readline() after next() with empty buffer " |
| "failed. Got %r, expected %r" % (line, testline)) |
| testline = testlines.pop(0) |
| buf = array("b", b"\x00" * len(testline)) |
| try: |
| f.readinto(buf) |
| except ValueError: |
| self.fail("readinto() after next() with supposedly empty " |
| "iteration-buffer failed anyway") |
| line = buf.tostring() |
| if line != testline: |
| self.fail("readinto() after next() with empty buffer " |
| "failed. Got %r, expected %r" % (line, testline)) |
| |
| testline = testlines.pop(0) |
| try: |
| line = f.read(len(testline)) |
| except ValueError: |
| self.fail("read() after next() with supposedly empty " |
| "iteration-buffer failed anyway") |
| if line != testline: |
| self.fail("read() after next() with empty buffer " |
| "failed. Got %r, expected %r" % (line, testline)) |
| try: |
| lines = f.readlines() |
| except ValueError: |
| self.fail("readlines() after next() with supposedly empty " |
| "iteration-buffer failed anyway") |
| if lines != testlines: |
| 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.close() |
| f = self.open(TESTFN, 'rb') |
| try: |
| for line in f: |
| pass |
| try: |
| f.readline() |
| f.readinto(buf) |
| f.read() |
| f.readlines() |
| except ValueError: |
| self.fail("read* failed after next() consumed file") |
| finally: |
| f.close() |
| 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(CAutoFileTests, PyAutoFileTests, |
| COtherFileTests, PyOtherFileTests) |
| finally: |
| if os.path.exists(TESTFN): |
| os.unlink(TESTFN) |
| |
| if __name__ == '__main__': |
| test_main() |
