Debian Codegraph @

Lib/test/test_memoryio.py

raw
1 """Unit tests for memory-based file-like objects.
2 StringIO -- for unicode strings
3 BytesIO -- for bytes
4 """
5
6 import unittest
7 from test import support
8
9 import gc
10 import io
11 import _pyio as pyio
12 import pickle
13 import sys
14 import weakref
15
16 class IntLike:
17 def __init__(self, num):
18 self._num = num
19 def __index__(self):
20 return self._num
21 __int__ = __index__
22
23 class MemorySeekTestMixin:
24
25 def testInit(self):
26 buf = self.buftype("1234567890")
27 bytesIo = self.ioclass(buf)
28
29 def testRead(self):
30 buf = self.buftype("1234567890")
31 bytesIo = self.ioclass(buf)
32
33 self.assertEqual(buf[:1], bytesIo.read(1))
34 self.assertEqual(buf[1:5], bytesIo.read(4))
35 self.assertEqual(buf[5:], bytesIo.read(900))
36 self.assertEqual(self.EOF, bytesIo.read())
37
38 def testReadNoArgs(self):
39 buf = self.buftype("1234567890")
40 bytesIo = self.ioclass(buf)
41
42 self.assertEqual(buf, bytesIo.read())
43 self.assertEqual(self.EOF, bytesIo.read())
44
45 def testSeek(self):
46 buf = self.buftype("1234567890")
47 bytesIo = self.ioclass(buf)
48
49 bytesIo.read(5)
50 bytesIo.seek(0)
51 self.assertEqual(buf, bytesIo.read())
52
53 bytesIo.seek(3)
54 self.assertEqual(buf[3:], bytesIo.read())
55 self.assertRaises(TypeError, bytesIo.seek, 0.0)
56
57 self.assertEqual(sys.maxsize, bytesIo.seek(sys.maxsize))
58 self.assertEqual(self.EOF, bytesIo.read(4))
59
60 self.assertEqual(sys.maxsize - 2, bytesIo.seek(sys.maxsize - 2))
61 self.assertEqual(self.EOF, bytesIo.read(4))
62
63 def testTell(self):
64 buf = self.buftype("1234567890")
65 bytesIo = self.ioclass(buf)
66
67 self.assertEqual(0, bytesIo.tell())
68 bytesIo.seek(5)
69 self.assertEqual(5, bytesIo.tell())
70 bytesIo.seek(10000)
71 self.assertEqual(10000, bytesIo.tell())
72
73
74 class MemoryTestMixin:
75
76 def test_detach(self):
77 buf = self.ioclass()
78 self.assertRaises(self.UnsupportedOperation, buf.detach)
79
80 def write_ops(self, f, t):
81 self.assertEqual(f.write(t("blah.")), 5)
82 self.assertEqual(f.seek(0), 0)
83 self.assertEqual(f.write(t("Hello.")), 6)
84 self.assertEqual(f.tell(), 6)
85 self.assertEqual(f.seek(5), 5)
86 self.assertEqual(f.tell(), 5)
87 self.assertEqual(f.write(t(" world\n\n\n")), 9)
88 self.assertEqual(f.seek(0), 0)
89 self.assertEqual(f.write(t("h")), 1)
90 self.assertEqual(f.truncate(12), 12)
91 self.assertEqual(f.tell(), 1)
92
93 def test_write(self):
94 buf = self.buftype("hello world\n")
95 memio = self.ioclass(buf)
96
97 self.write_ops(memio, self.buftype)
98 self.assertEqual(memio.getvalue(), buf)
99 memio = self.ioclass()
100 self.write_ops(memio, self.buftype)
101 self.assertEqual(memio.getvalue(), buf)
102 self.assertRaises(TypeError, memio.write, None)
103 memio.close()
104 self.assertRaises(ValueError, memio.write, self.buftype(""))
105
106 def test_writelines(self):
107 buf = self.buftype("1234567890")
108 memio = self.ioclass()
109
110 self.assertEqual(memio.writelines([buf] * 100), None)
111 self.assertEqual(memio.getvalue(), buf * 100)
112 memio.writelines([])
113 self.assertEqual(memio.getvalue(), buf * 100)
114 memio = self.ioclass()
115 self.assertRaises(TypeError, memio.writelines, [buf] + [1])
116 self.assertEqual(memio.getvalue(), buf)
117 self.assertRaises(TypeError, memio.writelines, None)
118 memio.close()
119 self.assertRaises(ValueError, memio.writelines, [])
120
121 def test_writelines_error(self):
122 memio = self.ioclass()
123 def error_gen():
124 yield self.buftype('spam')
125 raise KeyboardInterrupt
126
127 self.assertRaises(KeyboardInterrupt, memio.writelines, error_gen())
128
129 def test_truncate(self):
130 buf = self.buftype("1234567890")
131 memio = self.ioclass(buf)
132
133 self.assertRaises(ValueError, memio.truncate, -1)
134 self.assertRaises(ValueError, memio.truncate, IntLike(-1))
135 memio.seek(6)
136 self.assertEqual(memio.truncate(IntLike(8)), 8)
137 self.assertEqual(memio.getvalue(), buf[:8])
138 self.assertEqual(memio.truncate(), 6)
139 self.assertEqual(memio.getvalue(), buf[:6])
140 self.assertEqual(memio.truncate(4), 4)
141 self.assertEqual(memio.getvalue(), buf[:4])
142 self.assertEqual(memio.tell(), 6)
143 memio.seek(0, 2)
144 memio.write(buf)
145 self.assertEqual(memio.getvalue(), buf[:4] + buf)
146 pos = memio.tell()
147 self.assertEqual(memio.truncate(None), pos)
148 self.assertEqual(memio.tell(), pos)
149 self.assertRaises(TypeError, memio.truncate, '0')
150 memio.close()
151 self.assertRaises(ValueError, memio.truncate, 0)
152 self.assertRaises(ValueError, memio.truncate, IntLike(0))
153
154 def test_init(self):
155 buf = self.buftype("1234567890")
156 memio = self.ioclass(buf)
157 self.assertEqual(memio.getvalue(), buf)
158 memio = self.ioclass(None)
159 self.assertEqual(memio.getvalue(), self.EOF)
160 memio.__init__(buf * 2)
161 self.assertEqual(memio.getvalue(), buf * 2)
162 memio.__init__(buf)
163 self.assertEqual(memio.getvalue(), buf)
164 self.assertRaises(TypeError, memio.__init__, [])
165
166 def test_read(self):
167 buf = self.buftype("1234567890")
168 memio = self.ioclass(buf)
169
170 self.assertEqual(memio.read(0), self.EOF)
171 self.assertEqual(memio.read(1), buf[:1])
172 self.assertEqual(memio.read(4), buf[1:5])
173 self.assertEqual(memio.read(900), buf[5:])
174 self.assertEqual(memio.read(), self.EOF)
175 memio.seek(0)
176 self.assertEqual(memio.read(IntLike(0)), self.EOF)
177 self.assertEqual(memio.read(IntLike(1)), buf[:1])
178 self.assertEqual(memio.read(IntLike(4)), buf[1:5])
179 self.assertEqual(memio.read(IntLike(900)), buf[5:])
180 memio.seek(0)
181 self.assertEqual(memio.read(), buf)
182 self.assertEqual(memio.read(), self.EOF)
183 self.assertEqual(memio.tell(), 10)
184 memio.seek(0)
185 self.assertEqual(memio.read(-1), buf)
186 memio.seek(0)
187 self.assertEqual(memio.read(IntLike(-1)), buf)
188 memio.seek(0)
189 self.assertEqual(type(memio.read()), type(buf))
190 memio.seek(100)
191 self.assertEqual(type(memio.read()), type(buf))
192 memio.seek(0)
193 self.assertEqual(memio.read(None), buf)
194 self.assertRaises(TypeError, memio.read, '')
195 memio.seek(len(buf) + 1)
196 self.assertEqual(memio.read(1), self.EOF)
197 memio.seek(len(buf) + 1)
198 self.assertEqual(memio.read(IntLike(1)), self.EOF)
199 memio.seek(len(buf) + 1)
200 self.assertEqual(memio.read(), self.EOF)
201 memio.close()
202 self.assertRaises(ValueError, memio.read)
203
204 def test_readline(self):
205 buf = self.buftype("1234567890\n")
206 memio = self.ioclass(buf * 2)
207
208 self.assertEqual(memio.readline(0), self.EOF)
209 self.assertEqual(memio.readline(IntLike(0)), self.EOF)
210 self.assertEqual(memio.readline(), buf)
211 self.assertEqual(memio.readline(), buf)
212 self.assertEqual(memio.readline(), self.EOF)
213 memio.seek(0)
214 self.assertEqual(memio.readline(5), buf[:5])
215 self.assertEqual(memio.readline(5), buf[5:10])
216 self.assertEqual(memio.readline(5), buf[10:15])
217 memio.seek(0)
218 self.assertEqual(memio.readline(IntLike(5)), buf[:5])
219 self.assertEqual(memio.readline(IntLike(5)), buf[5:10])
220 self.assertEqual(memio.readline(IntLike(5)), buf[10:15])
221 memio.seek(0)
222 self.assertEqual(memio.readline(-1), buf)
223 memio.seek(0)
224 self.assertEqual(memio.readline(IntLike(-1)), buf)
225 memio.seek(0)
226 self.assertEqual(memio.readline(0), self.EOF)
227 self.assertEqual(memio.readline(IntLike(0)), self.EOF)
228 # Issue #24989: Buffer overread
229 memio.seek(len(buf) * 2 + 1)
230 self.assertEqual(memio.readline(), self.EOF)
231
232 buf = self.buftype("1234567890\n")
233 memio = self.ioclass((buf * 3)[:-1])
234 self.assertEqual(memio.readline(), buf)
235 self.assertEqual(memio.readline(), buf)
236 self.assertEqual(memio.readline(), buf[:-1])
237 self.assertEqual(memio.readline(), self.EOF)
238 memio.seek(0)
239 self.assertEqual(type(memio.readline()), type(buf))
240 self.assertEqual(memio.readline(), buf)
241 self.assertRaises(TypeError, memio.readline, '')
242 memio.close()
243 self.assertRaises(ValueError, memio.readline)
244
245 def test_readlines(self):
246 buf = self.buftype("1234567890\n")
247 memio = self.ioclass(buf * 10)
248
249 self.assertEqual(memio.readlines(), [buf] * 10)
250 memio.seek(5)
251 self.assertEqual(memio.readlines(), [buf[5:]] + [buf] * 9)
252 memio.seek(0)
253 self.assertEqual(memio.readlines(15), [buf] * 2)
254 memio.seek(0)
255 self.assertEqual(memio.readlines(-1), [buf] * 10)
256 memio.seek(0)
257 self.assertEqual(memio.readlines(0), [buf] * 10)
258 memio.seek(0)
259 self.assertEqual(type(memio.readlines()[0]), type(buf))
260 memio.seek(0)
261 self.assertEqual(memio.readlines(None), [buf] * 10)
262 self.assertRaises(TypeError, memio.readlines, '')
263 # Issue #24989: Buffer overread
264 memio.seek(len(buf) * 10 + 1)
265 self.assertEqual(memio.readlines(), [])
266 memio.close()
267 self.assertRaises(ValueError, memio.readlines)
268
269 def test_iterator(self):
270 buf = self.buftype("1234567890\n")
271 memio = self.ioclass(buf * 10)
272
273 self.assertEqual(iter(memio), memio)
274 self.assertHasAttr(memio, '__iter__')
275 self.assertHasAttr(memio, '__next__')
276 i = 0
277 for line in memio:
278 self.assertEqual(line, buf)
279 i += 1
280 self.assertEqual(i, 10)
281 memio.seek(0)
282 i = 0
283 for line in memio:
284 self.assertEqual(line, buf)
285 i += 1
286 self.assertEqual(i, 10)
287 # Issue #24989: Buffer overread
288 memio.seek(len(buf) * 10 + 1)
289 self.assertEqual(list(memio), [])
290 memio = self.ioclass(buf * 2)
291 memio.close()
292 self.assertRaises(ValueError, memio.__next__)
293
294 def test_getvalue(self):
295 buf = self.buftype("1234567890")
296 memio = self.ioclass(buf)
297
298 self.assertEqual(memio.getvalue(), buf)
299 memio.read()
300 self.assertEqual(memio.getvalue(), buf)
301 self.assertEqual(type(memio.getvalue()), type(buf))
302 memio = self.ioclass(buf * 1000)
303 self.assertEqual(memio.getvalue()[-3:], self.buftype("890"))
304 memio = self.ioclass(buf)
305 memio.close()
306 self.assertRaises(ValueError, memio.getvalue)
307
308 def test_seek(self):
309 buf = self.buftype("1234567890")
310 memio = self.ioclass(buf)
311
312 memio.read(5)
313 self.assertRaises(ValueError, memio.seek, -1)
314 self.assertRaises(ValueError, memio.seek, 1, -1)
315 self.assertRaises(ValueError, memio.seek, 1, 3)
316 self.assertEqual(memio.seek(0), 0)
317 self.assertEqual(memio.seek(0, 0), 0)
318 self.assertEqual(memio.read(), buf)
319 self.assertEqual(memio.seek(3), 3)
320 self.assertEqual(memio.seek(0, 1), 3)
321 self.assertEqual(memio.read(), buf[3:])
322 self.assertEqual(memio.seek(len(buf)), len(buf))
323 self.assertEqual(memio.read(), self.EOF)
324 memio.seek(len(buf) + 1)
325 self.assertEqual(memio.read(), self.EOF)
326 self.assertEqual(memio.seek(0, 2), len(buf))
327 self.assertEqual(memio.read(), self.EOF)
328 memio.close()
329 self.assertRaises(ValueError, memio.seek, 0)
330
331 def test_overseek(self):
332 buf = self.buftype("1234567890")
333 memio = self.ioclass(buf)
334
335 self.assertEqual(memio.seek(len(buf) + 1), 11)
336 self.assertEqual(memio.read(), self.EOF)
337 self.assertEqual(memio.tell(), 11)
338 self.assertEqual(memio.getvalue(), buf)
339 memio.write(self.EOF)
340 self.assertEqual(memio.getvalue(), buf)
341 memio.write(buf)
342 self.assertEqual(memio.getvalue(), buf + self.buftype('\0') + buf)
343
344 def test_tell(self):
345 buf = self.buftype("1234567890")
346 memio = self.ioclass(buf)
347
348 self.assertEqual(memio.tell(), 0)
349 memio.seek(5)
350 self.assertEqual(memio.tell(), 5)
351 memio.seek(10000)
352 self.assertEqual(memio.tell(), 10000)
353 memio.close()
354 self.assertRaises(ValueError, memio.tell)
355
356 def test_flush(self):
357 buf = self.buftype("1234567890")
358 memio = self.ioclass(buf)
359
360 self.assertEqual(memio.flush(), None)
361
362 def test_flags(self):
363 memio = self.ioclass()
364
365 self.assertEqual(memio.writable(), True)
366 self.assertEqual(memio.readable(), True)
367 self.assertEqual(memio.seekable(), True)
368 self.assertEqual(memio.isatty(), False)
369 self.assertEqual(memio.closed, False)
370 memio.close()
371 self.assertRaises(ValueError, memio.writable)
372 self.assertRaises(ValueError, memio.readable)
373 self.assertRaises(ValueError, memio.seekable)
374 self.assertRaises(ValueError, memio.isatty)
375 self.assertEqual(memio.closed, True)
376
377 def test_subclassing(self):
378 buf = self.buftype("1234567890")
379 def test1():
380 class MemIO(self.ioclass):
381 pass
382 m = MemIO(buf)
383 return m.getvalue()
384 def test2():
385 class MemIO(self.ioclass):
386 def __init__(me, a, b):
387 self.ioclass.__init__(me, a)
388 m = MemIO(buf, None)
389 return m.getvalue()
390 self.assertEqual(test1(), buf)
391 self.assertEqual(test2(), buf)
392
393 def test_instance_dict_leak(self):
394 # Test case for issue #6242.
395 # This will be caught by regrtest.py -R if this leak.
396 for _ in range(100):
397 memio = self.ioclass()
398 memio.foo = 1
399
400 def test_pickling(self):
401 buf = self.buftype("1234567890")
402 memio = self.ioclass(buf)
403 memio.foo = 42
404 memio.seek(2)
405
406 class PickleTestMemIO(self.ioclass):
407 def __init__(me, initvalue, foo):
408 self.ioclass.__init__(me, initvalue)
409 me.foo = foo
410 # __getnewargs__ is undefined on purpose. This checks that PEP 307
411 # is used to provide pickling support.
412
413 # Pickle expects the class to be on the module level. Here we use a
414 # little hack to allow the PickleTestMemIO class to derive from
415 # self.ioclass without having to define all combinations explicitly on
416 # the module-level.
417 import __main__
418 PickleTestMemIO.__module__ = '__main__'
419 PickleTestMemIO.__qualname__ = PickleTestMemIO.__name__
420 __main__.PickleTestMemIO = PickleTestMemIO
421 submemio = PickleTestMemIO(buf, 80)
422 submemio.seek(2)
423
424 # We only support pickle protocol 2 and onward since we use extended
425 # __reduce__ API of PEP 307 to provide pickling support.
426 for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
427 for obj in (memio, submemio):
428 obj2 = pickle.loads(pickle.dumps(obj, protocol=proto))
429 self.assertEqual(obj.getvalue(), obj2.getvalue())
430 self.assertEqual(obj.__class__, obj2.__class__)
431 self.assertEqual(obj.foo, obj2.foo)
432 self.assertEqual(obj.tell(), obj2.tell())
433 obj2.close()
434 self.assertRaises(ValueError, pickle.dumps, obj2, proto)
435 del __main__.PickleTestMemIO
436
437
438 class PyBytesIOTest(MemoryTestMixin, MemorySeekTestMixin, unittest.TestCase):
439 # Test _pyio.BytesIO; class also inherited for testing C implementation
440
441 UnsupportedOperation = pyio.UnsupportedOperation
442
443 @staticmethod
444 def buftype(s):
445 return s.encode("ascii")
446 ioclass = pyio.BytesIO
447 EOF = b""
448
449 def test_getbuffer(self):
450 memio = self.ioclass(b"1234567890")
451 buf = memio.getbuffer()
452 self.assertEqual(bytes(buf), b"1234567890")
453 memio.seek(5)
454 buf = memio.getbuffer()
455 self.assertEqual(bytes(buf), b"1234567890")
456 # Trying to change the size of the BytesIO while a buffer is exported
457 # raises a BufferError.
458 self.assertRaises(BufferError, memio.write, b'x' * 100)
459 self.assertRaises(BufferError, memio.truncate)
460 self.assertRaises(BufferError, memio.close)
461 self.assertFalse(memio.closed)
462 # Mutating the buffer updates the BytesIO
463 buf[3:6] = b"abc"
464 self.assertEqual(bytes(buf), b"123abc7890")
465 self.assertEqual(memio.getvalue(), b"123abc7890")
466 # After the buffer gets released, we can resize and close the BytesIO
467 # again
468 del buf
469 support.gc_collect()
470 memio.truncate()
471 memio.close()
472 self.assertRaises(ValueError, memio.getbuffer)
473
474 def test_getbuffer_empty(self):
475 memio = self.ioclass()
476 buf = memio.getbuffer()
477 self.assertEqual(bytes(buf), b"")
478 # Trying to change the size of the BytesIO while a buffer is exported
479 # raises a BufferError.
480 self.assertRaises(BufferError, memio.write, b'x')
481 buf2 = memio.getbuffer()
482 self.assertRaises(BufferError, memio.write, b'x')
483 buf.release()
484 self.assertRaises(BufferError, memio.write, b'x')
485 buf2.release()
486 memio.write(b'x')
487
488 def test_getbuffer_gc_collect(self):
489 memio = self.ioclass(b"1234567890")
490 buf = memio.getbuffer()
491 memiowr = weakref.ref(memio)
492 bufwr = weakref.ref(buf)
493 # Create a reference loop.
494 a = [buf]
495 a.append(a)
496 # The Python implementation emits an unraisable exception.
497 with support.catch_unraisable_exception():
498 del memio
499 del buf
500 del a
501 # The C implementation emits an unraisable exception.
502 with support.catch_unraisable_exception():
503 gc.collect()
504 self.assertIsNone(memiowr())
505 self.assertIsNone(bufwr())
506
507 def test_read1(self):
508 buf = self.buftype("1234567890")
509 self.assertEqual(self.ioclass(buf).read1(), buf)
510 self.assertEqual(self.ioclass(buf).read1(-1), buf)
511
512 def test_readinto(self):
513 buf = self.buftype("1234567890")
514 memio = self.ioclass(buf)
515
516 b = bytearray(b"hello")
517 self.assertEqual(memio.readinto(b), 5)
518 self.assertEqual(b, b"12345")
519 self.assertEqual(memio.readinto(b), 5)
520 self.assertEqual(b, b"67890")
521 self.assertEqual(memio.readinto(b), 0)
522 self.assertEqual(b, b"67890")
523 b = bytearray(b"hello world")
524 memio.seek(0)
525 self.assertEqual(memio.readinto(b), 10)
526 self.assertEqual(b, b"1234567890d")
527 b = bytearray(b"")
528 memio.seek(0)
529 self.assertEqual(memio.readinto(b), 0)
530 self.assertEqual(b, b"")
531 self.assertRaises(TypeError, memio.readinto, '')
532 import array
533 a = array.array('b', b"hello world")
534 memio = self.ioclass(buf)
535 memio.readinto(a)
536 self.assertEqual(a.tobytes(), b"1234567890d")
537 memio.close()
538 self.assertRaises(ValueError, memio.readinto, b)
539 memio = self.ioclass(b"123")
540 b = bytearray()
541 memio.seek(42)
542 memio.readinto(b)
543 self.assertEqual(b, b"")
544
545 def test_relative_seek(self):
546 buf = self.buftype("1234567890")
547 memio = self.ioclass(buf)
548
549 self.assertEqual(memio.seek(-1, 1), 0)
550 self.assertEqual(memio.seek(3, 1), 3)
551 self.assertEqual(memio.seek(-4, 1), 0)
552 self.assertEqual(memio.seek(-1, 2), 9)
553 self.assertEqual(memio.seek(1, 1), 10)
554 self.assertEqual(memio.seek(1, 2), 11)
555 memio.seek(-3, 2)
556 self.assertEqual(memio.read(), buf[-3:])
557 memio.seek(0)
558 memio.seek(1, 1)
559 self.assertEqual(memio.read(), buf[1:])
560
561 def test_issue141311(self):
562 memio = self.ioclass()
563 # Seek allows PY_SSIZE_T_MAX, read should handle that.
564 # Past end of buffer read should always return 0 (EOF).
565 self.assertEqual(sys.maxsize, memio.seek(sys.maxsize))
566 buf = bytearray(2)
567 self.assertEqual(0, memio.readinto(buf))
568
569 def test_unicode(self):
570 memio = self.ioclass()
571
572 self.assertRaises(TypeError, self.ioclass, "1234567890")
573 self.assertRaises(TypeError, memio.write, "1234567890")
574 self.assertRaises(TypeError, memio.writelines, ["1234567890"])
575
576 def test_bytes_array(self):
577 buf = b"1234567890"
578 import array
579 a = array.array('b', list(buf))
580 memio = self.ioclass(a)
581 self.assertEqual(memio.getvalue(), buf)
582 self.assertEqual(memio.write(a), 10)
583 self.assertEqual(memio.getvalue(), buf)
584
585 def test_issue5449(self):
586 buf = self.buftype("1234567890")
587 self.ioclass(initial_bytes=buf)
588 self.assertRaises(TypeError, self.ioclass, buf, foo=None)
589
590 def test_write_concurrent_close(self):
591 class B:
592 def __buffer__(self, flags):
593 memio.close()
594 return memoryview(b"A")
595
596 memio = self.ioclass()
597 self.assertRaises(ValueError, memio.write, B())
598
599 # Prevent crashes when memio.write() or memio.writelines()
600 # concurrently mutates (e.g., closes or exports) 'memio'.
601 # See: https://github.com/python/cpython/issues/143378.
602
603 def test_writelines_concurrent_close(self):
604 class B:
605 def __buffer__(self, flags):
606 memio.close()
607 return memoryview(b"A")
608
609 memio = self.ioclass()
610 self.assertRaises(ValueError, memio.writelines, [B()])
611
612 def test_write_concurrent_export(self):
613 class B:
614 buf = None
615 def __buffer__(self, flags):
616 self.buf = memio.getbuffer()
617 return memoryview(b"A")
618
619 memio = self.ioclass()
620 self.assertRaises(BufferError, memio.write, B())
621
622 def test_writelines_concurrent_export(self):
623 class B:
624 buf = None
625 def __buffer__(self, flags):
626 self.buf = memio.getbuffer()
627 return memoryview(b"A")
628
629 memio = self.ioclass()
630 self.assertRaises(BufferError, memio.writelines, [B()])
631
632 def test_write_mutating_buffer(self):
633 # Test that buffer is exported only once during write().
634 # See: https://github.com/python/cpython/issues/143602.
635 class B:
636 count = 0
637 def __buffer__(self, flags):
638 self.count += 1
639 if self.count == 1:
640 return memoryview(b"AAA")
641 else:
642 return memoryview(b"BBBBBBBBB")
643
644 memio = self.ioclass(b'0123456789')
645 memio.seek(2)
646 b = B()
647 n = memio.write(b)
648
649 self.assertEqual(b.count, 1)
650 self.assertEqual(n, 3)
651 self.assertEqual(memio.getvalue(), b"01AAA56789")
652 self.assertEqual(memio.tell(), 5)
653
654
655 class TextIOTestMixin:
656
657 def test_newlines_property(self):
658 memio = self.ioclass(newline=None)
659 # The C StringIO decodes newlines in write() calls, but the Python
660 # implementation only does when reading. This function forces them to
661 # be decoded for testing.
662 def force_decode():
663 memio.seek(0)
664 memio.read()
665 self.assertEqual(memio.newlines, None)
666 memio.write("a\n")
667 force_decode()
668 self.assertEqual(memio.newlines, "\n")
669 memio.write("b\r\n")
670 force_decode()
671 self.assertEqual(memio.newlines, ("\n", "\r\n"))
672 memio.write("c\rd")
673 force_decode()
674 self.assertEqual(memio.newlines, ("\r", "\n", "\r\n"))
675
676 def test_relative_seek(self):
677 memio = self.ioclass()
678
679 self.assertRaises(OSError, memio.seek, -1, 1)
680 self.assertRaises(OSError, memio.seek, 3, 1)
681 self.assertRaises(OSError, memio.seek, -3, 1)
682 self.assertRaises(OSError, memio.seek, -1, 2)
683 self.assertRaises(OSError, memio.seek, 1, 1)
684 self.assertRaises(OSError, memio.seek, 1, 2)
685
686 def test_textio_properties(self):
687 memio = self.ioclass()
688
689 # These are just dummy values but we nevertheless check them for fear
690 # of unexpected breakage.
691 self.assertIsNone(memio.encoding)
692 self.assertIsNone(memio.errors)
693 self.assertFalse(memio.line_buffering)
694
695 def test_newline_default(self):
696 memio = self.ioclass("a\nb\r\nc\rd")
697 self.assertEqual(list(memio), ["a\n", "b\r\n", "c\rd"])
698 self.assertEqual(memio.getvalue(), "a\nb\r\nc\rd")
699
700 memio = self.ioclass()
701 self.assertEqual(memio.write("a\nb\r\nc\rd"), 8)
702 memio.seek(0)
703 self.assertEqual(list(memio), ["a\n", "b\r\n", "c\rd"])
704 self.assertEqual(memio.getvalue(), "a\nb\r\nc\rd")
705
706 def test_newline_none(self):
707 # newline=None
708 memio = self.ioclass("a\nb\r\nc\rd", newline=None)
709 self.assertEqual(list(memio), ["a\n", "b\n", "c\n", "d"])
710 memio.seek(0)
711 self.assertEqual(memio.read(1), "a")
712 self.assertEqual(memio.read(2), "\nb")
713 self.assertEqual(memio.read(2), "\nc")
714 self.assertEqual(memio.read(1), "\n")
715 self.assertEqual(memio.getvalue(), "a\nb\nc\nd")
716
717 memio = self.ioclass(newline=None)
718 self.assertEqual(2, memio.write("a\n"))
719 self.assertEqual(3, memio.write("b\r\n"))
720 self.assertEqual(3, memio.write("c\rd"))
721 memio.seek(0)
722 self.assertEqual(memio.read(), "a\nb\nc\nd")
723 self.assertEqual(memio.getvalue(), "a\nb\nc\nd")
724
725 memio = self.ioclass("a\r\nb", newline=None)
726 self.assertEqual(memio.read(3), "a\nb")
727
728 def test_newline_empty(self):
729 # newline=""
730 memio = self.ioclass("a\nb\r\nc\rd", newline="")
731 self.assertEqual(list(memio), ["a\n", "b\r\n", "c\r", "d"])
732 memio.seek(0)
733 self.assertEqual(memio.read(4), "a\nb\r")
734 self.assertEqual(memio.read(2), "\nc")
735 self.assertEqual(memio.read(1), "\r")
736 self.assertEqual(memio.getvalue(), "a\nb\r\nc\rd")
737
738 memio = self.ioclass(newline="")
739 self.assertEqual(2, memio.write("a\n"))
740 self.assertEqual(2, memio.write("b\r"))
741 self.assertEqual(2, memio.write("\nc"))
742 self.assertEqual(2, memio.write("\rd"))
743 memio.seek(0)
744 self.assertEqual(list(memio), ["a\n", "b\r\n", "c\r", "d"])
745 self.assertEqual(memio.getvalue(), "a\nb\r\nc\rd")
746
747 def test_newline_lf(self):
748 # newline="\n"
749 memio = self.ioclass("a\nb\r\nc\rd", newline="\n")
750 self.assertEqual(list(memio), ["a\n", "b\r\n", "c\rd"])
751 self.assertEqual(memio.getvalue(), "a\nb\r\nc\rd")
752
753 memio = self.ioclass(newline="\n")
754 self.assertEqual(memio.write("a\nb\r\nc\rd"), 8)
755 memio.seek(0)
756 self.assertEqual(list(memio), ["a\n", "b\r\n", "c\rd"])
757 self.assertEqual(memio.getvalue(), "a\nb\r\nc\rd")
758
759 def test_newline_cr(self):
760 # newline="\r"
761 memio = self.ioclass("a\nb\r\nc\rd", newline="\r")
762 self.assertEqual(memio.read(), "a\rb\r\rc\rd")
763 memio.seek(0)
764 self.assertEqual(list(memio), ["a\r", "b\r", "\r", "c\r", "d"])
765 self.assertEqual(memio.getvalue(), "a\rb\r\rc\rd")
766
767 memio = self.ioclass(newline="\r")
768 self.assertEqual(memio.write("a\nb\r\nc\rd"), 8)
769 memio.seek(0)
770 self.assertEqual(list(memio), ["a\r", "b\r", "\r", "c\r", "d"])
771 memio.seek(0)
772 self.assertEqual(memio.readlines(), ["a\r", "b\r", "\r", "c\r", "d"])
773 self.assertEqual(memio.getvalue(), "a\rb\r\rc\rd")
774
775 def test_newline_crlf(self):
776 # newline="\r\n"
777 memio = self.ioclass("a\nb\r\nc\rd", newline="\r\n")
778 self.assertEqual(memio.read(), "a\r\nb\r\r\nc\rd")
779 memio.seek(0)
780 self.assertEqual(list(memio), ["a\r\n", "b\r\r\n", "c\rd"])
781 memio.seek(0)
782 self.assertEqual(memio.readlines(), ["a\r\n", "b\r\r\n", "c\rd"])
783 self.assertEqual(memio.getvalue(), "a\r\nb\r\r\nc\rd")
784
785 memio = self.ioclass(newline="\r\n")
786 self.assertEqual(memio.write("a\nb\r\nc\rd"), 8)
787 memio.seek(0)
788 self.assertEqual(list(memio), ["a\r\n", "b\r\r\n", "c\rd"])
789 self.assertEqual(memio.getvalue(), "a\r\nb\r\r\nc\rd")
790
791 def test_issue5265(self):
792 # StringIO can duplicate newlines in universal newlines mode
793 memio = self.ioclass("a\r\nb\r\n", newline=None)
794 self.assertEqual(memio.read(5), "a\nb\n")
795 self.assertEqual(memio.getvalue(), "a\nb\n")
796
797 def test_newline_argument(self):
798 self.assertRaises(TypeError, self.ioclass, newline=b"\n")
799 self.assertRaises(ValueError, self.ioclass, newline="error")
800 # These should not raise an error
801 for newline in (None, "", "\n", "\r", "\r\n"):
802 self.ioclass(newline=newline)
803
804
805 class PyStringIOTest(MemoryTestMixin, MemorySeekTestMixin,
806 TextIOTestMixin, unittest.TestCase):
807 buftype = str
808 ioclass = pyio.StringIO
809 UnsupportedOperation = pyio.UnsupportedOperation
810 EOF = ""
811
812 def test_lone_surrogates(self):
813 # Issue #20424
814 memio = self.ioclass('\ud800')
815 self.assertEqual(memio.read(), '\ud800')
816
817 memio = self.ioclass()
818 memio.write('\ud800')
819 self.assertEqual(memio.getvalue(), '\ud800')
820
821
822 class PyStringIOPickleTest(TextIOTestMixin, unittest.TestCase):
823 """Test if pickle restores properly the internal state of StringIO.
824 """
825 buftype = str
826 UnsupportedOperation = pyio.UnsupportedOperation
827 EOF = ""
828
829 class ioclass(pyio.StringIO):
830 def __new__(cls, *args, **kwargs):
831 return pickle.loads(pickle.dumps(pyio.StringIO(*args, **kwargs)))
832 def __init__(self, *args, **kwargs):
833 pass
834
835
836 class CBytesIOTest(PyBytesIOTest):
837 ioclass = io.BytesIO
838 UnsupportedOperation = io.UnsupportedOperation
839
840 def test_getstate(self):
841 memio = self.ioclass()
842 state = memio.__getstate__()
843 self.assertEqual(len(state), 3)
844 bytearray(state[0]) # Check if state[0] supports the buffer interface.
845 self.assertIsInstance(state[1], int)
846 if state[2] is not None:
847 self.assertIsInstance(state[2], dict)
848 memio.close()
849 self.assertRaises(ValueError, memio.__getstate__)
850
851 def test_setstate(self):
852 # This checks whether __setstate__ does proper input validation.
853 memio = self.ioclass()
854 memio.__setstate__((b"no error", 0, None))
855 memio.__setstate__((bytearray(b"no error"), 0, None))
856 memio.__setstate__((b"no error", 0, {'spam': 3}))
857 self.assertRaises(ValueError, memio.__setstate__, (b"", -1, None))
858 self.assertRaises(TypeError, memio.__setstate__, ("unicode", 0, None))
859 self.assertRaises(TypeError, memio.__setstate__, (b"", 0.0, None))
860 self.assertRaises(TypeError, memio.__setstate__, (b"", 0, 0))
861 self.assertRaises(TypeError, memio.__setstate__, (b"len-test", 0))
862 self.assertRaises(TypeError, memio.__setstate__)
863 self.assertRaises(TypeError, memio.__setstate__, 0)
864 memio.close()
865 self.assertRaises(ValueError, memio.__setstate__, (b"closed", 0, None))
866
867 check_sizeof = support.check_sizeof
868
869 @support.cpython_only
870 def test_sizeof(self):
871 basesize = support.calcobjsize('P2n2Pn')
872 check = self.check_sizeof
873 self.assertEqual(object.__sizeof__(io.BytesIO()), basesize)
874 check(io.BytesIO(), basesize )
875 n = 1000 # use a variable to prevent constant folding
876 check(io.BytesIO(b'a' * n), basesize + sys.getsizeof(b'a' * n))
877
878 # Various tests of copy-on-write behaviour for BytesIO.
879
880 def _test_cow_mutation(self, mutation):
881 # Common code for all BytesIO copy-on-write mutation tests.
882 imm = (' ' * 1024).encode("ascii")
883 old_rc = sys.getrefcount(imm)
884 memio = self.ioclass(imm)
885 self.assertEqual(sys.getrefcount(imm), old_rc + 1)
886 mutation(memio)
887 self.assertEqual(sys.getrefcount(imm), old_rc)
888
889 @support.cpython_only
890 def test_cow_truncate(self):
891 # Ensure truncate causes a copy.
892 def mutation(memio):
893 memio.truncate(1)
894 self._test_cow_mutation(mutation)
895
896 @support.cpython_only
897 def test_cow_write(self):
898 # Ensure write that would not cause a resize still results in a copy.
899 def mutation(memio):
900 memio.seek(0)
901 memio.write(b'foo')
902 self._test_cow_mutation(mutation)
903
904 @support.cpython_only
905 def test_cow_setstate(self):
906 # __setstate__ should cause buffer to be released.
907 memio = self.ioclass(b'foooooo')
908 state = memio.__getstate__()
909 def mutation(memio):
910 memio.__setstate__(state)
911 self._test_cow_mutation(mutation)
912
913 @support.cpython_only
914 def test_cow_mutable(self):
915 # BytesIO should accept only Bytes for copy-on-write sharing, since
916 # arbitrary buffer-exporting objects like bytearray() aren't guaranteed
917 # to be immutable.
918 ba = bytearray(1024)
919 old_rc = sys.getrefcount(ba)
920 memio = self.ioclass(ba)
921 self.assertEqual(sys.getrefcount(ba), old_rc)
922
923 class CStringIOTest(PyStringIOTest):
924 ioclass = io.StringIO
925 UnsupportedOperation = io.UnsupportedOperation
926
927 # XXX: For the Python version of io.StringIO, this is highly
928 # dependent on the encoding used for the underlying buffer.
929 def test_widechar(self):
930 buf = self.buftype("\U0002030a\U00020347")
931 memio = self.ioclass(buf)
932
933 self.assertEqual(memio.getvalue(), buf)
934 self.assertEqual(memio.write(buf), len(buf))
935 self.assertEqual(memio.tell(), len(buf))
936 self.assertEqual(memio.getvalue(), buf)
937 self.assertEqual(memio.write(buf), len(buf))
938 self.assertEqual(memio.tell(), len(buf) * 2)
939 self.assertEqual(memio.getvalue(), buf + buf)
940
941 def test_getstate(self):
942 memio = self.ioclass()
943 state = memio.__getstate__()
944 self.assertEqual(len(state), 4)
945 self.assertIsInstance(state[0], str)
946 self.assertIsInstance(state[1], str)
947 self.assertIsInstance(state[2], int)
948 if state[3] is not None:
949 self.assertIsInstance(state[3], dict)
950 memio.close()
951 self.assertRaises(ValueError, memio.__getstate__)
952
953 def test_setstate(self):
954 # This checks whether __setstate__ does proper input validation.
955 memio = self.ioclass()
956 memio.__setstate__(("no error", "\n", 0, None))
957 memio.__setstate__(("no error", "", 0, {'spam': 3}))
958 self.assertRaises(ValueError, memio.__setstate__, ("", "f", 0, None))
959 self.assertRaises(ValueError, memio.__setstate__, ("", "", -1, None))
960 self.assertRaises(TypeError, memio.__setstate__, (b"", "", 0, None))
961 self.assertRaises(TypeError, memio.__setstate__, ("", b"", 0, None))
962 self.assertRaises(TypeError, memio.__setstate__, ("", "", 0.0, None))
963 self.assertRaises(TypeError, memio.__setstate__, ("", "", 0, 0))
964 self.assertRaises(TypeError, memio.__setstate__, ("len-test", 0))
965 self.assertRaises(TypeError, memio.__setstate__)
966 self.assertRaises(TypeError, memio.__setstate__, 0)
967 memio.close()
968 self.assertRaises(ValueError, memio.__setstate__, ("closed", "", 0, None))
969
970
971 class CStringIOPickleTest(PyStringIOPickleTest):
972 UnsupportedOperation = io.UnsupportedOperation
973
974 class ioclass(io.StringIO):
975 def __new__(cls, *args, **kwargs):
976 return pickle.loads(pickle.dumps(io.StringIO(*args, **kwargs)))
977 def __init__(self, *args, **kwargs):
978 pass
979
980
981 if __name__ == '__main__':
982 unittest.main()