Martin v. Löwis | f90ae20 | 2002-06-11 06:22:31 +0000 | [diff] [blame] | 1 | import sys |
Fred Drake | 2ec80fa | 2000-10-23 16:59:35 +0000 | [diff] [blame] | 2 | import os |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 3 | import unittest |
Neal Norwitz | 62f5a9d | 2002-04-01 00:09:00 +0000 | [diff] [blame] | 4 | from array import array |
Raymond Hettinger | cb87bc8 | 2004-05-31 00:35:52 +0000 | [diff] [blame] | 5 | from weakref import proxy |
Fred Drake | 2ec80fa | 2000-10-23 16:59:35 +0000 | [diff] [blame] | 6 | |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 7 | import io |
| 8 | import _pyio as pyio |
| 9 | |
Serhiy Storchaka | 597d15a | 2016-04-24 13:45:58 +0300 | [diff] [blame] | 10 | from test.support import TESTFN |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 11 | from test import support |
Raymond Hettinger | 53dbe39 | 2008-02-12 20:03:09 +0000 | [diff] [blame] | 12 | from collections import UserList |
Marc-André Lemburg | fa44d79 | 2000-08-25 22:37:31 +0000 | [diff] [blame] | 13 | |
Ezio Melotti | 3a03d2e | 2013-02-15 19:17:53 +0200 | [diff] [blame] | 14 | class AutoFileTests: |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 15 | # file tests for which a test file is automatically set up |
Raymond Hettinger | cb87bc8 | 2004-05-31 00:35:52 +0000 | [diff] [blame] | 16 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 17 | def setUp(self): |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 18 | self.f = self.open(TESTFN, 'wb') |
Tim Peters | 015dd82 | 2003-05-04 04:16:52 +0000 | [diff] [blame] | 19 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 20 | def tearDown(self): |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 21 | if self.f: |
| 22 | self.f.close() |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 23 | support.unlink(TESTFN) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 24 | |
| 25 | def testWeakRefs(self): |
| 26 | # verify weak references |
| 27 | p = proxy(self.f) |
Guido van Rossum | e22905a | 2007-08-27 23:09:25 +0000 | [diff] [blame] | 28 | p.write(b'teststring') |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 29 | self.assertEqual(self.f.tell(), p.tell()) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 30 | self.f.close() |
| 31 | self.f = None |
| 32 | self.assertRaises(ReferenceError, getattr, p, 'tell') |
| 33 | |
| 34 | def testAttributes(self): |
| 35 | # verify expected attributes exist |
| 36 | f = self.f |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 37 | f.name # merely shouldn't blow up |
| 38 | f.mode # ditto |
| 39 | f.closed # ditto |
| 40 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 41 | def testReadinto(self): |
| 42 | # verify readinto |
Guido van Rossum | e22905a | 2007-08-27 23:09:25 +0000 | [diff] [blame] | 43 | self.f.write(b'12') |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 44 | self.f.close() |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 45 | a = array('b', b'x'*10) |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 46 | self.f = self.open(TESTFN, 'rb') |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 47 | n = self.f.readinto(a) |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 48 | self.assertEqual(b'12', a.tobytes()[:n]) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 49 | |
| 50 | def testReadinto_text(self): |
| 51 | # verify readinto refuses text files |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 52 | a = array('b', b'x'*10) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 53 | self.f.close() |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 54 | self.f = self.open(TESTFN, 'r') |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 55 | if hasattr(self.f, "readinto"): |
| 56 | self.assertRaises(TypeError, self.f.readinto, a) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 57 | |
| 58 | def testWritelinesUserList(self): |
| 59 | # verify writelines with instance sequence |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 60 | l = UserList([b'1', b'2']) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 61 | self.f.writelines(l) |
| 62 | self.f.close() |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 63 | self.f = self.open(TESTFN, 'rb') |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 64 | buf = self.f.read() |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 65 | self.assertEqual(buf, b'12') |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 66 | |
| 67 | def testWritelinesIntegers(self): |
| 68 | # verify writelines with integers |
| 69 | self.assertRaises(TypeError, self.f.writelines, [1, 2, 3]) |
| 70 | |
| 71 | def testWritelinesIntegersUserList(self): |
| 72 | # verify writelines with integers in UserList |
| 73 | l = UserList([1,2,3]) |
| 74 | self.assertRaises(TypeError, self.f.writelines, l) |
| 75 | |
| 76 | def testWritelinesNonString(self): |
| 77 | # verify writelines with non-string object |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 78 | class NonString: |
| 79 | pass |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 80 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 81 | self.assertRaises(TypeError, self.f.writelines, |
| 82 | [NonString(), NonString()]) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 83 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 84 | def testErrors(self): |
| 85 | f = self.f |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 86 | self.assertEqual(f.name, TESTFN) |
Serhiy Storchaka | 0dcd80a | 2015-08-02 15:17:49 +0300 | [diff] [blame] | 87 | self.assertFalse(f.isatty()) |
| 88 | self.assertFalse(f.closed) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 89 | |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 90 | if hasattr(f, "readinto"): |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 91 | self.assertRaises((OSError, TypeError), f.readinto, "") |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 92 | f.close() |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 93 | self.assertTrue(f.closed) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 94 | |
| 95 | def testMethods(self): |
Guido van Rossum | 4b5386f | 2007-07-10 09:12:49 +0000 | [diff] [blame] | 96 | methods = [('fileno', ()), |
| 97 | ('flush', ()), |
| 98 | ('isatty', ()), |
| 99 | ('__next__', ()), |
| 100 | ('read', ()), |
| 101 | ('write', (b"",)), |
| 102 | ('readline', ()), |
| 103 | ('readlines', ()), |
| 104 | ('seek', (0,)), |
| 105 | ('tell', ()), |
| 106 | ('write', (b"",)), |
| 107 | ('writelines', ([],)), |
| 108 | ('__iter__', ()), |
| 109 | ] |
Antoine Pitrou | 6103ab1 | 2009-10-24 20:11:21 +0000 | [diff] [blame] | 110 | methods.append(('truncate', ())) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 111 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 112 | # __exit__ should close the file |
| 113 | self.f.__exit__(None, None, None) |
Benjamin Peterson | c9c0f20 | 2009-06-30 23:06:06 +0000 | [diff] [blame] | 114 | self.assertTrue(self.f.closed) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 115 | |
Guido van Rossum | 4b5386f | 2007-07-10 09:12:49 +0000 | [diff] [blame] | 116 | for methodname, args in methods: |
| 117 | method = getattr(self.f, methodname) |
| 118 | # should raise on closed file |
| 119 | self.assertRaises(ValueError, method, *args) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 120 | |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 121 | # file is closed, __exit__ shouldn't do anything |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 122 | self.assertEqual(self.f.__exit__(None, None, None), None) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 123 | # it must also return None if an exception was given |
| 124 | try: |
| 125 | 1/0 |
| 126 | except: |
Ezio Melotti | b3aedd4 | 2010-11-20 19:04:17 +0000 | [diff] [blame] | 127 | self.assertEqual(self.f.__exit__(*sys.exc_info()), None) |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 128 | |
Skip Montanaro | 80072cb | 2008-12-23 03:51:14 +0000 | [diff] [blame] | 129 | def testReadWhenWriting(self): |
Andrew Svetlov | f7a17b4 | 2012-12-25 16:47:37 +0200 | [diff] [blame] | 130 | self.assertRaises(OSError, self.f.read) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 131 | |
Ezio Melotti | 3a03d2e | 2013-02-15 19:17:53 +0200 | [diff] [blame] | 132 | class CAutoFileTests(AutoFileTests, unittest.TestCase): |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 133 | open = io.open |
| 134 | |
Ezio Melotti | 3a03d2e | 2013-02-15 19:17:53 +0200 | [diff] [blame] | 135 | class PyAutoFileTests(AutoFileTests, unittest.TestCase): |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 136 | open = staticmethod(pyio.open) |
| 137 | |
| 138 | |
Ezio Melotti | 3a03d2e | 2013-02-15 19:17:53 +0200 | [diff] [blame] | 139 | class OtherFileTests: |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 140 | |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 141 | def tearDown(self): |
| 142 | support.unlink(TESTFN) |
| 143 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 144 | def testModeStrings(self): |
| 145 | # check invalid mode strings |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 146 | self.open(TESTFN, 'wb').close() |
Robert Collins | c94a1dc | 2015-07-26 06:43:13 +1200 | [diff] [blame] | 147 | for mode in ("", "aU", "wU+", "U+", "+U", "rU+"): |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 148 | try: |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 149 | f = self.open(TESTFN, mode) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 150 | except ValueError: |
| 151 | pass |
| 152 | else: |
| 153 | f.close() |
| 154 | self.fail('%r is an invalid file mode' % mode) |
| 155 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 156 | def testBadModeArgument(self): |
| 157 | # verify that we get a sensible error message for bad mode argument |
| 158 | bad_mode = "qwerty" |
Tim Peters | cffcfed | 2006-02-14 17:41:18 +0000 | [diff] [blame] | 159 | try: |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 160 | f = self.open(TESTFN, bad_mode) |
Guido van Rossum | b940e11 | 2007-01-10 16:19:56 +0000 | [diff] [blame] | 161 | except ValueError as msg: |
Brett Cannon | ca477b2 | 2007-03-21 22:26:20 +0000 | [diff] [blame] | 162 | if msg.args[0] != 0: |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 163 | s = str(msg) |
Ezio Melotti | 7fb4da7 | 2010-03-18 12:29:13 +0000 | [diff] [blame] | 164 | if TESTFN in s or bad_mode not in s: |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 165 | self.fail("bad error message for invalid mode: %s" % s) |
Georg Brandl | 50da60c | 2008-01-06 21:38:54 +0000 | [diff] [blame] | 166 | # if msg.args[0] == 0, we're probably on Windows where there may be |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 167 | # no obvious way to discover why open() failed. |
| 168 | else: |
| 169 | f.close() |
| 170 | self.fail("no error for invalid mode: %s" % bad_mode) |
| 171 | |
Alexey Izbyshev | a267056 | 2018-10-20 03:22:31 +0300 | [diff] [blame] | 172 | def _checkBufferSize(self, s): |
| 173 | try: |
| 174 | f = self.open(TESTFN, 'wb', s) |
| 175 | f.write(str(s).encode("ascii")) |
| 176 | f.close() |
| 177 | f.close() |
| 178 | f = self.open(TESTFN, 'rb', s) |
| 179 | d = int(f.read().decode("ascii")) |
| 180 | f.close() |
| 181 | f.close() |
| 182 | except OSError as msg: |
| 183 | self.fail('error setting buffer size %d: %s' % (s, str(msg))) |
| 184 | self.assertEqual(d, s) |
| 185 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 186 | def testSetBufferSize(self): |
| 187 | # make sure that explicitly setting the buffer size doesn't cause |
| 188 | # misbehaviour especially with repeated close() calls |
Alexey Izbyshev | a267056 | 2018-10-20 03:22:31 +0300 | [diff] [blame] | 189 | for s in (-1, 0, 512): |
| 190 | with support.check_no_warnings(self, |
| 191 | message='line buffering', |
| 192 | category=RuntimeWarning): |
| 193 | self._checkBufferSize(s) |
| 194 | |
| 195 | # test that attempts to use line buffering in binary mode cause |
| 196 | # a warning |
| 197 | with self.assertWarnsRegex(RuntimeWarning, 'line buffering'): |
| 198 | self._checkBufferSize(1) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 199 | |
| 200 | def testTruncateOnWindows(self): |
Guido van Rossum | 79b79ee | 2007-10-25 23:21:03 +0000 | [diff] [blame] | 201 | # SF bug <http://www.python.org/sf/801631> |
| 202 | # "file.truncate fault on windows" |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 203 | |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 204 | f = self.open(TESTFN, 'wb') |
Guido van Rossum | 79b79ee | 2007-10-25 23:21:03 +0000 | [diff] [blame] | 205 | |
| 206 | try: |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 207 | f.write(b'12345678901') # 11 bytes |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 208 | f.close() |
| 209 | |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 210 | f = self.open(TESTFN,'rb+') |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 211 | data = f.read(5) |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 212 | if data != b'12345': |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 213 | self.fail("Read on file opened for update failed %r" % data) |
| 214 | if f.tell() != 5: |
| 215 | self.fail("File pos after read wrong %d" % f.tell()) |
| 216 | |
| 217 | f.truncate() |
| 218 | if f.tell() != 5: |
| 219 | self.fail("File pos after ftruncate wrong %d" % f.tell()) |
| 220 | |
| 221 | f.close() |
| 222 | size = os.path.getsize(TESTFN) |
| 223 | if size != 5: |
| 224 | self.fail("File size after ftruncate wrong %d" % size) |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 225 | finally: |
Guido van Rossum | 79b79ee | 2007-10-25 23:21:03 +0000 | [diff] [blame] | 226 | f.close() |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 227 | |
| 228 | def testIteration(self): |
Thomas Wouters | 0e3f591 | 2006-08-11 14:57:12 +0000 | [diff] [blame] | 229 | # Test the complex interaction when mixing file-iteration and the |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 230 | # various read* methods. |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 231 | dataoffset = 16384 |
Guido van Rossum | e22905a | 2007-08-27 23:09:25 +0000 | [diff] [blame] | 232 | filler = b"ham\n" |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 233 | assert not dataoffset % len(filler), \ |
| 234 | "dataoffset must be multiple of len(filler)" |
| 235 | nchunks = dataoffset // len(filler) |
| 236 | testlines = [ |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 237 | b"spam, spam and eggs\n", |
| 238 | b"eggs, spam, ham and spam\n", |
| 239 | b"saussages, spam, spam and eggs\n", |
| 240 | b"spam, ham, spam and eggs\n", |
| 241 | b"spam, spam, spam, spam, spam, ham, spam\n", |
| 242 | b"wonderful spaaaaaam.\n" |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 243 | ] |
| 244 | methods = [("readline", ()), ("read", ()), ("readlines", ()), |
Guido van Rossum | 7165cb1 | 2007-07-10 06:54:34 +0000 | [diff] [blame] | 245 | ("readinto", (array("b", b" "*100),))] |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 246 | |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 247 | # Prepare the testfile |
| 248 | bag = self.open(TESTFN, "wb") |
| 249 | bag.write(filler * nchunks) |
| 250 | bag.writelines(testlines) |
| 251 | bag.close() |
| 252 | # Test for appropriate errors mixing read* and iteration |
| 253 | for methodname, args in methods: |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 254 | f = self.open(TESTFN, 'rb') |
Bradley Laney | 6b490b5 | 2018-07-10 05:46:44 -0400 | [diff] [blame] | 255 | self.assertEqual(next(f), filler) |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 256 | meth = getattr(f, methodname) |
| 257 | meth(*args) # This simply shouldn't fail |
Antoine Pitrou | a6e9502 | 2010-10-30 14:22:43 +0000 | [diff] [blame] | 258 | f.close() |
| 259 | |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 260 | # Test to see if harmless (by accident) mixing of read* and |
| 261 | # iteration still works. This depends on the size of the internal |
| 262 | # iteration buffer (currently 8192,) but we can test it in a |
| 263 | # flexible manner. Each line in the bag o' ham is 4 bytes |
| 264 | # ("h", "a", "m", "\n"), so 4096 lines of that should get us |
| 265 | # exactly on the buffer boundary for any power-of-2 buffersize |
| 266 | # between 4 and 16384 (inclusive). |
| 267 | f = self.open(TESTFN, 'rb') |
| 268 | for i in range(nchunks): |
| 269 | next(f) |
| 270 | testline = testlines.pop(0) |
| 271 | try: |
| 272 | line = f.readline() |
| 273 | except ValueError: |
| 274 | self.fail("readline() after next() with supposedly empty " |
| 275 | "iteration-buffer failed anyway") |
| 276 | if line != testline: |
| 277 | self.fail("readline() after next() with empty buffer " |
| 278 | "failed. Got %r, expected %r" % (line, testline)) |
| 279 | testline = testlines.pop(0) |
| 280 | buf = array("b", b"\x00" * len(testline)) |
| 281 | try: |
| 282 | f.readinto(buf) |
| 283 | except ValueError: |
| 284 | self.fail("readinto() after next() with supposedly empty " |
| 285 | "iteration-buffer failed anyway") |
| 286 | line = buf.tobytes() |
| 287 | if line != testline: |
| 288 | self.fail("readinto() after next() with empty buffer " |
| 289 | "failed. Got %r, expected %r" % (line, testline)) |
| 290 | |
| 291 | testline = testlines.pop(0) |
| 292 | try: |
| 293 | line = f.read(len(testline)) |
| 294 | except ValueError: |
| 295 | self.fail("read() after next() with supposedly empty " |
| 296 | "iteration-buffer failed anyway") |
| 297 | if line != testline: |
| 298 | self.fail("read() after next() with empty buffer " |
| 299 | "failed. Got %r, expected %r" % (line, testline)) |
| 300 | try: |
| 301 | lines = f.readlines() |
| 302 | except ValueError: |
| 303 | self.fail("readlines() after next() with supposedly empty " |
| 304 | "iteration-buffer failed anyway") |
| 305 | if lines != testlines: |
| 306 | self.fail("readlines() after next() with empty buffer " |
| 307 | "failed. Got %r, expected %r" % (line, testline)) |
| 308 | f.close() |
| 309 | |
| 310 | # Reading after iteration hit EOF shouldn't hurt either |
| 311 | f = self.open(TESTFN, 'rb') |
| 312 | try: |
| 313 | for line in f: |
| 314 | pass |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 315 | try: |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 316 | f.readline() |
| 317 | f.readinto(buf) |
| 318 | f.read() |
| 319 | f.readlines() |
| 320 | except ValueError: |
| 321 | self.fail("read* failed after next() consumed file") |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 322 | finally: |
Serhiy Storchaka | c2745d2 | 2018-06-05 19:55:41 +0300 | [diff] [blame] | 323 | f.close() |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 324 | |
Ezio Melotti | 3a03d2e | 2013-02-15 19:17:53 +0200 | [diff] [blame] | 325 | class COtherFileTests(OtherFileTests, unittest.TestCase): |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 326 | open = io.open |
| 327 | |
Ezio Melotti | 3a03d2e | 2013-02-15 19:17:53 +0200 | [diff] [blame] | 328 | class PyOtherFileTests(OtherFileTests, unittest.TestCase): |
Benjamin Peterson | 4fa88fa | 2009-03-04 00:14:51 +0000 | [diff] [blame] | 329 | open = staticmethod(pyio.open) |
| 330 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 331 | |
Thomas Wouters | 73e5a5b | 2006-06-08 15:35:45 +0000 | [diff] [blame] | 332 | if __name__ == '__main__': |
Ezio Melotti | 3a03d2e | 2013-02-15 19:17:53 +0200 | [diff] [blame] | 333 | unittest.main() |