10a8c90248264a8b26970b4473770bcc3df8515fJosh Gao"""Unit tests for the io module.""" 20a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# Tests of io are scattered over the test suite: 40a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# * test_bufio - tests file buffering 50a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# * test_memoryio - tests BytesIO and StringIO 60a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# * test_fileio - tests FileIO 70a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# * test_file - tests the file interface 80a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# * test_io - tests everything else in the io module 90a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# * test_univnewlines - tests universal newline support 100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# * test_largefile - tests operations on a file greater than 2**32 bytes 110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# (only enabled with -ulargefile) 120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao################################################################################ 140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# ATTENTION TEST WRITERS!!! 150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao################################################################################ 160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# When writing tests for io, it's important to test both the C and Python 170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# implementations. This is usually done by writing a base test that refers to 180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# the type it is testing as a attribute. Then it provides custom subclasses to 190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# test both implementations. This file has lots of examples. 200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao################################################################################ 210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 220a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom __future__ import print_function 230a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom __future__ import unicode_literals 240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 250a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport os 260a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport sys 270a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport time 280a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport array 290a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport random 300a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport unittest 310a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport weakref 320a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport abc 330a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport signal 340a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport errno 350a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom itertools import cycle, count 360a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom collections import deque 370a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom UserList import UserList 380a8c90248264a8b26970b4473770bcc3df8515fJosh Gaofrom test import test_support as support 390a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport contextlib 400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 410a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport codecs 420a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport io # C implementation of io 430a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoimport _pyio as pyio # Python implementation of io 440a8c90248264a8b26970b4473770bcc3df8515fJosh Gaotry: 450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import threading 460a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoexcept ImportError: 470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao threading = None 480a8c90248264a8b26970b4473770bcc3df8515fJosh Gaotry: 490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao import fcntl 500a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoexcept ImportError: 510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fcntl = None 520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao__metaclass__ = type 540a8c90248264a8b26970b4473770bcc3df8515fJosh Gaobytes = support.py3k_bytes 550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 560a8c90248264a8b26970b4473770bcc3df8515fJosh Gaodef _default_chunk_size(): 570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """Get the default TextIOWrapper chunk size""" 580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with io.open(__file__, "r", encoding="latin1") as f: 590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return f._CHUNK_SIZE 600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 620a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass MockRawIOWithoutRead: 630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """A RawIO implementation without read(), so as to exercise the default 640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao RawIO.read() which calls readinto().""" 650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, read_stack=()): 670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._read_stack = list(read_stack) 680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._write_stack = [] 690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._reads = 0 700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._extraneous_reads = 0 710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def write(self, b): 730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._write_stack.append(bytes(b)) 740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return len(b) 750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def writable(self): 770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return True 780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def fileno(self): 800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 42 810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def readable(self): 830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return True 840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def seekable(self): 860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return True 870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def seek(self, pos, whence): 890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 0 # wrong but we gotta return something 900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def tell(self): 920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 0 # same comment as above 930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def readinto(self, buf): 950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._reads += 1 960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao max_len = len(buf) 970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = self._read_stack[0] 990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except IndexError: 1000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._extraneous_reads += 1 1010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 0 1020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if data is None: 1030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del self._read_stack[0] 1040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return None 1050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = len(data) 1060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if len(data) <= max_len: 1070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del self._read_stack[0] 1080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf[:n] = data 1090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return n 1100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 1110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf[:] = data[:max_len] 1120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._read_stack[0] = data[max_len:] 1130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return max_len 1140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def truncate(self, pos=None): 1160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return pos 1170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1180a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CMockRawIOWithoutRead(MockRawIOWithoutRead, io.RawIOBase): 1190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1210a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyMockRawIOWithoutRead(MockRawIOWithoutRead, pyio.RawIOBase): 1220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1250a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass MockRawIO(MockRawIOWithoutRead): 1260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def read(self, n=None): 1280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._reads += 1 1290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 1300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self._read_stack.pop(0) 1310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except: 1320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._extraneous_reads += 1 1330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return b"" 1340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1350a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CMockRawIO(MockRawIO, io.RawIOBase): 1360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1380a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyMockRawIO(MockRawIO, pyio.RawIOBase): 1390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1420a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass MisbehavedRawIO(MockRawIO): 1430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def write(self, b): 1440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return MockRawIO.write(self, b) * 2 1450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def read(self, n=None): 1470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return MockRawIO.read(self, n) * 2 1480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def seek(self, pos, whence): 1500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return -123 1510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def tell(self): 1530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return -456 1540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def readinto(self, buf): 1560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao MockRawIO.readinto(self, buf) 1570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return len(buf) * 5 1580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1590a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CMisbehavedRawIO(MisbehavedRawIO, io.RawIOBase): 1600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1620a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyMisbehavedRawIO(MisbehavedRawIO, pyio.RawIOBase): 1630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1660a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CloseFailureIO(MockRawIO): 1670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao closed = 0 1680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def close(self): 1700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not self.closed: 1710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.closed = 1 1720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IOError 1730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1740a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CCloseFailureIO(CloseFailureIO, io.RawIOBase): 1750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1770a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyCloseFailureIO(CloseFailureIO, pyio.RawIOBase): 1780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1810a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass MockFileIO: 1820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, data): 1840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.read_history = [] 1850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MockFileIO, self).__init__(data) 1860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def read(self, n=None): 1880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao res = super(MockFileIO, self).read(n) 1890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.read_history.append(None if res is None else len(res)) 1900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return res 1910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def readinto(self, b): 1930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao res = super(MockFileIO, self).readinto(b) 1940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.read_history.append(res) 1950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return res 1960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1970a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CMockFileIO(MockFileIO, io.BytesIO): 1980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 1990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2000a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyMockFileIO(MockFileIO, pyio.BytesIO): 2010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 2020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2040a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass MockNonBlockWriterIO: 2050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self): 2070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._write_stack = [] 2080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._blocker_char = None 2090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def pop_written(self): 2110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = b"".join(self._write_stack) 2120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._write_stack[:] = [] 2130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return s 2140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def block_on(self, char): 2160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """Block when a given char is encountered.""" 2170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._blocker_char = char 2180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def readable(self): 2200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return True 2210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def seekable(self): 2230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return True 2240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def writable(self): 2260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return True 2270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def write(self, b): 2290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = bytes(b) 2300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = -1 2310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if self._blocker_char: 2320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 2330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = b.index(self._blocker_char) 2340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except ValueError: 2350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 2360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 2370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if n > 0: 2380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # write data up to the first blocker 2390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._write_stack.append(b[:n]) 2400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return n 2410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 2420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # cancel blocker and indicate would block 2430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._blocker_char = None 2440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return None 2450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._write_stack.append(b) 2460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return len(b) 2470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2480a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CMockNonBlockWriterIO(MockNonBlockWriterIO, io.RawIOBase): 2490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BlockingIOError = io.BlockingIOError 2500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2510a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyMockNonBlockWriterIO(MockNonBlockWriterIO, pyio.RawIOBase): 2520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BlockingIOError = pyio.BlockingIOError 2530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2550a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass IOTest(unittest.TestCase): 2560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def setUp(self): 2580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.unlink(support.TESTFN) 2590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def tearDown(self): 2610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.unlink(support.TESTFN) 2620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def write_ops(self, f): 2640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(b"blah."), 5) 2650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.truncate(0) 2660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 5) 2670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 2680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(b"blah."), 5) 2700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0), 0) 2710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(b"Hello."), 6) 2720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 6) 2730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(-1, 1), 5) 2740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 5) 2750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(bytearray(b" world\n\n\n")), 9) 2760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0), 0) 2770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(b"h"), 1) 2780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(-1, 2), 13) 2790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 13) 2800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.truncate(12), 12) 2820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 13) 2830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, f.seek, 0.0) 2840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 2850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def read_ops(self, f, buffered=False): 2860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = f.read(5) 2870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, b"hello") 2880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = bytearray(data) 2890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readinto(data), 5) 2900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, b" worl") 2910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readinto(data), 2) 2920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(data), 5) 2930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data[:2], b"d\n") 2940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0), 0) 2950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(20), b"hello world\n") 2960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(1), b"") 2970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readinto(bytearray(b"x")), 0) 2980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(-6, 2), 6) 2990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(5), b"world") 3000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(0), b"") 3010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readinto(bytearray()), 0) 3020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(-6, 1), 5) 3030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(5), b" worl") 3040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 10) 3050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, f.seek, 0.0) 3060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if buffered: 3070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 3080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"hello world\n") 3090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(6) 3100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"world\n") 3110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"") 3120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao LARGE = 2**31 3140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def large_file_ops(self, f): 3160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao assert f.readable() 3170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao assert f.writable() 3180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(self.LARGE), self.LARGE) 3190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), self.LARGE) 3200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(b"xxx"), 3) 3210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), self.LARGE + 3) 3220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(-1, 1), self.LARGE + 2) 3230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.truncate(), self.LARGE + 2) 3240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), self.LARGE + 2) 3250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0, 2), self.LARGE + 2) 3260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.truncate(self.LARGE + 1), self.LARGE + 1) 3270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), self.LARGE + 2) 3280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0, 2), self.LARGE + 1) 3290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(-1, 2), self.LARGE) 3300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(2), b"x") 3310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_invalid_operations(self): 3330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Try writing on a file opened in read mode and vice-versa. 3340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for mode in ("w", "wb"): 3350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, mode) as fp: 3360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, fp.read) 3370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, fp.readline) 3380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as fp: 3390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, fp.write, b"blah") 3400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, fp.writelines, [b"blah\n"]) 3410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "r") as fp: 3420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, fp.write, "blah") 3430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, fp.writelines, ["blah\n"]) 3440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_raw_file_io(self): 3460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb", buffering=0) as f: 3470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readable(), False) 3480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.writable(), True) 3490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seekable(), True) 3500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.write_ops(f) 3510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb", buffering=0) as f: 3520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readable(), True) 3530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.writable(), False) 3540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seekable(), True) 3550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.read_ops(f) 3560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_buffered_file_io(self): 3580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 3590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readable(), False) 3600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.writable(), True) 3610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seekable(), True) 3620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.write_ops(f) 3630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 3640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readable(), True) 3650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.writable(), False) 3660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seekable(), True) 3670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.read_ops(f, True) 3680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readline(self): 3700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 3710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"abc\ndef\nxyzzy\nfoo\x00bar\nanother line") 3720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 3730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), b"abc\n") 3740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(10), b"def\n") 3750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(2), b"xy") 3760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(4), b"zzy\n") 3770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), b"foo\x00bar\n") 3780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(None), b"another line") 3790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, f.readline, 5.3) 3800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "r") as f: 3810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, f.readline, 5.3) 3820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_raw_bytes_io(self): 3840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.BytesIO() 3850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.write_ops(f) 3860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = f.getvalue() 3870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, b"hello world\n") 3880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.BytesIO(data) 3890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.read_ops(f, True) 3900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 3910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_large_file_ops(self): 3920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # On Windows and Mac OSX this test comsumes large resources; It takes 3930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # a long time to build the >2GB file and takes >2GB of disk space 3940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # therefore the resource must be enabled to run this test. 3950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if sys.platform[:3] == 'win' or sys.platform == 'darwin': 3960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not support.is_resource_enabled("largefile"): 3970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao print("\nTesting large file ops skipped on %s." % sys.platform, 3980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao file=sys.stderr) 3990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao print("It requires %d bytes and a long time." % self.LARGE, 4000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao file=sys.stderr) 4010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao print("Use 'regrtest.py -u largefile test_io' to run it.", 4020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao file=sys.stderr) 4030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 4040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "w+b", 0) as f: 4050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.large_file_ops(f) 4060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "w+b") as f: 4070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.large_file_ops(f) 4080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_with_open(self): 4100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for bufsize in (0, 1, 100): 4110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = None 4120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb", bufsize) as f: 4130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"xxx") 4140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.closed, True) 4150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = None 4160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 4170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb", bufsize) as f: 4180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1 // 0 4190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except ZeroDivisionError: 4200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.closed, True) 4210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 4220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.fail("1 // 0 didn't raise an exception") 4230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # issue 5008 4250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_append_mode_tell(self): 4260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 4270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"xxx") 4280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "ab", buffering=0) as f: 4290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 3) 4300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "ab") as f: 4310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 3) 4320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "a") as f: 4330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(f.tell() > 0) 4340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_destructor(self): 4360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record = [] 4370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class MyFileIO(self.FileIO): 4380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __del__(self): 4390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(1) 4400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 4410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = super(MyFileIO, self).__del__ 4420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except AttributeError: 4430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 4440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 4450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f() 4460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def close(self): 4470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(2) 4480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyFileIO, self).close() 4490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def flush(self): 4500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(3) 4510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyFileIO, self).flush() 4520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = MyFileIO(support.TESTFN, "wb") 4530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"xxx") 4540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del f 4550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 4560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(record, [1, 2, 3]) 4570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 4580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"xxx") 4590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _check_base_destructor(self, base): 4610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record = [] 4620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class MyIO(base): 4630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self): 4640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This exercises the availability of attributes on object 4650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # destruction. 4660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (in the C version, close() is called by the tp_dealloc 4670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # function, not by __del__) 4680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.on_del = 1 4690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.on_close = 2 4700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.on_flush = 3 4710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __del__(self): 4720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(self.on_del) 4730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 4740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = super(MyIO, self).__del__ 4750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except AttributeError: 4760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 4770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 4780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f() 4790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def close(self): 4800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(self.on_close) 4810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyIO, self).close() 4820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def flush(self): 4830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(self.on_flush) 4840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyIO, self).flush() 4850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = MyIO() 4860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del f 4870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 4880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(record, [1, 2, 3]) 4890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_IOBase_destructor(self): 4910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._check_base_destructor(self.IOBase) 4920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_RawIOBase_destructor(self): 4940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._check_base_destructor(self.RawIOBase) 4950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_BufferedIOBase_destructor(self): 4970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._check_base_destructor(self.BufferedIOBase) 4980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 4990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_TextIOBase_destructor(self): 5000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._check_base_destructor(self.TextIOBase) 5010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_close_flushes(self): 5030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 5040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"xxx") 5050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 5060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"xxx") 5070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_array_writes(self): 5090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao a = array.array(b'i', range(10)) 5100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = len(a.tostring()) 5110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb", 0) as f: 5120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(a), n) 5130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 5140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write(a), n) 5150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_closefd(self): 5170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, self.open, support.TESTFN, 'w', 5180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao closefd=False) 5190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_closed(self): 5210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "w") as f: 5220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write("egg\n") 5230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "r") as f: 5240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao file = self.open(f.fileno(), "r", closefd=False) 5250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(file.read(), "egg\n") 5260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao file.seek(0) 5270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao file.close() 5280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, file.read) 5290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_no_closefd_with_filename(self): 5310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # can't use closefd in combination with a file name 5320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, self.open, support.TESTFN, "r", closefd=False) 5330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_closefd_attr(self): 5350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 5360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"egg\n") 5370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "r") as f: 5380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.buffer.raw.closefd, True) 5390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao file = self.open(f.fileno(), "r", closefd=False) 5400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(file.buffer.raw.closefd, False) 5410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_garbage_collection(self): 5430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # FileIO objects are collected, and collecting them flushes 5440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # all data to disk. 5450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.FileIO(support.TESTFN, "wb") 5460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"abcxxx") 5470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.f = f 5480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wr = weakref.ref(f) 5490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del f 5500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 5510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(wr() is None, wr) 5520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 5530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"abcxxx") 5540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_unbounded_file(self): 5560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #1174606: reading from an unbounded stream such as /dev/zero. 5570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao zero = "/dev/zero" 5580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not os.path.exists(zero): 5590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.skipTest("{0} does not exist".format(zero)) 5600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if sys.maxsize > 0x7FFFFFFF: 5610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.skipTest("test can only run in a 32-bit address space") 5620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if support.real_max_memuse < support._2G: 5630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.skipTest("test requires at least 2GB of memory") 5640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(zero, "rb", buffering=0) as f: 5650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(OverflowError, f.read) 5660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(zero, "rb") as f: 5670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(OverflowError, f.read) 5680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(zero, "r") as f: 5690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(OverflowError, f.read) 5700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush_error_on_close(self): 5720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "wb", buffering=0) 5730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def bad_flush(): 5740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IOError() 5750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.flush = bad_flush 5760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, f.close) # exception not swallowed 5770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(f.closed) 5780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_multi_close(self): 5800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "wb", buffering=0) 5810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 5820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 5830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 5840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.flush) 5850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_RawIOBase_read(self): 5870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Exercise the default RawIOBase.read() implementation (which calls 5880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # readinto() internally). 5890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIOWithoutRead((b"abc", b"d", None, b"efg", None)) 5900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), b"ab") 5910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), b"c") 5920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), b"d") 5930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), None) 5940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), b"ef") 5950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), b"g") 5960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), None) 5970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read(2), b"") 5980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 5990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_fileio_closefd(self): 6000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #4841 6010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(__file__, 'rb') as f1, \ 6020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.open(__file__, 'rb') as f2: 6030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fileio = self.FileIO(f1.fileno(), closefd=False) 6040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # .__init__() must not close f1 6050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fileio.__init__(f2.fileno(), closefd=False) 6060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f1.readline() 6070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # .close() must not close f2 6080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fileio.close() 6090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f2.readline() 6100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6120a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CIOTest(IOTest): 6130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_IOBase_finalize(self): 6150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #12149: segmentation fault on _PyIOBase_finalize when both a 6160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # class which inherits IOBase and an object of this class are caught 6170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # in a reference cycle and close() is already in the method cache. 6180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class MyIO(self.IOBase): 6190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def close(self): 6200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 6210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # create an instance to populate the method cache 6230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao MyIO() 6240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao obj = MyIO() 6250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao obj.obj = obj 6260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wr = weakref.ref(obj) 6270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del MyIO 6280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del obj 6290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 6300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(wr() is None, wr) 6310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6320a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyIOTest(IOTest): 6330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_array_writes = unittest.skip( 6340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "len(array.array) returns number of elements rather than bytelength" 6350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao )(IOTest.test_array_writes) 6360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6380a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CommonBufferedTests: 6390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Tests common to BufferedReader, BufferedWriter and BufferedRandom 6400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_detach(self): 6420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 6430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.tp(raw) 6440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIs(buf.detach(), raw) 6450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, buf.detach) 6460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_fileno(self): 6480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 6490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 6500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(42, bufio.fileno()) 6520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_no_fileno(self): 6540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # XXX will we always have fileno() function? If so, kill 6550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # this test. Else, write it. 6560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 6570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_invalid_args(self): 6590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 6600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 6610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Invalid whence 6620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.seek, 0, -1) 6630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.seek, 0, 3) 6640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_override_destructor(self): 6660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = self.tp 6670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record = [] 6680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class MyBufferedIO(tp): 6690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __del__(self): 6700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(1) 6710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 6720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = super(MyBufferedIO, self).__del__ 6730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except AttributeError: 6740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 6750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 6760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f() 6770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def close(self): 6780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(2) 6790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyBufferedIO, self).close() 6800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def flush(self): 6810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(3) 6820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyBufferedIO, self).flush() 6830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 6840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = MyBufferedIO(rawio) 6850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writable = bufio.writable() 6860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del bufio 6870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 6880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if writable: 6890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(record, [1, 2, 3]) 6900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 6910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(record, [1, 2]) 6920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 6930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_context_manager(self): 6940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test usability as a context manager 6950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 6960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 6970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _with(): 6980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with bufio: 6990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 7000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _with() 7010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # bufio should now be closed, and using it a second time should raise 7020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # a ValueError. 7030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, _with) 7040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_error_through_destructor(self): 7060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test that the exception state is not modified by a destructor, 7070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # even if close() fails. 7080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.CloseFailureIO() 7090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f(): 7100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.tp(rawio).xyzzy 7110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with support.captured_output("stderr") as s: 7120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(AttributeError, f) 7130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = s.getvalue().strip() 7140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if s: 7150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The destructor *may* have printed an unraisable error, check it 7160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(s.splitlines()), 1) 7170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(s.startswith("Exception IOError: "), s) 7180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(s.endswith(" ignored"), s) 7190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_repr(self): 7210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 7220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.tp(raw) 7230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao clsname = "%s.%s" % (self.tp.__module__, self.tp.__name__) 7240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(b), "<%s>" % clsname) 7250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.name = "dummy" 7260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(b), "<%s name=u'dummy'>" % clsname) 7270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.name = b"dummy" 7280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(b), "<%s name='dummy'>" % clsname) 7290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush_error_on_close(self): 7310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 7320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def bad_flush(): 7330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IOError() 7340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.flush = bad_flush 7350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.tp(raw) 7360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, b.close) # exception not swallowed 7370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(b.closed) 7380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_close_error_on_close(self): 7400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 7410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def bad_flush(): 7420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IOError('flush') 7430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def bad_close(): 7440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IOError('close') 7450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.close = bad_close 7460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.tp(raw) 7470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b.flush = bad_flush 7480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.assertRaises(IOError) as err: # exception not swallowed 7490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b.close() 7500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(err.exception.args, ('close',)) 7510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(b.closed) 7520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_multi_close(self): 7540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 7550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.tp(raw) 7560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b.close() 7570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b.close() 7580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b.close() 7590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, b.flush) 7600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readonly_attributes(self): 7620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 7630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.tp(raw) 7640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao x = self.MockRawIO() 7650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.assertRaises((AttributeError, TypeError)): 7660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf.raw = x 7670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7690a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass SizeofTest: 7700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @support.cpython_only 7720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_sizeof(self): 7730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufsize1 = 4096 7740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufsize2 = 8192 7750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 7760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio, buffer_size=bufsize1) 7770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao size = sys.getsizeof(bufio) - bufsize1 7780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 7790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio, buffer_size=bufsize2) 7800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(sys.getsizeof(bufio), size + bufsize2) 7810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7830a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass BufferedReaderTest(unittest.TestCase, CommonBufferedTests): 7840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read_mode = "rb" 7850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 7860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 7870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO([b"abc"]) 7880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 7890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio) 7900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio, buffer_size=1024) 7910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio, buffer_size=16) 7920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abc", bufio.read()) 7930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) 7940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) 7950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) 7960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO([b"abc"]) 7970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio) 7980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abc", bufio.read()) 7990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read(self): 8010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for arg in (None, 7): 8020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"abc", b"d", b"efg")) 8030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 8040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abcdefg", bufio.read(arg)) 8050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Invalid args 8060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.read, -2) 8070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read1(self): 8090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"abc", b"d", b"efg")) 8100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 8110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"a", bufio.read(1)) 8120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"b", bufio.read1(1)) 8130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio._reads, 1) 8140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"c", bufio.read1(100)) 8150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio._reads, 1) 8160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"d", bufio.read1(100)) 8170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio._reads, 2) 8180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"efg", bufio.read1(100)) 8190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio._reads, 3) 8200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"", bufio.read1(100)) 8210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio._reads, 4) 8220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Invalid args 8230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.read1, -1) 8240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readinto(self): 8260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"abc", b"d", b"efg")) 8270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 8280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = bytearray(2) 8290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.readinto(b), 2) 8300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b, b"ab") 8310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.readinto(b), 2) 8320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b, b"cd") 8330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.readinto(b), 2) 8340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b, b"ef") 8350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.readinto(b), 1) 8360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b, b"gf") 8370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.readinto(b), 0) 8380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b, b"gf") 8390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readlines(self): 8410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def bufio(): 8420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"abc\n", b"d\n", b"ef")) 8430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self.tp(rawio) 8440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio().readlines(), [b"abc\n", b"d\n", b"ef"]) 8450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio().readlines(5), [b"abc\n", b"d\n"]) 8460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"]) 8470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_buffering(self): 8490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = b"abcdefghi" 8500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao dlen = len(data) 8510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tests = [ 8530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ 100, [ 3, 1, 4, 8 ], [ dlen, 0 ] ], 8540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ 100, [ 3, 3, 3], [ dlen ] ], 8550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ 4, [ 1, 2, 4, 2 ], [ 4, 4, 1 ] ], 8560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ] 8570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for bufsize, buf_read_sizes, raw_read_sizes in tests: 8590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockFileIO(data) 8600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio, buffer_size=bufsize) 8610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = 0 8620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for nbytes in buf_read_sizes: 8630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.read(nbytes), data[pos:pos+nbytes]) 8640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos += nbytes 8650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # this is mildly implementation-dependent 8660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio.read_history, raw_read_sizes) 8670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_non_blocking(self): 8690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Inject some None's in there to simulate EWOULDBLOCK 8700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"abc", b"d", None, b"efg", None, None, None)) 8710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 8720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abcd", bufio.read(6)) 8730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"e", bufio.read(1)) 8740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"fg", bufio.read()) 8750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"", bufio.peek(1)) 8760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsNone(bufio.read()) 8770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"", bufio.read()) 8780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"a", None, None)) 8800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"a", rawio.readall()) 8810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsNone(rawio.readall()) 8820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_past_eof(self): 8840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"abc", b"d", b"efg")) 8850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 8860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abcdefg", bufio.read(9000)) 8880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_all(self): 8900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO((b"abc", b"d", b"efg")) 8910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 8920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abcdefg", bufio.read()) 8940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 8950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipUnless(threading, 'Threading required for this test.') 8960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @support.requires_resource('cpu') 8970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_threads(self): 8980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 8990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Write out many bytes with exactly the same number of 0's, 9000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # 1's... 255's. This will help us check that concurrent reading 9010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # doesn't duplicate or forget contents. 9020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao N = 1000 9030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao l = list(range(256)) * N 9040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao random.shuffle(l) 9050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = bytes(bytearray(l)) 9060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 9070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(s) 9080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, self.read_mode, buffering=0) as raw: 9090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 8) 9100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao errors = [] 9110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao results = [] 9120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f(): 9130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 9140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Intra-buffer read then buffer-flushing read 9150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for n in cycle([1, 19]): 9160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = bufio.read(n) 9170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not s: 9180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 9190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # list.append() is atomic 9200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao results.append(s) 9210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except Exception as e: 9220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao errors.append(e) 9230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise 9240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao threads = [threading.Thread(target=f) for x in range(20)] 9250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for t in threads: 9260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.start() 9270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao time.sleep(0.02) # yield 9280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for t in threads: 9290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.join() 9300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(errors, 9310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "the following exceptions were caught: %r" % errors) 9320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = b''.join(results) 9330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(256): 9340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = bytes(bytearray([i])) 9350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(s.count(c), N) 9360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 9370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.unlink(support.TESTFN) 9380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_misbehaved_io(self): 9400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MisbehavedRawIO((b"abc", b"d", b"efg")) 9410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 9420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, bufio.seek, 0) 9430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, bufio.tell) 9440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_no_extraneous_read(self): 9460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #9550; when the raw IO object has satisfied the read request, 9470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # we should not issue any additional reads, otherwise it may block 9480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (e.g. socket). 9490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufsize = 16 9500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for n in (2, bufsize - 1, bufsize, bufsize + 1, bufsize * 2): 9510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO([b"x" * n]) 9520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio, bufsize) 9530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.read(n), b"x" * n) 9540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Simple case: one raw read is enough to satisfy the request. 9550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio._extraneous_reads, 0, 9560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "failed for {}: {} != 0".format(n, rawio._extraneous_reads)) 9570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # A more complex case where two raw reads are needed to satisfy 9580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # the request. 9590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO([b"x" * (n - 1), b"x"]) 9600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio, bufsize) 9610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.read(n), b"x" * n) 9620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rawio._extraneous_reads, 0, 9630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "failed for {}: {} != 0".format(n, rawio._extraneous_reads)) 9640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9660a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CBufferedReaderTest(BufferedReaderTest, SizeofTest): 9670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = io.BufferedReader 9680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 9700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedReaderTest.test_constructor(self) 9710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The allocation can succeed on 32-bit builds, e.g. with more 9720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # than 2GB RAM and a 64-bit kernel. 9730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if sys.maxsize > 0x7FFFFFFF: 9740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 9750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 9760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises((OverflowError, MemoryError, ValueError), 9770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__, rawio, sys.maxsize) 9780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_initialization(self): 9800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO([b"abc"]) 9810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 9820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) 9830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.read) 9840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) 9850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.read) 9860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) 9870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.read) 9880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_misbehaved_io_read(self): 9900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MisbehavedRawIO((b"abc", b"d", b"efg")) 9910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 9920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # _pyio.BufferedReader seems to implement reading different, so that 9930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # checking this is not so easy. 9940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, bufio.read, 10) 9950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 9960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_garbage_collection(self): 9970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # C BufferedReader objects are collected. 9980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The Python version has __del__, so it ends into gc.garbage instead 9990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.FileIO(support.TESTFN, "w+b") 10000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.tp(rawio) 10010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.f = f 10020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wr = weakref.ref(f) 10030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del f 10040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 10050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(wr() is None, wr) 10060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_args_error(self): 10080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #17275 10090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.assertRaisesRegexp(TypeError, "BufferedReader"): 10100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.tp(io.BytesIO(), 1024, 1024, 1024) 10110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10130a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyBufferedReaderTest(BufferedReaderTest): 10140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = pyio.BufferedReader 10150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10170a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 10180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao write_mode = "wb" 10190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 10210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 10220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 10230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio) 10240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio, buffer_size=1024) 10250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio, buffer_size=16) 10260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(3, bufio.write(b"abc")) 10270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 10280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) 10290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) 10300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) 10310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__(rawio) 10320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(3, bufio.write(b"ghi")) 10330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 10340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"".join(rawio._write_stack), b"abcghi") 10350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_detach_flush(self): 10370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 10380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.tp(raw) 10390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf.write(b"howdy!") 10400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(raw._write_stack) 10410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf.detach() 10420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw._write_stack, [b"howdy!"]) 10430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write(self): 10450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Write to the buffered IO but don't overflow the buffer. 10460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 10470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 8) 10480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"abc") 10490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(writer._write_stack) 10500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write_overflow(self): 10520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 10530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 8) 10540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao contents = b"abcdefghijklmnop" 10550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for n in range(0, len(contents), 3): 10560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(contents[n:n+3]) 10570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao flushed = b"".join(writer._write_stack) 10580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # At least (total - 8) bytes were implicitly flushed, perhaps more 10590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # depending on the implementation. 10600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(flushed.startswith(contents[:-8]), flushed) 10610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_writes(self, intermediate_func): 10630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Lots of writes, test the flushed output is as expected. 10640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao contents = bytes(range(256)) * 1000 10650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = 0 10660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 10670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 13) 10680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Generator of write sizes: repeat each N 15 times then proceed to N+1 10690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def gen_sizes(): 10700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for size in count(1): 10710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(15): 10720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao yield size 10730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sizes = gen_sizes() 10740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while n < len(contents): 10750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao size = min(next(sizes), len(contents) - n) 10760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(contents[n:n+size]), size) 10770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao intermediate_func(bufio) 10780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n += size 10790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 10800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(contents, 10810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b"".join(writer._write_stack)) 10820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes(self): 10840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(lambda bufio: None) 10850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes_and_flushes(self): 10870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(lambda bufio: bufio.flush()) 10880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 10890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes_and_seeks(self): 10900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _seekabs(bufio): 10910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = bufio.tell() 10920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(pos + 1, 0) 10930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(pos - 1, 0) 10940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(pos, 0) 10950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(_seekabs) 10960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _seekrel(bufio): 10970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = bufio.seek(0, 1) 10980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(+1, 1) 10990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(-1, 1) 11000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(pos, 0) 11010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(_seekrel) 11020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes_and_truncates(self): 11040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(lambda bufio: bufio.truncate(bufio.tell())) 11050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write_non_blocking(self): 11070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockNonBlockWriterIO() 11080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 8) 11090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"abcd"), 4) 11110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"efghi"), 5) 11120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # 1 byte will be written, the rest will be buffered 11130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.block_on(b"k") 11140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"jklmn"), 5) 11150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # 8 bytes will be written, 8 will be buffered and the rest will be lost 11170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.block_on(b"0") 11180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 11190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"opqrwxyz0123456789") 11200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except self.BlockingIOError as e: 11210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao written = e.characters_written 11220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 11230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.fail("BlockingIOError should have been raised") 11240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(written, 16) 11250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw.pop_written(), 11260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b"abcdefghijklmnopqrwxyz") 11270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"ABCDEFGHI"), 9) 11290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = raw.pop_written() 11300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Previously buffered bytes were flushed 11310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(s.startswith(b"01234567A"), s) 11320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write_and_rewind(self): 11340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = io.BytesIO() 11350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 4) 11360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"abcdef"), 6) 11370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.tell(), 6) 11380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(0, 0) 11390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"XY"), 2) 11400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(6, 0) 11410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw.getvalue(), b"XYcdef") 11420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"123456"), 6) 11430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 11440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw.getvalue(), b"XYcdef123456") 11450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush(self): 11470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 11480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 8) 11490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"abc") 11500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 11510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abc", writer._write_stack[0]) 11520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writelines(self): 11540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao l = [b'ab', b'cd', b'ef'] 11550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 11560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 8) 11570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.writelines(l) 11580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 11590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b''.join(writer._write_stack), b'abcdef') 11600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writelines_userlist(self): 11620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao l = UserList([b'ab', b'cd', b'ef']) 11630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 11640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 8) 11650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.writelines(l) 11660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 11670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b''.join(writer._write_stack), b'abcdef') 11680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writelines_error(self): 11700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 11710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 8) 11720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, bufio.writelines, [1, 2, 3]) 11730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, bufio.writelines, None) 11740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_destructor(self): 11760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao writer = self.MockRawIO() 11770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(writer, 8) 11780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"abc") 11790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del bufio 11800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 11810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"abc", writer._write_stack[0]) 11820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_truncate(self): 11840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Truncate implicitly flushes the buffer. 11850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, self.write_mode, buffering=0) as raw: 11860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 8) 11870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"abcdef") 11880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.truncate(3), 3) 11890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.tell(), 6) 11900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb", buffering=0) as f: 11910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"abc") 11920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 11930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipUnless(threading, 'Threading required for this test.') 11940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @support.requires_resource('cpu') 11950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_threads(self): 11960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 11970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Write out many bytes from many threads and test they were 11980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # all flushed. 11990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao N = 1000 12000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao contents = bytes(range(256)) * N 12010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sizes = cycle([1, 19]) 12020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = 0 12030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao queue = deque() 12040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while n < len(contents): 12050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao size = next(sizes) 12060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao queue.append(contents[n:n+size]) 12070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n += size 12080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del contents 12090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # We use a real file object because it allows us to 12100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # exercise situations where the GIL is released before 12110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # writing the buffer to the raw streams. This is in addition 12120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # to concurrency issues due to switching threads in the middle 12130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # of Python code. 12140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, self.write_mode, buffering=0) as raw: 12150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 8) 12160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao errors = [] 12170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f(): 12180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 12190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 12200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 12210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = queue.popleft() 12220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except IndexError: 12230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return 12240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(s) 12250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except Exception as e: 12260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao errors.append(e) 12270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise 12280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao threads = [threading.Thread(target=f) for x in range(20)] 12290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for t in threads: 12300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.start() 12310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao time.sleep(0.02) # yield 12320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for t in threads: 12330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.join() 12340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(errors, 12350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "the following exceptions were caught: %r" % errors) 12360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.close() 12370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 12380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = f.read() 12390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(256): 12400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(s.count(bytes([i])), N) 12410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 12420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.unlink(support.TESTFN) 12430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_misbehaved_io(self): 12450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MisbehavedRawIO() 12460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio, 5) 12470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, bufio.seek, 0) 12480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, bufio.tell) 12490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, bufio.write, b"abcdef") 12500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_max_buffer_size_deprecation(self): 12520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with support.check_warnings(("max_buffer_size is deprecated", 12530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao DeprecationWarning)): 12540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.tp(self.MockRawIO(), 8, 12) 12550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write_error_on_close(self): 12570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO() 12580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def bad_write(b): 12590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IOError() 12600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.write = bad_write 12610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.tp(raw) 12620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b.write(b'spam') 12630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, b.close) # exception not swallowed 12640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(b.closed) 12650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12670a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CBufferedWriterTest(BufferedWriterTest, SizeofTest): 12680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = io.BufferedWriter 12690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 12710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedWriterTest.test_constructor(self) 12720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The allocation can succeed on 32-bit builds, e.g. with more 12730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # than 2GB RAM and a 64-bit kernel. 12740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if sys.maxsize > 0x7FFFFFFF: 12750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 12760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 12770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises((OverflowError, MemoryError, ValueError), 12780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__, rawio, sys.maxsize) 12790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_initialization(self): 12810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 12820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 12830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) 12840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.write, b"def") 12850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) 12860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.write, b"def") 12870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) 12880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, bufio.write, b"def") 12890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 12900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_garbage_collection(self): 12910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # C BufferedWriter objects are collected, and collecting them flushes 12920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # all data to disk. 12930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The Python version has __del__, so it ends into gc.garbage instead 12940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.FileIO(support.TESTFN, "w+b") 12950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.tp(rawio) 12960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"123xxx") 12970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.x = f 12980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wr = weakref.ref(f) 12990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del f 13000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 13010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(wr() is None, wr) 13020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 13030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"123xxx") 13040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_args_error(self): 13060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #17275 13070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.assertRaisesRegexp(TypeError, "BufferedWriter"): 13080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.tp(io.BytesIO(), 1024, 1024, 1024) 13090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13110a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyBufferedWriterTest(BufferedWriterTest): 13120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = pyio.BufferedWriter 13130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13140a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass BufferedRWPairTest(unittest.TestCase): 13150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 13170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.MockRawIO(), self.MockRawIO()) 13180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(pair.closed) 13190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_detach(self): 13210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.MockRawIO(), self.MockRawIO()) 13220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(self.UnsupportedOperation, pair.detach) 13230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor_max_buffer_size_deprecation(self): 13250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with support.check_warnings(("max_buffer_size is deprecated", 13260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao DeprecationWarning)): 13270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.tp(self.MockRawIO(), self.MockRawIO(), 8, 12) 13280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor_with_not_readable(self): 13300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class NotReadable(MockRawIO): 13310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def readable(self): 13320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return False 13330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, self.tp, NotReadable(), self.MockRawIO()) 13350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor_with_not_writeable(self): 13370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class NotWriteable(MockRawIO): 13380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def writable(self): 13390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return False 13400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, self.tp, self.MockRawIO(), NotWriteable()) 13420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read(self): 13440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.BytesIO(b"abcdef"), self.MockRawIO()) 13450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair.read(3), b"abc") 13470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair.read(1), b"d") 13480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair.read(), b"ef") 13490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.BytesIO(b"abc"), self.MockRawIO()) 13500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair.read(None), b"abc") 13510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readlines(self): 13530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = lambda: self.tp(self.BytesIO(b"abc\ndef\nh"), self.MockRawIO()) 13540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair().readlines(), [b"abc\n", b"def\n", b"h"]) 13550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair().readlines(), [b"abc\n", b"def\n", b"h"]) 13560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair().readlines(5), [b"abc\n", b"def\n"]) 13570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read1(self): 13590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # .read1() is delegated to the underlying reader object, so this test 13600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # can be shallow. 13610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.BytesIO(b"abcdef"), self.MockRawIO()) 13620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair.read1(3), b"abc") 13640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readinto(self): 13660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.BytesIO(b"abcdef"), self.MockRawIO()) 13670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = bytearray(5) 13690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair.readinto(data), 5) 13700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(data, b"abcde") 13710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write(self): 13730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao w = self.MockRawIO() 13740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.MockRawIO(), w) 13750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair.write(b"abc") 13770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair.flush() 13780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair.write(b"def") 13790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair.flush() 13800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(w._write_stack, [b"abc", b"def"]) 13810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_peek(self): 13830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.BytesIO(b"abcdef"), self.MockRawIO()) 13840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(pair.peek(3).startswith(b"abc")) 13860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(pair.read(3), b"abc") 13870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readable(self): 13890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.MockRawIO(), self.MockRawIO()) 13900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(pair.readable()) 13910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writeable(self): 13930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.MockRawIO(), self.MockRawIO()) 13940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(pair.writable()) 13950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 13960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_seekable(self): 13970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # BufferedRWPairs are never seekable, even if their readers and writers 13980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # are. 13990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.MockRawIO(), self.MockRawIO()) 14000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(pair.seekable()) 14010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # .flush() is delegated to the underlying writer object and has been 14030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # tested in the test_write method. 14040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_close_and_closed(self): 14060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(self.MockRawIO(), self.MockRawIO()) 14070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(pair.closed) 14080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair.close() 14090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(pair.closed) 14100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_isatty(self): 14120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class SelectableIsAtty(MockRawIO): 14130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, isatty): 14140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao MockRawIO.__init__(self) 14150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._isatty = isatty 14160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def isatty(self): 14180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return self._isatty 14190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(SelectableIsAtty(False), SelectableIsAtty(False)) 14210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(pair.isatty()) 14220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(SelectableIsAtty(True), SelectableIsAtty(False)) 14240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(pair.isatty()) 14250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(SelectableIsAtty(False), SelectableIsAtty(True)) 14270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(pair.isatty()) 14280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pair = self.tp(SelectableIsAtty(True), SelectableIsAtty(True)) 14300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(pair.isatty()) 14310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14320a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CBufferedRWPairTest(BufferedRWPairTest): 14330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = io.BufferedRWPair 14340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14350a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyBufferedRWPairTest(BufferedRWPairTest): 14360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = pyio.BufferedRWPair 14370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14390a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): 14400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read_mode = "rb+" 14410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao write_mode = "wb+" 14420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 14440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedReaderTest.test_constructor(self) 14450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedWriterTest.test_constructor(self) 14460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_and_write(self): 14480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.MockRawIO((b"asdf", b"ghjk")) 14490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw = self.tp(raw, 8) 14500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"as", rw.read(2)) 14520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.write(b"ddd") 14530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.write(b"eee") 14540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(raw._write_stack) # Buffer writes 14550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"ghjk", rw.read()) 14560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"dddeee", raw._write_stack[0]) 14570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_seek_and_tell(self): 14590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.BytesIO(b"asdfghjkl") 14600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw = self.tp(raw) 14610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"as", rw.read(2)) 14630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(2, rw.tell()) 14640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.seek(0, 0) 14650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"asdf", rw.read(4)) 14660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.write(b"123f") 14680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.seek(0, 0) 14690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"asdf123fl", rw.read()) 14700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(9, rw.tell()) 14710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.seek(-4, 2) 14720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(5, rw.tell()) 14730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.seek(2, 1) 14740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(7, rw.tell()) 14750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"fl", rw.read(11)) 14760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rw.flush() 14770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"asdf123fl", raw.getvalue()) 14780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, rw.seek, 0.0) 14800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_flush_and_read(self, read_func): 14820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.BytesIO(b"abcdefghi") 14830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw) 14840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"ab", read_func(bufio, 2)) 14860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"12") 14870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"ef", read_func(bufio, 2)) 14880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(6, bufio.tell()) 14890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 14900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(6, bufio.tell()) 14910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"ghi", read_func(bufio)) 14920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.seek(0, 0) 14930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.write(b"XYZ") 14940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # flush() resets the read buffer 14950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 14960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(0, 0) 14970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"XYZ", read_func(bufio, 3)) 14980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 14990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush_and_read(self): 15000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_flush_and_read(lambda bufio, *args: bufio.read(*args)) 15010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush_and_readinto(self): 15030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _readinto(bufio, n=-1): 15040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = bytearray(n if n >= 0 else 9999) 15050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao n = bufio.readinto(b) 15060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return bytes(b[:n]) 15070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_flush_and_read(_readinto) 15080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush_and_peek(self): 15100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _peek(bufio, n=-1): 15110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This relies on the fact that the buffer can contain the whole 15120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # raw stream, otherwise peek() can return less. 15130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = bufio.peek(n) 15140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if n != -1: 15150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = b[:n] 15160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(len(b), 1) 15170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return b 15180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_flush_and_read(_peek) 15190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush_and_write(self): 15210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.BytesIO(b"abcdefghi") 15220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw) 15230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"123") 15250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 15260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"45") 15270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 15280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(0, 0) 15290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"12345fghi", raw.getvalue()) 15300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b"12345fghi", bufio.read()) 15310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_threads(self): 15330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedReaderTest.test_threads(self) 15340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedWriterTest.test_threads(self) 15350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes_and_peek(self): 15370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _peek(bufio): 15380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.peek(1) 15390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(_peek) 15400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _peek(bufio): 15410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = bufio.tell() 15420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(-1, 1) 15430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.peek(1) 15440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(pos, 0) 15450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(_peek) 15460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes_and_reads(self): 15480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _read(bufio): 15490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(-1, 1) 15500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.read(1) 15510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(_read) 15520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes_and_read1s(self): 15540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _read1(bufio): 15550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(-1, 1) 15560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.read1(1) 15570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(_read1) 15580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writes_and_readintos(self): 15600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _read(bufio): 15610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(-1, 1) 15620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.readinto(bytearray(1)) 15630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_writes(_read) 15640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write_after_readahead(self): 15660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #6629: writing after the buffer was filled by readahead should 15670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # first rewind the raw stream. 15680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for overwrite_size in [1, 5]: 15690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.BytesIO(b"A" * 10) 15700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 4) 15710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Trigger readahead 15720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.read(1), b"A") 15730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.tell(), 1) 15740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Overwriting should rewind the raw stream if it needs so 15750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b"B" * overwrite_size) 15760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.tell(), overwrite_size + 1) 15770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # If the write size was smaller than the buffer size, flush() and 15780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # check that rewind happens. 15790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 15800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.tell(), overwrite_size + 1) 15810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = raw.getvalue() 15820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(s, 15830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b"A" + b"B" * overwrite_size + b"A" * (9 - overwrite_size)) 15840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_write_rewind_write(self): 15860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Various combinations of reading / writing / seeking backwards / writing again 15870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def mutate(bufio, pos1, pos2): 15880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao assert pos2 >= pos1 15890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Fill the buffer 15900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(pos1) 15910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.read(pos2 - pos1) 15920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b'\x02') 15930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This writes earlier than the previous write, but still inside 15940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # the buffer. 15950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.seek(pos1) 15960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.write(b'\x01') 15970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 15980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = b"\x80\x81\x82\x83\x84" 15990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(0, len(b)): 16000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for j in range(i, len(b)): 16010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.BytesIO(b) 16020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 100) 16030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao mutate(bufio, i, j) 16040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.flush() 16050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao expected = bytearray(b) 16060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao expected[j] = 2 16070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao expected[i] = 1 16080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw.getvalue(), expected, 16090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "failed result for i=%d, j=%d" % (i, j)) 16100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_truncate_after_read_or_write(self): 16120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.BytesIO(b"A" * 10) 16130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(raw, 100) 16140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.read(2), b"AA") # the read buffer gets filled 16150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.truncate(), 2) 16160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.write(b"BB"), 2) # the write buffer increases 16170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(bufio.truncate(), 4) 16180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_misbehaved_io(self): 16200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedReaderTest.test_misbehaved_io(self) 16210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedWriterTest.test_misbehaved_io(self) 16220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interleaved_read_write(self): 16240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test for issue #12213 16250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.BytesIO(b'abcdefgh') as raw: 16260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.tp(raw, 100) as f: 16270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"1") 16280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(1), b'b') 16290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b'2') 16300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read1(1), b'd') 16310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b'3') 16320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = bytearray(1) 16330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.readinto(buf) 16340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(buf, b'f') 16350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b'4') 16360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.peek(1), b'h') 16370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.flush() 16380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw.getvalue(), b'1b2d3f4h') 16390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.BytesIO(b'abc') as raw: 16410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.tp(raw, 100) as f: 16420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(1), b'a') 16430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b"2") 16440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(1), b'c') 16450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.flush() 16460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw.getvalue(), b'a2c') 16470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interleaved_readline_write(self): 16490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.BytesIO(b'ab\ncdef\ng\n') as raw: 16500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.tp(raw) as f: 16510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b'1') 16520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), b'b\n') 16530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b'2') 16540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), b'def\n') 16550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(b'3') 16560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), b'\n') 16570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.flush() 16580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(raw.getvalue(), b'1b\n2def\n3\n') 16590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16610a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CBufferedRandomTest(CBufferedReaderTest, CBufferedWriterTest, 16620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedRandomTest, SizeofTest): 16630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = io.BufferedRandom 16640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 16660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao BufferedRandomTest.test_constructor(self) 16670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The allocation can succeed on 32-bit builds, e.g. with more 16680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # than 2GB RAM and a 64-bit kernel. 16690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if sys.maxsize > 0x7FFFFFFF: 16700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.MockRawIO() 16710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.tp(rawio) 16720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises((OverflowError, MemoryError, ValueError), 16730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio.__init__, rawio, sys.maxsize) 16740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_garbage_collection(self): 16760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CBufferedReaderTest.test_garbage_collection(self) 16770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CBufferedWriterTest.test_garbage_collection(self) 16780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_args_error(self): 16800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #17275 16810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.assertRaisesRegexp(TypeError, "BufferedRandom"): 16820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.tp(io.BytesIO(), 1024, 1024, 1024) 16830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16850a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyBufferedRandomTest(BufferedRandomTest): 16860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tp = pyio.BufferedRandom 16870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 16890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# To fully exercise seek/tell, the StatefulIncrementalDecoder has these 16900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# properties: 16910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# - A single output character can correspond to many bytes of input. 16920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# - The number of input bytes to complete the character can be 16930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# undetermined until the last input byte is received. 16940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# - The number of input bytes can vary depending on previous input. 16950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# - A single input byte can correspond to many characters of output. 16960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# - The number of output characters can be undetermined until the 16970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# last input byte is received. 16980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# - The number of output characters can vary depending on previous input. 16990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17000a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass StatefulIncrementalDecoder(codecs.IncrementalDecoder): 17010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """ 17020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao For testing seek/tell behavior with a stateful, buffering decoder. 17030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao Input is a sequence of words. Words may be fixed-length (length set 17050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao by input) or variable-length (period-terminated). In variable-length 17060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao mode, extra periods are ignored. Possible words are: 17070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao - 'i' followed by a number sets the input length, I (maximum 99). 17080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao When I is set to 0, words are space-terminated. 17090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao - 'o' followed by a number sets the output length, O (maximum 99). 17100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao - Any other word is converted into a word followed by a period on 17110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao the output. The output word consists of the input word truncated 17120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao or padded out with hyphens to make its length equal to O. If O 17130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao is 0, the word is output verbatim without truncating or padding. 17140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao I and O are initially set to 1. When I changes, any buffered input is 17150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao re-scanned according to the new I. EOF also terminates the last word. 17160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """ 17170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __init__(self, errors='strict'): 17190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao codecs.IncrementalDecoder.__init__(self, errors) 17200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.reset() 17210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __repr__(self): 17230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return '<SID %x>' % id(self) 17240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def reset(self): 17260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.i = 1 17270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.o = 1 17280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.buffer = bytearray() 17290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def getstate(self): 17310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao i, o = self.i ^ 1, self.o ^ 1 # so that flags = 0 after reset() 17320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return bytes(self.buffer), i*100 + o 17330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def setstate(self, state): 17350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buffer, io = state 17360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.buffer = bytearray(buffer) 17370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao i, o = divmod(io, 100) 17380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.i, self.o = i ^ 1, o ^ 1 17390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def decode(self, input, final=False): 17410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output = '' 17420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for b in input: 17430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if self.i == 0: # variable-length, terminated with period 17440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if b == '.': 17450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if self.buffer: 17460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output += self.process_word() 17470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 17480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.buffer.append(b) 17490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: # fixed-length, terminate after self.i bytes 17500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.buffer.append(b) 17510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if len(self.buffer) == self.i: 17520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output += self.process_word() 17530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if final and self.buffer: # EOF terminates the last word 17540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output += self.process_word() 17550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return output 17560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def process_word(self): 17580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output = '' 17590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if self.buffer[0] == ord('i'): 17600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.i = min(99, int(self.buffer[1:] or 0)) # set input length 17610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao elif self.buffer[0] == ord('o'): 17620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.o = min(99, int(self.buffer[1:] or 0)) # set output length 17630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 17640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output = self.buffer.decode('ascii') 17650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if len(output) < self.o: 17660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output += '-'*self.o # pad out with hyphens 17670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if self.o: 17680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output = output[:self.o] # truncate to output length 17690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao output += '.' 17700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.buffer = bytearray() 17710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return output 17720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao codecEnabled = False 17740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @classmethod 17760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def lookupTestDecoder(cls, name): 17770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if cls.codecEnabled and name == 'test_decoder': 17780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao latin1 = codecs.lookup('latin-1') 17790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return codecs.CodecInfo( 17800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao name='test_decoder', encode=latin1.encode, decode=None, 17810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao incrementalencoder=None, 17820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao streamreader=None, streamwriter=None, 17830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao incrementaldecoder=cls) 17840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# Register the previous decoder for testing. 17860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# Disabled by default, tests will enable it. 17870a8c90248264a8b26970b4473770bcc3df8515fJosh Gaocodecs.register(StatefulIncrementalDecoder.lookupTestDecoder) 17880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17900a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass StatefulIncrementalDecoderTest(unittest.TestCase): 17910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """ 17920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao Make sure the StatefulIncrementalDecoder actually works. 17930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """ 17940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 17950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_cases = [ 17960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # I=1, O=1 (fixed-length input == fixed-length output) 17970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (b'abcd', False, 'a.b.c.d.'), 17980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # I=0, O=0 (variable-length input, variable-length output) 17990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (b'oiabcd', True, 'abcd.'), 18000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # I=0, O=0 (should ignore extra periods) 18010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (b'oi...abcd...', True, 'abcd.'), 18020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # I=0, O=6 (variable-length input, fixed-length output) 18030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (b'i.o6.x.xyz.toolongtofit.', False, 'x-----.xyz---.toolon.'), 18040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # I=2, O=6 (fixed-length input < fixed-length output) 18050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (b'i.i2.o6xyz', True, 'xy----.z-----.'), 18060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # I=6, O=3 (fixed-length input > fixed-length output) 18070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (b'i.o3.i6.abcdefghijklmnop', True, 'abc.ghi.mno.'), 18080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # I=0, then 3; O=29, then 15 (with longer output) 18090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (b'i.o29.a.b.cde.o15.abcdefghijabcdefghij.i3.a.b.c.d.ei00k.l.m', True, 18100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'a----------------------------.' + 18110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'b----------------------------.' + 18120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'cde--------------------------.' + 18130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'abcdefghijabcde.' + 18140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'a.b------------.' + 18150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao '.c.------------.' + 18160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'd.e------------.' + 18170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'k--------------.' + 18180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'l--------------.' + 18190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'm--------------.') 18200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ] 18210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_decoder(self): 18230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Try a few one-shot test cases. 18240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for input, eof, output in self.test_cases: 18250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao d = StatefulIncrementalDecoder() 18260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(d.decode(input, eof), output) 18270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Also test an unfinished decode, followed by forcing EOF. 18290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao d = StatefulIncrementalDecoder() 18300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(d.decode(b'oiabcd'), '') 18310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(d.decode(b'', 1), 'abcd.') 18320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18330a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass TextIOWrapperTest(unittest.TestCase): 18340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def setUp(self): 18360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.testdata = b"AAA\r\nBBB\rCCC\r\nDDD\nEEE\r\n" 18370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.normalized = b"AAA\nBBB\nCCC\nDDD\nEEE\n".decode("ascii") 18380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.unlink(support.TESTFN) 18390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def tearDown(self): 18410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.unlink(support.TESTFN) 18420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_constructor(self): 18440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r = self.BytesIO(b"\xc3\xa9\n\n") 18450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BufferedReader(r, 1000) 18460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b) 18470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.__init__(b, encoding="latin1", newline="\r\n") 18480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.encoding, "latin1") 18490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.line_buffering, False) 18500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.__init__(b, encoding="utf8", line_buffering=True) 18510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.encoding, "utf8") 18520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.line_buffering, True) 18530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual("\xe9\n", t.readline()) 18540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, t.__init__, b, newline=42) 18550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, t.__init__, b, newline='xyzzy') 18560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_detach(self): 18580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r = self.BytesIO() 18590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BufferedWriter(r) 18600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b) 18610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIs(t.detach(), b) 18620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii") 18640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("howdy") 18650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertFalse(r.getvalue()) 18660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.detach() 18670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(r.getvalue(), b"howdy") 18680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, t.detach) 18690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_repr(self): 18710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw = self.BytesIO("hello".encode("utf-8")) 18720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BufferedReader(raw) 18730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="utf-8") 18740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao modname = self.TextIOWrapper.__module__ 18750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(t), 18760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "<%s.TextIOWrapper encoding='utf-8'>" % modname) 18770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.name = "dummy" 18780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(t), 18790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "<%s.TextIOWrapper name=u'dummy' encoding='utf-8'>" % modname) 18800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raw.name = b"dummy" 18810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(repr(t), 18820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "<%s.TextIOWrapper name='dummy' encoding='utf-8'>" % modname) 18830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_line_buffering(self): 18850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r = self.BytesIO() 18860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BufferedWriter(r, 1000) 18870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, newline="\n", line_buffering=True) 18880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("X") 18890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(r.getvalue(), b"") # No flush happened 18900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("Y\nZ") 18910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(r.getvalue(), b"XY\nZ") # All got flushed 18920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("A\rB") 18930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(r.getvalue(), b"XY\nZA\rB") 18940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 18950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_encoding(self): 18960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Check the encoding attribute is always set, and valid 18970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO() 18980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="utf8") 18990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.encoding, "utf8") 19000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b) 19010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(t.encoding is not None) 19020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao codecs.lookup(t.encoding) 19030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 19040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_encoding_errors_reading(self): 19050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (1) default 19060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO(b"abc\n\xff\n") 19070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii") 19080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(UnicodeError, t.read) 19090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (2) explicit strict 19100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO(b"abc\n\xff\n") 19110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii", errors="strict") 19120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(UnicodeError, t.read) 19130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (3) ignore 19140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO(b"abc\n\xff\n") 19150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii", errors="ignore") 19160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.read(), "abc\n\n") 19170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (4) replace 19180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO(b"abc\n\xff\n") 19190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii", errors="replace") 19200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.read(), "abc\n\ufffd\n") 19210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 19220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_encoding_errors_writing(self): 19230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (1) default 19240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO() 19250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii") 19260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(UnicodeError, t.write, "\xff") 19270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (2) explicit strict 19280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO() 19290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii", errors="strict") 19300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(UnicodeError, t.write, "\xff") 19310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (3) ignore 19320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO() 19330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii", errors="ignore", 19340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao newline="\n") 19350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("abc\xffdef\n") 19360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.flush() 19370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b.getvalue(), b"abcdef\n") 19380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # (4) replace 19390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO() 19400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii", errors="replace", 19410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao newline="\n") 19420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("abc\xffdef\n") 19430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.flush() 19440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b.getvalue(), b"abc?def\n") 19450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 19460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_newlines(self): 19470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ] 19480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 19490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tests = [ 19500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ None, [ 'unix\n', 'windows\n', 'os9\n', 'last\n', 'nonl' ] ], 19510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ '', input_lines ], 19520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ '\n', [ "unix\n", "windows\r\n", "os9\rlast\n", "nonl" ] ], 19530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ '\r\n', [ "unix\nwindows\r\n", "os9\rlast\nnonl" ] ], 19540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao [ '\r', [ "unix\nwindows\r", "\nos9\r", "last\nnonl" ] ], 19550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ] 19560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encodings = ( 19570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'utf-8', 'latin-1', 19580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'utf-16', 'utf-16-le', 'utf-16-be', 19590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'utf-32', 'utf-32-le', 'utf-32-be', 19600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 19610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 19620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Try a range of buffer sizes to test the case where \r is the last 19630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # character in TextIOWrapper._pending_line. 19640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for encoding in encodings: 19650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # XXX: str.encode() should return bytes 19660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = bytes(''.join(input_lines).encode(encoding)) 19670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for do_reads in (False, True): 19680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for bufsize in range(1, 10): 19690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for newline, exp_lines in tests: 19700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao bufio = self.BufferedReader(self.BytesIO(data), bufsize) 19710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao textio = self.TextIOWrapper(bufio, newline=newline, 19720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encoding=encoding) 19730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if do_reads: 19740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao got_lines = [] 19750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 19760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c2 = textio.read(2) 19770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if c2 == '': 19780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 19790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(c2), 2) 19800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao got_lines.append(c2 + textio.readline()) 19810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 19820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao got_lines = list(textio) 19830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 19840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for got_line, exp_line in zip(got_lines, exp_lines): 19850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(got_line, exp_line) 19860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(got_lines), len(exp_lines)) 19870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 19880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_newlines_input(self): 19890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG" 19900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao normalized = testdata.replace(b"\r\n", b"\n").replace(b"\r", b"\n") 19910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for newline, expected in [ 19920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao (None, normalized.decode("ascii").splitlines(True)), 19930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ("", testdata.decode("ascii").splitlines(True)), 19940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ("\n", ["AAA\n", "BB\x00B\n", "CCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]), 19950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ("\r\n", ["AAA\nBB\x00B\nCCC\rDDD\rEEE\r\n", "FFF\r\n", "GGG"]), 19960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ("\r", ["AAA\nBB\x00B\nCCC\r", "DDD\r", "EEE\r", "\nFFF\r", "\nGGG"]), 19970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ]: 19980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.BytesIO(testdata) 19990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline) 20000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(txt.readlines(), expected) 20010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.seek(0) 20020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(txt.read(), "".join(expected)) 20030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 20040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_newlines_output(self): 20050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao testdict = { 20060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "": b"AAA\nBBB\nCCC\nX\rY\r\nZ", 20070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "\n": b"AAA\nBBB\nCCC\nX\rY\r\nZ", 20080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "\r": b"AAA\rBBB\rCCC\rX\rY\r\rZ", 20090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "\r\n": b"AAA\r\nBBB\r\nCCC\r\nX\rY\r\r\nZ", 20100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao } 20110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tests = [(None, testdict[os.linesep])] + sorted(testdict.items()) 20120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for newline, expected in tests: 20130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.BytesIO() 20140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline) 20150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.write("AAA\nB") 20160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.write("BB\nCCC\n") 20170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.write("X\rY\r\nZ") 20180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.flush() 20190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(buf.closed, False) 20200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(buf.getvalue(), expected) 20210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 20220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_destructor(self): 20230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao l = [] 20240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao base = self.BytesIO 20250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class MyBytesIO(base): 20260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def close(self): 20270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao l.append(self.getvalue()) 20280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao base.close(self) 20290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = MyBytesIO() 20300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii") 20310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("abc") 20320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del t 20330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 20340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual([b"abc"], l) 20350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 20360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_override_destructor(self): 20370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record = [] 20380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class MyTextIO(self.TextIOWrapper): 20390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def __del__(self): 20400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(1) 20410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 20420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = super(MyTextIO, self).__del__ 20430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except AttributeError: 20440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 20450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 20460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f() 20470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def close(self): 20480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(2) 20490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyTextIO, self).close() 20500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def flush(self): 20510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao record.append(3) 20520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao super(MyTextIO, self).flush() 20530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BytesIO() 20540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = MyTextIO(b, encoding="ascii") 20550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del t 20560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 20570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(record, [1, 2, 3]) 20580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 20590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_error_through_destructor(self): 20600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test that the exception state is not modified by a destructor, 20610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # even if close() fails. 20620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = self.CloseFailureIO() 20630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def f(): 20640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.TextIOWrapper(rawio).xyzzy 20650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with support.captured_output("stderr") as s: 20660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(AttributeError, f) 20670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = s.getvalue().strip() 20680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if s: 20690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The destructor *may* have printed an unraisable error, check it 20700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(s.splitlines()), 1) 20710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(s.startswith("Exception IOError: "), s) 20720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(s.endswith(" ignored"), s) 20730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 20740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Systematic tests of the text I/O API 20750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 20760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_basic_io(self): 20770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for chunksize in (1, 2, 3, 4, 5, 15, 16, 17, 31, 32, 33, 63, 64, 65): 20780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le": 20790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "w+", encoding=enc) 20800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f._CHUNK_SIZE = chunksize 20810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write("abc"), 3) 20820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 20830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "r+", encoding=enc) 20840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f._CHUNK_SIZE = chunksize 20850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), 0) 20860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), "abc") 20870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao cookie = f.tell() 20880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0), 0) 20890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(None), "abc") 20900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 20910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(2), "ab") 20920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(1), "c") 20930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(1), "") 20940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), "") 20950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), cookie) 20960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0), 0) 20970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(0, 2), cookie) 20980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.write("def"), 3) 20990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.seek(cookie), cookie) 21000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), "def") 21010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if enc.startswith("utf"): 21020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.multi_line_test(f, enc) 21030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 21040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 21050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def multi_line_test(self, f, enc): 21060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 21070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.truncate() 21080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sample = "s\xff\u0fff\uffff" 21090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wlines = [] 21100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for size in (0, 1, 2, 3, 4, 5, 30, 31, 32, 33, 62, 63, 64, 65, 1000): 21110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao chars = [] 21120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(size): 21130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao chars.append(sample[i % len(sample)]) 21140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao line = "".join(chars) + "\n" 21150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wlines.append((f.tell(), line)) 21160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(line) 21170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 21180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rlines = [] 21190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 21200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = f.tell() 21210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao line = f.readline() 21220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not line: 21230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 21240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rlines.append((pos, line)) 21250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(rlines, wlines) 21260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 21270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_telling(self): 21280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "w+", encoding="utf8") 21290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao p0 = f.tell() 21300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write("\xff\n") 21310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao p1 = f.tell() 21320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write("\xff\n") 21330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao p2 = f.tell() 21340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 21350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), p0) 21360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), "\xff\n") 21370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), p1) 21380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), "\xff\n") 21390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), p2) 21400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 21410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for line in f: 21420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(line, "\xff\n") 21430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, f.tell) 21440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), p2) 21450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 21460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 21470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_seeking(self): 21480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao chunk_size = _default_chunk_size() 21490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao prefix_size = chunk_size - 2 21500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao u_prefix = "a" * prefix_size 21510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao prefix = bytes(u_prefix.encode("utf-8")) 21520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(len(u_prefix), len(prefix)) 21530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao u_suffix = "\u8888\n" 21540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao suffix = bytes(u_suffix.encode("utf-8")) 21550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao line = prefix + suffix 21560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "wb") 21570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(line*2) 21580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 21590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "r", encoding="utf-8") 21600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = f.read(prefix_size) 21610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(s, prefix.decode("ascii")) 21620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.tell(), prefix_size) 21630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.readline(), u_suffix) 21640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 21650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_seeking_too(self): 21660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Regression test for a specific bug 21670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = b'\xe0\xbf\xbf\n' 21680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "wb") 21690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(data) 21700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 21710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "r", encoding="utf-8") 21720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f._CHUNK_SIZE # Just test that it exists 21730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f._CHUNK_SIZE = 2 21740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.readline() 21750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.tell() 21760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 21770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_seek_and_tell(self): 21780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao #Test seek/tell using the StatefulIncrementalDecoder. 21790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Make test faster by doing smaller seeks 21800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CHUNK_SIZE = 128 21810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 21820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_seek_and_tell_with_data(data, min_pos=0): 21830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """Tell/seek to various points within a data stream and ensure 21840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao that the decoded data returned by read() is consistent.""" 21850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, 'wb') 21860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(data) 21870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 21880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, encoding='test_decoder') 21890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f._CHUNK_SIZE = CHUNK_SIZE 21900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoded = f.read() 21910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 21920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 21930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(min_pos, len(decoded) + 1): # seek positions 21940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for j in [1, 5, len(decoded) - i]: # read lengths 21950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, encoding='test_decoder') 21960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(i), decoded[:i]) 21970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao cookie = f.tell() 21980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(j), decoded[i:i + j]) 21990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(cookie) 22000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), decoded[i:]) 22010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 22020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Enable the test decoder. 22040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao StatefulIncrementalDecoder.codecEnabled = 1 22050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Run the tests. 22070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 22080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Try each test case. 22090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for input, _, _ in StatefulIncrementalDecoderTest.test_cases: 22100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_seek_and_tell_with_data(input) 22110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Position each test case so that it crosses a chunk boundary. 22130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for input, _, _ in StatefulIncrementalDecoderTest.test_cases: 22140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao offset = CHUNK_SIZE - len(input)//2 22150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao prefix = b'.'*offset 22160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Don't bother seeking into the prefix (takes too long). 22170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao min_pos = offset*2 22180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_seek_and_tell_with_data(prefix + input, min_pos) 22190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Ensure our test decoder won't interfere with subsequent tests. 22210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 22220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao StatefulIncrementalDecoder.codecEnabled = 0 22230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_encoded_writes(self): 22250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao data = "1234567890" 22260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tests = ("utf-16", 22270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "utf-16-le", 22280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "utf-16-be", 22290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "utf-32", 22300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "utf-32-le", 22310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao "utf-32-be") 22320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for encoding in tests: 22330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.BytesIO() 22340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.TextIOWrapper(buf, encoding=encoding) 22350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Check if the BOM is written only once (see issue1753). 22360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(data) 22370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(data) 22380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 22390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), data * 2) 22400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 22410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), data * 2) 22420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(buf.getvalue(), (data * 2).encode(encoding)) 22430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_unreadable(self): 22450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class UnReadable(self.BytesIO): 22460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def readable(self): 22470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao return False 22480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(UnReadable()) 22490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, txt.read) 22500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_one_by_one(self): 22520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(b"AA\r\nBB")) 22530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads = "" 22540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 22550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = txt.read(1) 22560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not c: 22570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 22580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += c 22590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reads, "AA\nBB") 22600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readlines(self): 22620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(b"AA\nBB\nCC")) 22630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(txt.readlines(), ["AA\n", "BB\n", "CC"]) 22640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.seek(0) 22650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(txt.readlines(None), ["AA\n", "BB\n", "CC"]) 22660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.seek(0) 22670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(txt.readlines(5), ["AA\n", "BB\n"]) 22680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # read in amounts equal to TextIOWrapper._CHUNK_SIZE which is 128. 22700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_by_chunk(self): 22710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # make sure "\r\n" straddles 128 char boundary. 22720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(b"A" * 127 + b"\r\nB")) 22730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads = "" 22740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 22750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = txt.read(128) 22760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not c: 22770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 22780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += c 22790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reads, "A"*127+"\nB") 22800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writelines(self): 22820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao l = ['ab', 'cd', 'ef'] 22830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.BytesIO() 22840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(buf) 22850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.writelines(l) 22860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.flush() 22870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(buf.getvalue(), b'abcdef') 22880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writelines_userlist(self): 22900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao l = UserList(['ab', 'cd', 'ef']) 22910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.BytesIO() 22920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(buf) 22930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.writelines(l) 22940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.flush() 22950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(buf.getvalue(), b'abcdef') 22960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 22970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_writelines_error(self): 22980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO()) 22990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, txt.writelines, [1, 2, 3]) 23000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, txt.writelines, None) 23010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, txt.writelines, b'abc') 23020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_issue1395_1(self): 23040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 23050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # read one char at a time 23070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads = "" 23080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 23090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = txt.read(1) 23100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not c: 23110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 23120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += c 23130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reads, self.normalized) 23140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_issue1395_2(self): 23160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 23170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt._CHUNK_SIZE = 4 23180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads = "" 23200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 23210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = txt.read(4) 23220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if not c: 23230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 23240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += c 23250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reads, self.normalized) 23260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_issue1395_3(self): 23280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 23290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt._CHUNK_SIZE = 4 23300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads = txt.read(4) 23320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += txt.read(4) 23330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += txt.readline() 23340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += txt.readline() 23350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += txt.readline() 23360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reads, self.normalized) 23370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_issue1395_4(self): 23390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 23400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt._CHUNK_SIZE = 4 23410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads = txt.read(4) 23430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads += txt.read() 23440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(reads, self.normalized) 23450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_issue1395_5(self): 23470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 23480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt._CHUNK_SIZE = 4 23490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao reads = txt.read(4) 23510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = txt.tell() 23520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.seek(0) 23530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.seek(pos) 23540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(txt.read(4), "BBB\n") 23550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_issue2282(self): 23570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buffer = self.BytesIO(self.testdata) 23580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(buffer, encoding="ascii") 23590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(buffer.seekable(), txt.seekable()) 23610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_append_bom(self): 23630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The BOM is not written again when appending to a non-empty file 23640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao filename = support.TESTFN 23650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for charset in ('utf-8-sig', 'utf-16', 'utf-32'): 23660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(filename, 'w', encoding=charset) as f: 23670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write('aaa') 23680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = f.tell() 23690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(filename, 'rb') as f: 23700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), 'aaa'.encode(charset)) 23710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(filename, 'a', encoding=charset) as f: 23730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write('xxx') 23740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(filename, 'rb') as f: 23750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), 'aaaxxx'.encode(charset)) 23760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_seek_bom(self): 23780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Same test, but when seeking manually 23790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao filename = support.TESTFN 23800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for charset in ('utf-8-sig', 'utf-16', 'utf-32'): 23810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(filename, 'w', encoding=charset) as f: 23820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write('aaa') 23830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pos = f.tell() 23840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(filename, 'r+', encoding=charset) as f: 23850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(pos) 23860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write('zzz') 23870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.seek(0) 23880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write('bbb') 23890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(filename, 'rb') as f: 23900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), 'bbbzzz'.encode(charset)) 23910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_errors_property(self): 23930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "w") as f: 23940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.errors, "strict") 23950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "w", errors="replace") as f: 23960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.errors, "replace") 23970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 23980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipUnless(threading, 'Threading required for this test.') 23990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_threads_write(self): 24000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue6750: concurrent writes could duplicate data 24010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao event = threading.Event() 24020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "w", buffering=1) as f: 24030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def run(n): 24040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao text = "Thread%03d\n" % n 24050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao event.wait() 24060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.write(text) 24070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao threads = [threading.Thread(target=lambda n=x: run(n)) 24080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for x in range(20)] 24090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for t in threads: 24100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.start() 24110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao time.sleep(0.02) 24120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao event.set() 24130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for t in threads: 24140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.join() 24150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN) as f: 24160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao content = f.read() 24170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for n in range(20): 24180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(content.count("Thread%03d\n" % n), 1) 24190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_flush_error_on_close(self): 24210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 24220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def bad_flush(): 24230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise IOError() 24240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.flush = bad_flush 24250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(IOError, txt.close) # exception not swallowed 24260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(txt.closed) 24270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_multi_close(self): 24290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 24300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.close() 24310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.close() 24320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.close() 24330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, txt.flush) 24340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_readonly_attributes(self): 24360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") 24370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao buf = self.BytesIO(self.testdata) 24380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.assertRaises((AttributeError, TypeError)): 24390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao txt.buffer = buf 24400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_read_nonbytes(self): 24420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #17106 24430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Crash when underlying read() returns non-bytes 24440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class NonbytesStream(self.StringIO): 24450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read1 = self.StringIO.read 24460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class NonbytesStream(self.StringIO): 24470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read1 = self.StringIO.read 24480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(NonbytesStream('a')) 24490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.maybeRaises(TypeError): 24500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.read(1) 24510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(NonbytesStream('a')) 24520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.maybeRaises(TypeError): 24530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.readline() 24540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(NonbytesStream('a')) 24550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(t.read(), u'a') 24560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_illegal_decoder(self): 24580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue #17106 24590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Crash when decoder returns non-string 24600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(self.BytesIO(b'aaaaaa'), newline='\n', 24610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encoding='quopri_codec') 24620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.maybeRaises(TypeError): 24630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.read(1) 24640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(self.BytesIO(b'aaaaaa'), newline='\n', 24650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encoding='quopri_codec') 24660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.maybeRaises(TypeError): 24670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.readline() 24680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(self.BytesIO(b'aaaaaa'), newline='\n', 24690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encoding='quopri_codec') 24700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.maybeRaises(TypeError): 24710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.read() 24720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24740a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CTextIOWrapperTest(TextIOWrapperTest): 24750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_initialization(self): 24770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r = self.BytesIO(b"\xc3\xa9\n\n") 24780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BufferedReader(r, 1000) 24790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b) 24800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, t.__init__, b, newline=42) 24810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, t.read) 24820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, t.__init__, b, newline='xyzzy') 24830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, t.read) 24840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 24850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_garbage_collection(self): 24860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # C TextIOWrapper objects are collected, and collecting them flushes 24870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # all data to disk. 24880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The Python version has __del__, so it ends in gc.garbage instead. 24890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rawio = io.FileIO(support.TESTFN, "wb") 24900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BufferedWriter(rawio) 24910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = self.TextIOWrapper(b, encoding="ascii") 24920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.write("456def") 24930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.x = t 24940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wr = weakref.ref(t) 24950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del t 24960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 24970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(wr() is None, wr) 24980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "rb") as f: 24990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.read(), b"456def") 25000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_rwpair_cleared_before_textio(self): 25020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue 13070: TextIOWrapper's finalization would crash when called 25030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # after the reference to the underlying BufferedRWPair's writer got 25040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # cleared by the GC. 25050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(1000): 25060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b1 = self.BufferedRWPair(self.MockRawIO(), self.MockRawIO()) 25070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t1 = self.TextIOWrapper(b1, encoding="ascii") 25080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b2 = self.BufferedRWPair(self.MockRawIO(), self.MockRawIO()) 25090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t2 = self.TextIOWrapper(b2, encoding="ascii") 25100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # circular references 25110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t1.buddy = t2 25120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t2.buddy = t1 25130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 25140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao maybeRaises = unittest.TestCase.assertRaises 25160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25180a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyTextIOWrapperTest(TextIOWrapperTest): 25190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @contextlib.contextmanager 25200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def maybeRaises(self, *args, **kwds): 25210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao yield 25220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25240a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass IncrementalNewlineDecoderTest(unittest.TestCase): 25250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_newline_decoding_utf8(self, decoder): 25270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # UTF-8 specific tests for a newline decoder 25280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _check_decode(b, s, **kwargs): 25290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # We exercise getstate() / setstate() as well as decode() 25300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao state = decoder.getstate() 25310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.decode(b, **kwargs), s) 25320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoder.setstate(state) 25330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.decode(b, **kwargs), s) 25340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xe8\xa2\x88', "\u8888") 25360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xe8', "") 25380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xa2', "") 25390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\x88', "\u8888") 25400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xe8', "") 25420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xa2', "") 25430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\x88', "\u8888") 25440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xe8', "") 25460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(UnicodeDecodeError, decoder.decode, b'', final=True) 25470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoder.reset() 25490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\n', "\n") 25500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\r', "") 25510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'', "\n", final=True) 25520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\r', "\n", final=True) 25530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\r', "") 25550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'a', "\na") 25560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\r\r\n', "\n\n") 25580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\r', "") 25590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\r', "\n") 25600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\na', "\na") 25610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xe8\xa2\x88\r\n', "\u8888\n") 25630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xe8\xa2\x88', "\u8888") 25640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\n', "\n") 25650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\xe8\xa2\x88\r', "\u8888") 25660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check_decode(b'\n', "\n") 25670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 25680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_newline_decoding(self, decoder, encoding): 25690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao result = [] 25700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if encoding is not None: 25710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encoder = codecs.getincrementalencoder(encoding)() 25720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _decode_bytewise(s): 25730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Decode one byte at a time 25740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for b in encoder.encode(s): 25750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao result.append(decoder.decode(b)) 25760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao else: 25770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encoder = None 25780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _decode_bytewise(s): 25790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Decode one char at a time 25800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for c in s: 25810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao result.append(decoder.decode(c)) 25820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.newlines, None) 25830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _decode_bytewise("abc\n\r") 25840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.newlines, '\n') 25850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _decode_bytewise("\nabc") 25860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.newlines, ('\n', '\r\n')) 25870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _decode_bytewise("abc\r") 25880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.newlines, ('\n', '\r\n')) 25890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _decode_bytewise("abc") 25900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.newlines, ('\r', '\n', '\r\n')) 25910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _decode_bytewise("abc\r") 25920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual("".join(result), "abc\n\nabcabc\nabcabc") 25930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoder.reset() 25940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao input = "abc" 25950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if encoder is not None: 25960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encoder.reset() 25970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao input = encoder.encode(input) 25980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.decode(input), "abc") 25990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decoder.newlines, None) 26000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_newline_decoder(self): 26020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao encodings = ( 26030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # None meaning the IncrementalNewlineDecoder takes unicode input 26040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # rather than bytes input 26050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao None, 'utf-8', 'latin-1', 26060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'utf-16', 'utf-16-le', 'utf-16-be', 26070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'utf-32', 'utf-32-le', 'utf-32-be', 26080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 26090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for enc in encodings: 26100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoder = enc and codecs.getincrementaldecoder(enc)() 26110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoder = self.IncrementalNewlineDecoder(decoder, translate=True) 26120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_newline_decoding(decoder, enc) 26130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoder = codecs.getincrementaldecoder("utf-8")() 26140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao decoder = self.IncrementalNewlineDecoder(decoder, translate=True) 26150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_newline_decoding_utf8(decoder) 26160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_newline_bytes(self): 26180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Issue 5433: Excessive optimization in IncrementalNewlineDecoder 26190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _check(dec): 26200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(dec.newlines, None) 26210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(dec.decode("\u0D00"), "\u0D00") 26220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(dec.newlines, None) 26230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(dec.decode("\u0A00"), "\u0A00") 26240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(dec.newlines, None) 26250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao dec = self.IncrementalNewlineDecoder(None, translate=False) 26260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check(dec) 26270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao dec = self.IncrementalNewlineDecoder(None, translate=True) 26280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao _check(dec) 26290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26300a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CIncrementalNewlineDecoderTest(IncrementalNewlineDecoderTest): 26310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 26320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26330a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyIncrementalNewlineDecoderTest(IncrementalNewlineDecoderTest): 26340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 26350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao# XXX Tests for open() 26380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26390a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass MiscIOTest(unittest.TestCase): 26400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def tearDown(self): 26420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.unlink(support.TESTFN) 26430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test___all__(self): 26450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for name in self.io.__all__: 26460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao obj = getattr(self.io, name, None) 26470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(obj is not None, name) 26480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if name == "open": 26490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao continue 26500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao elif "error" in name.lower() or name == "UnsupportedOperation": 26510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(issubclass(obj, Exception), name) 26520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao elif not name.startswith("SEEK_"): 26530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(issubclass(obj, self.IOBase)) 26540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_attributes(self): 26560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "wb", buffering=0) 26570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.mode, "wb") 26580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 26590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "U") 26610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.name, support.TESTFN) 26620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.buffer.name, support.TESTFN) 26630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.buffer.raw.name, support.TESTFN) 26640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.mode, "U") 26650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.buffer.mode, "rb") 26660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.buffer.raw.mode, "rb") 26670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 26680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, "w+") 26700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.mode, "w+") 26710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.buffer.mode, "rb+") # Does it really matter? 26720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(f.buffer.raw.mode, "rb+") 26730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao g = self.open(f.fileno(), "wb", closefd=False) 26750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(g.mode, "wb") 26760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(g.raw.mode, "wb") 26770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(g.name, f.fileno()) 26780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(g.raw.name, f.fileno()) 26790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 26800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao g.close() 26810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 26820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_io_after_close(self): 26830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for kwargs in [ 26840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w"}, 26850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "wb"}, 26860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w", "buffering": 1}, 26870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w", "buffering": 2}, 26880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "wb", "buffering": 0}, 26890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "r"}, 26900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "rb"}, 26910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "r", "buffering": 1}, 26920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "r", "buffering": 2}, 26930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "rb", "buffering": 0}, 26940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w+"}, 26950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w+b"}, 26960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w+", "buffering": 1}, 26970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w+", "buffering": 2}, 26980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao {"mode": "w+b", "buffering": 0}, 26990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ]: 27000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f = self.open(support.TESTFN, **kwargs) 27010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao f.close() 27020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.flush) 27030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.fileno) 27040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.isatty) 27050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.__iter__) 27060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if hasattr(f, "peek"): 27070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.peek, 1) 27080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.read) 27090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if hasattr(f, "read1"): 27100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.read1, 1024) 27110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if hasattr(f, "readall"): 27120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.readall) 27130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if hasattr(f, "readinto"): 27140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.readinto, bytearray(1024)) 27150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.readline) 27160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.readlines) 27170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.seek, 0) 27180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.tell) 27190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.truncate) 27200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.write, 27210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b"" if "b" in kwargs['mode'] else "") 27220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, f.writelines, []) 27230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ValueError, next, f) 27240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_blockingioerror(self): 27260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Various BlockingIOError issues 27270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, self.BlockingIOError) 27280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, self.BlockingIOError, 1) 27290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, self.BlockingIOError, 1, 2, 3, 4) 27300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(TypeError, self.BlockingIOError, 1, "", None) 27310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BlockingIOError(1, "") 27320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(b.characters_written, 0) 27330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao class C(unicode): 27340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao pass 27350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c = C("") 27360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b = self.BlockingIOError(1, c) 27370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c.b = b 27380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao b.c = c 27390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wr = weakref.ref(c) 27400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao del c, b 27410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.gc_collect() 27420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(wr() is None, wr) 27430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_abcs(self): 27450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test the visible base classes are ABCs. 27460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(self.IOBase, abc.ABCMeta) 27470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(self.RawIOBase, abc.ABCMeta) 27480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(self.BufferedIOBase, abc.ABCMeta) 27490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(self.TextIOBase, abc.ABCMeta) 27500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _check_abc_inheritance(self, abcmodule): 27520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb", buffering=0) as f: 27530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(f, abcmodule.IOBase) 27540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(f, abcmodule.RawIOBase) 27550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIsInstance(f, abcmodule.BufferedIOBase) 27560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIsInstance(f, abcmodule.TextIOBase) 27570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "wb") as f: 27580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(f, abcmodule.IOBase) 27590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIsInstance(f, abcmodule.RawIOBase) 27600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(f, abcmodule.BufferedIOBase) 27610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIsInstance(f, abcmodule.TextIOBase) 27620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.open(support.TESTFN, "w") as f: 27630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(f, abcmodule.IOBase) 27640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIsInstance(f, abcmodule.RawIOBase) 27650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotIsInstance(f, abcmodule.BufferedIOBase) 27660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertIsInstance(f, abcmodule.TextIOBase) 27670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_abc_inheritance(self): 27690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test implementations inherit from their respective ABCs 27700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._check_abc_inheritance(self) 27710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_abc_inheritance_official(self): 27730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Test implementations inherit from the official ABCs of the 27740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # baseline "io" module. 27750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._check_abc_inheritance(io) 27760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipUnless(fcntl, 'fcntl required for this test') 27780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_nonblock_pipe_write_bigbuf(self): 27790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._test_nonblock_pipe_write(16*1024) 27800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipUnless(fcntl, 'fcntl required for this test') 27820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_nonblock_pipe_write_smallbuf(self): 27830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._test_nonblock_pipe_write(1024) 27840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _set_non_blocking(self, fd): 27860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao flags = fcntl.fcntl(fd, fcntl.F_GETFL) 27870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertNotEqual(flags, -1) 27880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao res = fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK) 27890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(res, 0) 27900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _test_nonblock_pipe_write(self, bufsize): 27920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sent = [] 27930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao received = [] 27940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r, w = os.pipe() 27950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._set_non_blocking(r) 27960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self._set_non_blocking(w) 27970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 27980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # To exercise all code paths in the C implementation we need 27990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # to play with buffer sizes. For instance, if we choose a 28000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # buffer size less than or equal to _PIPE_BUF (4096 on Linux) 28010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # then we will never get a partial write of the buffer. 28020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rf = self.open(r, mode='rb', closefd=True, buffering=bufsize) 28030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wf = self.open(w, mode='wb', closefd=True, buffering=bufsize) 28040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with rf, wf: 28060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for N in 9999, 73, 7574: 28070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 28080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao i = 0 28090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 28100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao msg = bytes([i % 26 + 97]) * N 28110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sent.append(msg) 28120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wf.write(msg) 28130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao i += 1 28140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except self.BlockingIOError as e: 28160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(e.args[0], errno.EAGAIN) 28170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sent[-1] = sent[-1][:e.characters_written] 28180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao received.append(rf.read()) 28190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao msg = b'BLOCKED' 28200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wf.write(msg) 28210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sent.append(msg) 28220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while True: 28240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 28250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wf.flush() 28260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao break 28270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except self.BlockingIOError as e: 28280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(e.args[0], errno.EAGAIN) 28290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(e.characters_written, 0) 28300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao received.append(rf.read()) 28310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao received += iter(rf.read, None) 28330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao sent, received = b''.join(sent), b''.join(received) 28350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(sent == received) 28360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(wf.closed) 28370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(rf.closed) 28380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28390a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CMiscIOTest(MiscIOTest): 28400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao io = io 28410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28420a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PyMiscIOTest(MiscIOTest): 28430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao io = pyio 28440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao@unittest.skipIf(os.name == 'nt', 'POSIX signals required for this test.') 28470a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass SignalsTest(unittest.TestCase): 28480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def setUp(self): 28500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.oldalrm = signal.signal(signal.SIGALRM, self.alarm_interrupt) 28510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def tearDown(self): 28530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.signal(signal.SIGALRM, self.oldalrm) 28540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def alarm_interrupt(self, sig, frame): 28560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1 // 0 28570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 28580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipUnless(threading, 'Threading required for this test.') 28590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipIf(sys.platform in ('freebsd5', 'freebsd6', 'freebsd7'), 28600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 'issue #12429: skip test on FreeBSD <= 7') 28610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_interrupted_write(self, item, bytes, **fdopen_kwargs): 28620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """Check that a partial write, when it gets interrupted, properly 28630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao invokes the signal handler, and bubbles up the exception raised 28640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao in the latter.""" 28650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read_results = [] 28660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _read(): 28670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = os.read(r, 1) 28680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read_results.append(s) 28690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = threading.Thread(target=_read) 28700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.daemon = True 28710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r, w = os.pipe() 28720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 28730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio = self.io.open(w, **fdopen_kwargs) 28740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.start() 28750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.alarm(1) 28760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Fill the pipe enough that the write will be blocking. 28770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # It will be interrupted by the timer armed above. Since the 28780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # other thread has read one byte, the low-level write will 28790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # return with a successful (partial) result rather than an EINTR. 28800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # The buffered IO layer must check for pending signal 28810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # handlers, which in this case will invoke alarm_interrupt(). 28820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertRaises(ZeroDivisionError, 28830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.write, item * (support.PIPE_MAX_SIZE // len(item) + 1)) 28840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.join() 28850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # We got one byte, get another one and check that it isn't a 28860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # repeat of the first one. 28870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read_results.append(os.read(r, 1)) 28880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(read_results, [bytes[0:1], bytes[1:2]]) 28890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 28900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.close(w) 28910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.close(r) 28920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This is deliberate. If we didn't close the file descriptor 28930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # before closing wio, wio would try to flush its internal 28940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # buffer, and block again. 28950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 28960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.close() 28970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except IOError as e: 28980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if e.errno != errno.EBADF: 28990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise 29000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interrupted_write_unbuffered(self): 29020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_interrupted_write(b"xy", b"xy", mode="wb", buffering=0) 29030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interrupted_write_buffered(self): 29050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_interrupted_write(b"xy", b"xy", mode="wb") 29060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interrupted_write_text(self): 29080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_interrupted_write("xy", b"xy", mode="w", encoding="ascii") 29090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_reentrant_write(self, data, **fdopen_kwargs): 29110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def on_alarm(*args): 29120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Will be called reentrantly from the same thread 29130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.write(data) 29140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 1//0 29150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.signal(signal.SIGALRM, on_alarm) 29160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r, w = os.pipe() 29170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio = self.io.open(w, **fdopen_kwargs) 29180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 29190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.alarm(1) 29200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Either the reentrant call to wio.write() fails with RuntimeError, 29210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # or the signal handler raises ZeroDivisionError. 29220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao with self.assertRaises((ZeroDivisionError, RuntimeError)) as cm: 29230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while 1: 29240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for i in range(100): 29250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.write(data) 29260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.flush() 29270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Make sure the buffer doesn't fill up and block further writes 29280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.read(r, len(data) * 100) 29290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao exc = cm.exception 29300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if isinstance(exc, RuntimeError): 29310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertTrue(str(exc).startswith("reentrant call"), str(exc)) 29320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 29330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.close() 29340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.close(r) 29350a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_reentrant_write_buffered(self): 29370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_reentrant_write(b"xy", mode="wb") 29380a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_reentrant_write_text(self): 29400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_reentrant_write("xy", mode="w", encoding="ascii") 29410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_interrupted_read_retry(self, decode, **fdopen_kwargs): 29430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """Check that a buffered read, when it gets interrupted (either 29440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao returning a partial result or EINTR), properly invokes the signal 29450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao handler and retries if the latter returned successfully.""" 29460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r, w = os.pipe() 29470a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fdopen_kwargs["closefd"] = False 29480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def alarm_handler(sig, frame): 29490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.write(w, b"bar") 29500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.signal(signal.SIGALRM, alarm_handler) 29510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 29520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rio = self.io.open(r, **fdopen_kwargs) 29530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.write(w, b"foo") 29540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.alarm(1) 29550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Expected behaviour: 29560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # - first raw read() returns partial b"foo" 29570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # - second raw read() returns EINTR 29580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # - third raw read() returns b"bar" 29590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(decode(rio.read(6)), "foobar") 29600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 29610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao rio.close() 29620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.close(w) 29630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.close(r) 29640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interrupterd_read_retry_buffered(self): 29660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_interrupted_read_retry(lambda x: x.decode('latin1'), 29670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao mode="rb") 29680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interrupterd_read_retry_text(self): 29700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_interrupted_read_retry(lambda x: x, 29710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao mode="r") 29720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 29730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao @unittest.skipUnless(threading, 'Threading required for this test.') 29740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def check_interrupted_write_retry(self, item, **fdopen_kwargs): 29750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao """Check that a buffered write, when it gets interrupted (either 29760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao returning a partial result or EINTR), properly invokes the signal 29770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao handler and retries if the latter returned successfully.""" 29780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao select = support.import_module("select") 29790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # A quantity that exceeds the buffer size of an anonymous pipe's 29800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # write end. 29810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao N = support.PIPE_MAX_SIZE 29820a8c90248264a8b26970b4473770bcc3df8515fJosh Gao r, w = os.pipe() 29830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao fdopen_kwargs["closefd"] = False 29840a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # We need a separate thread to read from the pipe and allow the 29850a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # write() to finish. This thread is started after the SIGALRM is 29860a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # received (forcing a first EINTR in write()). 29870a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read_results = [] 29880a8c90248264a8b26970b4473770bcc3df8515fJosh Gao write_finished = False 29890a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def _read(): 29900a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while not write_finished: 29910a8c90248264a8b26970b4473770bcc3df8515fJosh Gao while r in select.select([r], [], [], 1.0)[0]: 29920a8c90248264a8b26970b4473770bcc3df8515fJosh Gao s = os.read(r, 1024) 29930a8c90248264a8b26970b4473770bcc3df8515fJosh Gao read_results.append(s) 29940a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t = threading.Thread(target=_read) 29950a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.daemon = True 29960a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def alarm1(sig, frame): 29970a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.signal(signal.SIGALRM, alarm2) 29980a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.alarm(1) 29990a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def alarm2(sig, frame): 30000a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.start() 30010a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.signal(signal.SIGALRM, alarm1) 30020a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 30030a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio = self.io.open(w, **fdopen_kwargs) 30040a8c90248264a8b26970b4473770bcc3df8515fJosh Gao signal.alarm(1) 30050a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Expected behaviour: 30060a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # - first raw write() is partial (because of the limited pipe buffer 30070a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # and the first alarm) 30080a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # - second raw write() returns EINTR (because of the second alarm) 30090a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # - subsequent write()s are successful (either partial or complete) 30100a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(N, wio.write(item * N)) 30110a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.flush() 30120a8c90248264a8b26970b4473770bcc3df8515fJosh Gao write_finished = True 30130a8c90248264a8b26970b4473770bcc3df8515fJosh Gao t.join() 30140a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.assertEqual(N, sum(len(x) for x in read_results)) 30150a8c90248264a8b26970b4473770bcc3df8515fJosh Gao finally: 30160a8c90248264a8b26970b4473770bcc3df8515fJosh Gao write_finished = True 30170a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.close(w) 30180a8c90248264a8b26970b4473770bcc3df8515fJosh Gao os.close(r) 30190a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # This is deliberate. If we didn't close the file descriptor 30200a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # before closing wio, wio would try to flush its internal 30210a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # buffer, and could block (in case of failure). 30220a8c90248264a8b26970b4473770bcc3df8515fJosh Gao try: 30230a8c90248264a8b26970b4473770bcc3df8515fJosh Gao wio.close() 30240a8c90248264a8b26970b4473770bcc3df8515fJosh Gao except IOError as e: 30250a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if e.errno != errno.EBADF: 30260a8c90248264a8b26970b4473770bcc3df8515fJosh Gao raise 30270a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30280a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interrupterd_write_retry_buffered(self): 30290a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_interrupted_write_retry(b"x", mode="wb") 30300a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30310a8c90248264a8b26970b4473770bcc3df8515fJosh Gao def test_interrupterd_write_retry_text(self): 30320a8c90248264a8b26970b4473770bcc3df8515fJosh Gao self.check_interrupted_write_retry("x", mode="w", encoding="latin1") 30330a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30340a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30350a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass CSignalsTest(SignalsTest): 30360a8c90248264a8b26970b4473770bcc3df8515fJosh Gao io = io 30370a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30380a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoclass PySignalsTest(SignalsTest): 30390a8c90248264a8b26970b4473770bcc3df8515fJosh Gao io = pyio 30400a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30410a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Handling reentrancy issues would slow down _pyio even more, so the 30420a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # tests are disabled. 30430a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_reentrant_write_buffered = None 30440a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_reentrant_write_text = None 30450a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30460a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30470a8c90248264a8b26970b4473770bcc3df8515fJosh Gaodef test_main(): 30480a8c90248264a8b26970b4473770bcc3df8515fJosh Gao tests = (CIOTest, PyIOTest, 30490a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CBufferedReaderTest, PyBufferedReaderTest, 30500a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CBufferedWriterTest, PyBufferedWriterTest, 30510a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CBufferedRWPairTest, PyBufferedRWPairTest, 30520a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CBufferedRandomTest, PyBufferedRandomTest, 30530a8c90248264a8b26970b4473770bcc3df8515fJosh Gao StatefulIncrementalDecoderTest, 30540a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CIncrementalNewlineDecoderTest, PyIncrementalNewlineDecoderTest, 30550a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CTextIOWrapperTest, PyTextIOWrapperTest, 30560a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CMiscIOTest, PyMiscIOTest, 30570a8c90248264a8b26970b4473770bcc3df8515fJosh Gao CSignalsTest, PySignalsTest, 30580a8c90248264a8b26970b4473770bcc3df8515fJosh Gao ) 30590a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30600a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Put the namespaces of the IO module we are testing and some useful mock 30610a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # classes in the __dict__ of each test. 30620a8c90248264a8b26970b4473770bcc3df8515fJosh Gao mocks = (MockRawIO, MisbehavedRawIO, MockFileIO, CloseFailureIO, 30630a8c90248264a8b26970b4473770bcc3df8515fJosh Gao MockNonBlockWriterIO, MockRawIOWithoutRead) 30640a8c90248264a8b26970b4473770bcc3df8515fJosh Gao all_members = io.__all__ + ["IncrementalNewlineDecoder"] 30650a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c_io_ns = dict((name, getattr(io, name)) for name in all_members) 30660a8c90248264a8b26970b4473770bcc3df8515fJosh Gao py_io_ns = dict((name, getattr(pyio, name)) for name in all_members) 30670a8c90248264a8b26970b4473770bcc3df8515fJosh Gao globs = globals() 30680a8c90248264a8b26970b4473770bcc3df8515fJosh Gao c_io_ns.update((x.__name__, globs["C" + x.__name__]) for x in mocks) 30690a8c90248264a8b26970b4473770bcc3df8515fJosh Gao py_io_ns.update((x.__name__, globs["Py" + x.__name__]) for x in mocks) 30700a8c90248264a8b26970b4473770bcc3df8515fJosh Gao # Avoid turning open into a bound method. 30710a8c90248264a8b26970b4473770bcc3df8515fJosh Gao py_io_ns["open"] = pyio.OpenWrapper 30720a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for test in tests: 30730a8c90248264a8b26970b4473770bcc3df8515fJosh Gao if test.__name__.startswith("C"): 30740a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for name, obj in c_io_ns.items(): 30750a8c90248264a8b26970b4473770bcc3df8515fJosh Gao setattr(test, name, obj) 30760a8c90248264a8b26970b4473770bcc3df8515fJosh Gao elif test.__name__.startswith("Py"): 30770a8c90248264a8b26970b4473770bcc3df8515fJosh Gao for name, obj in py_io_ns.items(): 30780a8c90248264a8b26970b4473770bcc3df8515fJosh Gao setattr(test, name, obj) 30790a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30800a8c90248264a8b26970b4473770bcc3df8515fJosh Gao support.run_unittest(*tests) 30810a8c90248264a8b26970b4473770bcc3df8515fJosh Gao 30820a8c90248264a8b26970b4473770bcc3df8515fJosh Gaoif __name__ == "__main__": 30830a8c90248264a8b26970b4473770bcc3df8515fJosh Gao test_main() 3084