diff options
Diffstat (limited to 'lib/python2.7/test/test_file.py')
| -rw-r--r-- | lib/python2.7/test/test_file.py | 347 |
1 files changed, 0 insertions, 347 deletions
diff --git a/lib/python2.7/test/test_file.py b/lib/python2.7/test/test_file.py deleted file mode 100644 index dffa4b5..0000000 --- a/lib/python2.7/test/test_file.py +++ /dev/null @@ -1,347 +0,0 @@ -# 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 testStdin(self): - # This causes the interpreter to exit on OSF1 v5.1. - if sys.platform != 'osf1V5': - self.assertRaises((IOError, ValueError), sys.stdin.seek, -1) - else: - print(( - ' Skipping sys.stdin.seek(-1), it may crash the interpreter.' - ' Test manually.'), file=sys.__stdout__) - self.assertRaises((IOError, ValueError), sys.stdin.truncate) - - 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 = 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() |