| 1 |
import sys |
| 2 |
import os |
| 3 |
import unittest |
| 4 |
from array import array |
| 5 |
from weakref import proxy |
| 6 |
|
| 7 |
import io |
| 8 |
import _pyio as pyio |
| 9 |
|
| 10 |
from test.support import gc_collect |
| 11 |
from test.support.os_helper import TESTFN |
| 12 |
from test.support import os_helper |
| 13 |
from test.support import warnings_helper |
| 14 |
from collections import UserList |
| 15 |
|
| 16 |
class AutoFileTests: |
| 17 |
# file tests for which a test file is automatically set up |
| 18 |
|
| 19 |
def setUp(self): |
| 20 |
self.f = self.open(TESTFN, 'wb') |
| 21 |
|
| 22 |
def tearDown(self): |
| 23 |
if self.f: |
| 24 |
self.f.close() |
| 25 |
os_helper.unlink(TESTFN) |
| 26 |
|
| 27 |
def testWeakRefs(self): |
| 28 |
# verify weak references |
| 29 |
p = proxy(self.f) |
| 30 |
p.write(b'teststring') |
| 31 |
self.assertEqual(self.f.tell(), p.tell()) |
| 32 |
self.f.close() |
| 33 |
self.f = None |
| 34 |
gc_collect() # For PyPy or other GCs. |
| 35 |
self.assertRaises(ReferenceError, getattr, p, 'tell') |
| 36 |
|
| 37 |
def testAttributes(self): |
| 38 |
# verify expected attributes exist |
| 39 |
f = self.f |
| 40 |
f.name # merely shouldn't blow up |
| 41 |
f.mode # ditto |
| 42 |
f.closed # ditto |
| 43 |
|
| 44 |
def testReadinto(self): |
| 45 |
# verify readinto |
| 46 |
self.f.write(b'12') |
| 47 |
self.f.close() |
| 48 |
a = array('b', b'x'*10) |
| 49 |
self.f = self.open(TESTFN, 'rb') |
| 50 |
n = self.f.readinto(a) |
| 51 |
self.assertEqual(b'12', a.tobytes()[:n]) |
| 52 |
|
| 53 |
def testReadinto_text(self): |
| 54 |
# verify readinto refuses text files |
| 55 |
a = array('b', b'x'*10) |
| 56 |
self.f.close() |
| 57 |
self.f = self.open(TESTFN, encoding="utf-8") |
| 58 |
if hasattr(self.f, "readinto"): |
| 59 |
self.assertRaises(TypeError, self.f.readinto, a) |
| 60 |
|
| 61 |
def testWritelinesUserList(self): |
| 62 |
# verify writelines with instance sequence |
| 63 |
l = UserList([b'1', b'2']) |
| 64 |
self.f.writelines(l) |
| 65 |
self.f.close() |
| 66 |
self.f = self.open(TESTFN, 'rb') |
| 67 |
buf = self.f.read() |
| 68 |
self.assertEqual(buf, b'12') |
| 69 |
|
| 70 |
def testWritelinesIntegers(self): |
| 71 |
# verify writelines with integers |
| 72 |
self.assertRaises(TypeError, self.f.writelines, [1, 2, 3]) |
| 73 |
|
| 74 |
def testWritelinesIntegersUserList(self): |
| 75 |
# verify writelines with integers in UserList |
| 76 |
l = UserList([1,2,3]) |
| 77 |
self.assertRaises(TypeError, self.f.writelines, l) |
| 78 |
|
| 79 |
def testWritelinesNonString(self): |
| 80 |
# verify writelines with non-string object |
| 81 |
class NonString: |
| 82 |
pass |
| 83 |
|
| 84 |
self.assertRaises(TypeError, self.f.writelines, |
| 85 |
[NonString(), NonString()]) |
| 86 |
|
| 87 |
def testErrors(self): |
| 88 |
f = self.f |
| 89 |
self.assertEqual(f.name, TESTFN) |
| 90 |
self.assertFalse(f.isatty()) |
| 91 |
self.assertFalse(f.closed) |
| 92 |
|
| 93 |
if hasattr(f, "readinto"): |
| 94 |
self.assertRaises((OSError, TypeError), f.readinto, "") |
| 95 |
f.close() |
| 96 |
self.assertTrue(f.closed) |
| 97 |
|
| 98 |
def testMethods(self): |
| 99 |
methods = [('fileno', ()), |
| 100 |
('flush', ()), |
| 101 |
('isatty', ()), |
| 102 |
('__next__', ()), |
| 103 |
('read', ()), |
| 104 |
('write', (b"",)), |
| 105 |
('readline', ()), |
| 106 |
('readlines', ()), |
| 107 |
('seek', (0,)), |
| 108 |
('tell', ()), |
| 109 |
('write', (b"",)), |
| 110 |
('writelines', ([],)), |
| 111 |
('__iter__', ()), |
| 112 |
] |
| 113 |
methods.append(('truncate', ())) |
| 114 |
|
| 115 |
# __exit__ should close the file |
| 116 |
self.f.__exit__(None, None, None) |
| 117 |
self.assertTrue(self.f.closed) |
| 118 |
|
| 119 |
for methodname, args in methods: |
| 120 |
method = getattr(self.f, methodname) |
| 121 |
# should raise on closed file |
| 122 |
self.assertRaises(ValueError, method, *args) |
| 123 |
|
| 124 |
# file is closed, __exit__ shouldn't do anything |
| 125 |
self.assertEqual(self.f.__exit__(None, None, None), None) |
| 126 |
# it must also return None if an exception was given |
| 127 |
try: |
| 128 |
1/0 |
| 129 |
except ZeroDivisionError: |
| 130 |
self.assertEqual(self.f.__exit__(*sys.exc_info()), None) |
| 131 |
|
| 132 |
def testReadWhenWriting(self): |
| 133 |
self.assertRaises(OSError, self.f.read) |
| 134 |
|
| 135 |
class CAutoFileTests(AutoFileTests, unittest.TestCase): |
| 136 |
open = io.open |
| 137 |
|
| 138 |
class PyAutoFileTests(AutoFileTests, unittest.TestCase): |
| 139 |
open = staticmethod(pyio.open) |
| 140 |
|
| 141 |
|
| 142 |
class OtherFileTests: |
| 143 |
|
| 144 |
def tearDown(self): |
| 145 |
os_helper.unlink(TESTFN) |
| 146 |
|
| 147 |
def testModeStrings(self): |
| 148 |
# check invalid mode strings |
| 149 |
self.open(TESTFN, 'wb').close() |
| 150 |
for mode in ("", "aU", "wU+", "U+", "+U", "rU+"): |
| 151 |
try: |
| 152 |
f = self.open(TESTFN, mode) |
| 153 |
except ValueError: |
| 154 |
pass |
| 155 |
else: |
| 156 |
f.close() |
| 157 |
self.fail('%r is an invalid file mode' % mode) |
| 158 |
|
| 159 |
def testStdin(self): |
| 160 |
if sys.platform == 'osf1V5': |
| 161 |
# This causes the interpreter to exit on OSF1 v5.1. |
| 162 |
self.skipTest( |
| 163 |
' sys.stdin.seek(-1) may crash the interpreter on OSF1.' |
| 164 |
' Test manually.') |
| 165 |
|
| 166 |
if not sys.stdin.isatty(): |
| 167 |
# Issue 14853: stdin becomes seekable when redirected to a file |
| 168 |
self.skipTest('stdin must be a TTY in this test') |
| 169 |
|
| 170 |
with self.assertRaises((IOError, ValueError)): |
| 171 |
sys.stdin.seek(-1) |
| 172 |
with self.assertRaises((IOError, ValueError)): |
| 173 |
sys.stdin.truncate() |
| 174 |
|
| 175 |
def testBadModeArgument(self): |
| 176 |
# verify that we get a sensible error message for bad mode argument |
| 177 |
bad_mode = "qwerty" |
| 178 |
try: |
| 179 |
f = self.open(TESTFN, bad_mode) |
| 180 |
except ValueError as msg: |
| 181 |
if msg.args[0] != 0: |
| 182 |
s = str(msg) |
| 183 |
if TESTFN in s or bad_mode not in s: |
| 184 |
self.fail("bad error message for invalid mode: %s" % s) |
| 185 |
# if msg.args[0] == 0, we're probably on Windows where there may be |
| 186 |
# no obvious way to discover why open() failed. |
| 187 |
else: |
| 188 |
f.close() |
| 189 |
self.fail("no error for invalid mode: %s" % bad_mode) |
| 190 |
|
| 191 |
def _checkBufferSize(self, s): |
| 192 |
try: |
| 193 |
f = self.open(TESTFN, 'wb', s) |
| 194 |
f.write(str(s).encode("ascii")) |
| 195 |
f.close() |
| 196 |
f.close() |
| 197 |
f = self.open(TESTFN, 'rb', s) |
| 198 |
d = int(f.read().decode("ascii")) |
| 199 |
f.close() |
| 200 |
f.close() |
| 201 |
except OSError as msg: |
| 202 |
self.fail('error setting buffer size %d: %s' % (s, str(msg))) |
| 203 |
self.assertEqual(d, s) |
| 204 |
|
| 205 |
def testSetBufferSize(self): |
| 206 |
# make sure that explicitly setting the buffer size doesn't cause |
| 207 |
# misbehaviour especially with repeated close() calls |
| 208 |
for s in (-1, 0, 512): |
| 209 |
with warnings_helper.check_no_warnings(self, |
| 210 |
message='line buffering', |
| 211 |
category=RuntimeWarning): |
| 212 |
self._checkBufferSize(s) |
| 213 |
|
| 214 |
# test that attempts to use line buffering in binary mode cause |
| 215 |
# a warning |
| 216 |
with self.assertWarnsRegex(RuntimeWarning, 'line buffering'): |
| 217 |
self._checkBufferSize(1) |
| 218 |
|
| 219 |
def testDefaultBufferSize(self): |
| 220 |
with self.open(TESTFN, 'wb') as f: |
| 221 |
blksize = f.raw._blksize |
| 222 |
f.write(b"\0" * 5_000_000) |
| 223 |
|
| 224 |
with self.open(TESTFN, 'rb') as f: |
| 225 |
data = f.read1() |
| 226 |
expected_size = max(min(blksize, 8192 * 1024), io.DEFAULT_BUFFER_SIZE) |
| 227 |
self.assertEqual(len(data), expected_size) |
| 228 |
|
| 229 |
def testTruncateOnWindows(self): |
| 230 |
# SF bug <https://bugs.python.org/issue801631> |
| 231 |
# "file.truncate fault on windows" |
| 232 |
|
| 233 |
f = self.open(TESTFN, 'wb') |
| 234 |
|
| 235 |
try: |
| 236 |
f.write(b'12345678901') # 11 bytes |
| 237 |
f.close() |
| 238 |
|
| 239 |
f = self.open(TESTFN,'rb+') |
| 240 |
data = f.read(5) |
| 241 |
if data != b'12345': |
| 242 |
self.fail("Read on file opened for update failed %r" % data) |
| 243 |
if f.tell() != 5: |
| 244 |
self.fail("File pos after read wrong %d" % f.tell()) |
| 245 |
|
| 246 |
f.truncate() |
| 247 |
if f.tell() != 5: |
| 248 |
self.fail("File pos after ftruncate wrong %d" % f.tell()) |
| 249 |
|
| 250 |
f.close() |
| 251 |
size = os.path.getsize(TESTFN) |
| 252 |
if size != 5: |
| 253 |
self.fail("File size after ftruncate wrong %d" % size) |
| 254 |
finally: |
| 255 |
f.close() |
| 256 |
|
| 257 |
def testIteration(self): |
| 258 |
# Test the complex interaction when mixing file-iteration and the |
| 259 |
# various read* methods. |
| 260 |
dataoffset = 16384 |
| 261 |
filler = b"ham\n" |
| 262 |
assert not dataoffset % len(filler), \ |
| 263 |
"dataoffset must be multiple of len(filler)" |
| 264 |
nchunks = dataoffset // len(filler) |
| 265 |
testlines = [ |
| 266 |
b"spam, spam and eggs\n", |
| 267 |
b"eggs, spam, ham and spam\n", |
| 268 |
b"saussages, spam, spam and eggs\n", |
| 269 |
b"spam, ham, spam and eggs\n", |
| 270 |
b"spam, spam, spam, spam, spam, ham, spam\n", |
| 271 |
b"wonderful spaaaaaam.\n" |
| 272 |
] |
| 273 |
methods = [("readline", ()), ("read", ()), ("readlines", ()), |
| 274 |
("readinto", (array("b", b" "*100),))] |
| 275 |
|
| 276 |
# Prepare the testfile |
| 277 |
bag = self.open(TESTFN, "wb") |
| 278 |
bag.write(filler * nchunks) |
| 279 |
bag.writelines(testlines) |
| 280 |
bag.close() |
| 281 |
# Test for appropriate errors mixing read* and iteration |
| 282 |
for methodname, args in methods: |
| 283 |
f = self.open(TESTFN, 'rb') |
| 284 |
self.assertEqual(next(f), filler) |
| 285 |
meth = getattr(f, methodname) |
| 286 |
meth(*args) # This simply shouldn't fail |
| 287 |
f.close() |
| 288 |
|
| 289 |
# Test to see if harmless (by accident) mixing of read* and |
| 290 |
# iteration still works. This depends on the size of the internal |
| 291 |
# iteration buffer (currently 8192,) but we can test it in a |
| 292 |
# flexible manner. Each line in the bag o' ham is 4 bytes |
| 293 |
# ("h", "a", "m", "\n"), so 4096 lines of that should get us |
| 294 |
# exactly on the buffer boundary for any power-of-2 buffersize |
| 295 |
# between 4 and 16384 (inclusive). |
| 296 |
f = self.open(TESTFN, 'rb') |
| 297 |
for i in range(nchunks): |
| 298 |
next(f) |
| 299 |
testline = testlines.pop(0) |
| 300 |
try: |
| 301 |
line = f.readline() |
| 302 |
except ValueError: |
| 303 |
self.fail("readline() after next() with supposedly empty " |
| 304 |
"iteration-buffer failed anyway") |
| 305 |
if line != testline: |
| 306 |
self.fail("readline() after next() with empty buffer " |
| 307 |
"failed. Got %r, expected %r" % (line, testline)) |
| 308 |
testline = testlines.pop(0) |
| 309 |
buf = array("b", b"\x00" * len(testline)) |
| 310 |
try: |
| 311 |
f.readinto(buf) |
| 312 |
except ValueError: |
| 313 |
self.fail("readinto() after next() with supposedly empty " |
| 314 |
"iteration-buffer failed anyway") |
| 315 |
line = buf.tobytes() |
| 316 |
if line != testline: |
| 317 |
self.fail("readinto() after next() with empty buffer " |
| 318 |
"failed. Got %r, expected %r" % (line, testline)) |
| 319 |
|
| 320 |
testline = testlines.pop(0) |
| 321 |
try: |
| 322 |
line = f.read(len(testline)) |
| 323 |
except ValueError: |
| 324 |
self.fail("read() after next() with supposedly empty " |
| 325 |
"iteration-buffer failed anyway") |
| 326 |
if line != testline: |
| 327 |
self.fail("read() after next() with empty buffer " |
| 328 |
"failed. Got %r, expected %r" % (line, testline)) |
| 329 |
try: |
| 330 |
lines = f.readlines() |
| 331 |
except ValueError: |
| 332 |
self.fail("readlines() after next() with supposedly empty " |
| 333 |
"iteration-buffer failed anyway") |
| 334 |
if lines != testlines: |
| 335 |
self.fail("readlines() after next() with empty buffer " |
| 336 |
"failed. Got %r, expected %r" % (line, testline)) |
| 337 |
f.close() |
| 338 |
|
| 339 |
# Reading after iteration hit EOF shouldn't hurt either |
| 340 |
f = self.open(TESTFN, 'rb') |
| 341 |
try: |
| 342 |
for line in f: |
| 343 |
pass |
| 344 |
try: |
| 345 |
f.readline() |
| 346 |
f.readinto(buf) |
| 347 |
f.read() |
| 348 |
f.readlines() |
| 349 |
except ValueError: |
| 350 |
self.fail("read* failed after next() consumed file") |
| 351 |
finally: |
| 352 |
f.close() |
| 353 |
|
| 354 |
class COtherFileTests(OtherFileTests, unittest.TestCase): |
| 355 |
open = io.open |
| 356 |
|
| 357 |
class PyOtherFileTests(OtherFileTests, unittest.TestCase): |
| 358 |
open = staticmethod(pyio.open) |
| 359 |
|
| 360 |
|
| 361 |
if __name__ == '__main__': |
| 362 |
unittest.main() |