Your IP : 216.73.216.213

Current Path : /opt/alt/python35/lib64/python3.5/test/__pycache__/
Upload File :
Current File : //opt/alt/python35/lib64/python3.5/test/__pycache__/test_io.cpython-35.opt-1.pyc



��Yf,C�@s'dZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
Z
ddlmZmZddlmZmZddlmZddlmZmZddlZddlZddlZyddlZWnek
rBdZYnXyddlZWnek
rsdd�Z Yn&Xd	d�Z Gd
d�dej!�Z"dd
�Z#Gdd�d�Z$Gdd�de$ej%�Z&Gdd�de$ej%�Z'Gdd�de$�Z(Gdd�de(ej%�Z)Gdd�de(ej%�Z*Gdd�de(�Z+Gdd�de+ej%�Z,Gdd�de+ej%�Z-Gd d!�d!e(�Z.Gd"d#�d#e.ej%�Z/Gd$d%�d%e.ej%�Z0Gd&d'�d'�Z1Gd(d)�d)e1ej2�Z3Gd*d+�d+e1ej2�Z4Gd,d-�d-�Z5Gd.d/�d/e5ej2�Z6Gd0d1�d1e5ej2�Z7Gd2d3�d3�Z8Gd4d5�d5e8ej%�Z9Gd6d7�d7e8ej%�Z:Gd8d9�d9ej;�Z<Gd:d;�d;e<�Z=Gd<d=�d=e<�Z>ej?Gd>d?�d?ej;��Z@Gd@dA�dA�ZAGdBdC�dC�ZBGdDdE�dEej;eA�ZCGdFdG�dGeCeB�ZDGdHdI�dIeC�ZEGdJdK�dKej;eA�ZFGdLdM�dMeFeB�ZGGdNdO�dOeF�ZHGdPdQ�dQej;�ZIGdRdS�dSeI�ZJGdTdU�dUeI�ZKGdVdW�dWeCeF�ZLGdXdY�dYeLeB�ZMGdZd[�d[eL�ZNGd\d]�d]ejO�ZPejQePjR�Gd^d_�d_ej;�ZSGd`da�daej;�ZTGdbdc�dcej2�ZUddde�ZVGdfdg�dgeT�ZWGdhdi�dieT�ZXGdjdk�dkej;�ZYGdldm�dmeY�ZZGdndo�doeY�Z[Gdpdq�dqej;�Z\Gdrds�dse\�Z]Gdtdu�due\�Z^ej_ej`dvkdw�Gdxdy�dyej;��ZaGdzd{�d{ea�ZbGd|d}�d}ea�Zcd~d�Zdeed�kr#ejf�dS)�zUnit tests for the io module.�N)�deque�UserList)�cycle�count)�support)�assert_python_ok�run_python_until_endcOstjdt||��S)N�b)�array�bytes)�pos�kw�r�1/opt/alt/python35/lib64/python3.5/test/test_io.py�	byteslike3srcOsQt||�}t�}tj|t|��|t|�jd�dd�<|S)z?Create a bytes-like object having no string or sequence methods�BN)r�EmptyStruct�ctypesZresize�len�
memoryview�cast)rr
�data�objrrrr6s
	c@seZdZdS)rN)�__name__�
__module__�__qualname__rrrrr=src	Cs*ttddd��}|jSWdQRXdS)z(Get the default TextIOWrapper chunk size�r�encodingzlatin-1N)�open�__file__�_CHUNK_SIZE)�frrr�_default_chunk_size@sr"c@s�eZdZdZfdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zddd�Z
dS)�MockRawIOWithoutReadzmA RawIO implementation without read(), so as to exercise the default
    RawIO.read() which calls readinto().cCs.t|�|_g|_d|_d|_dS)Nr)�list�_read_stack�_write_stack�_reads�_extraneous_reads)�selfZ
read_stackrrr�__init__Js		zMockRawIOWithoutRead.__init__cCs |jjt|��t|�S)N)r&�appendrr)r)r	rrr�writePszMockRawIOWithoutRead.writecCsdS)NTr)r)rrr�writableTszMockRawIOWithoutRead.writablecCsdS)N�*r)r)rrr�filenoWszMockRawIOWithoutRead.filenocCsdS)NTr)r)rrr�readableZszMockRawIOWithoutRead.readablecCsdS)NTr)r)rrr�seekable]szMockRawIOWithoutRead.seekablecCsdS)Nrr)r)r�whencerrr�seek`szMockRawIOWithoutRead.seekcCsdS)Nrr)r)rrr�tellcszMockRawIOWithoutRead.tellcCs�|jd7_t|�}y|jd}Wn%tk
rS|jd7_dSYnX|dkrn|jd=dSt|�}t|�|kr�|jd=||d|�<|S|d|�|dd�<||d�|jd<|SdS)N�r)r'rr%�
IndexErrorr()r)�bufZmax_lenr�nrrr�readintofs$
	

zMockRawIOWithoutRead.readintoNcCs|S)Nr)r)rrrr�truncate{szMockRawIOWithoutRead.truncate)rrr�__doc__r*r,r-r/r0r1r3r4r9r:rrrrr#Fsr#c@seZdZdS)�CMockRawIOWithoutReadN)rrrrrrrr<~sr<c@seZdZdS)�PyMockRawIOWithoutReadN)rrrrrrrr=�sr=c@seZdZddd�ZdS)�	MockRawIONc	CsE|jd7_y|jjd�SWn|jd7_dSYnXdS)Nr5r�)r'r%�popr()r)r8rrr�read�szMockRawIO.read)rrrrArrrrr>�sr>c@seZdZdS)�
CMockRawION)rrrrrrrrB�srBc@seZdZdS)�PyMockRawION)rrrrrrrrC�srCcsaeZdZ�fdd�Zd�fdd�Zdd�Zdd	�Z�fd
d�Z�S)�MisbehavedRawIOcst�j|�dS)N�)�superr,)r)r	)�	__class__rrr,�szMisbehavedRawIO.writeNcst�j|�dS)NrE)rFrA)r)r8)rGrrrA�szMisbehavedRawIO.readcCsdS)N�{i����r)r)rr2rrrr3�szMisbehavedRawIO.seekcCsdS)Ni�i8���r)r)rrrr4�szMisbehavedRawIO.tellcst�j|�t|�dS)N�)rFr9r)r)r7)rGrrr9�szMisbehavedRawIO.readinto)rrrr,rAr3r4r9rr)rGrrD�s
rDc@seZdZdS)�CMisbehavedRawION)rrrrrrrrJ�srJc@seZdZdS)�PyMisbehavedRawION)rrrrrrrrK�srKc@s"eZdZdZdd�ZdS)�CloseFailureIOrcCs|jsd|_t�dS)Nr5)�closed�OSError)r)rrr�close�s		zCloseFailureIO.closeN)rrrrMrOrrrrrL�srLc@seZdZdS)�CCloseFailureION)rrrrrrrrP�srPc@seZdZdS)�PyCloseFailureION)rrrrrrrrQ�srQcsIeZdZ�fdd�Zd�fdd�Z�fdd�Z�S)�
MockFileIOcsg|_t�j|�dS)N)�read_historyrFr*)r)r)rGrrr*�s	zMockFileIO.__init__Ncs>t�j|�}|jj|dkr-dn	t|��|S)N)rFrArSr+r)r)r8�res)rGrrrA�s(zMockFileIO.readcs&t�j|�}|jj|�|S)N)rFr9rSr+)r)r	rT)rGrrr9�szMockFileIO.readinto)rrrr*rAr9rr)rGrrR�srRc@seZdZdS)�CMockFileION)rrrrrrrrU�srUc@seZdZdS)�PyMockFileION)rrrrrrrrV�srVc@s@eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�MockUnseekableIOcCsdS)NFr)r)rrrr1�szMockUnseekableIO.seekablecGs|jd��dS)Nznot seekable)�UnsupportedOperation)r)�argsrrrr3�szMockUnseekableIO.seekcGs|jd��dS)Nznot seekable)rX)r)rYrrrr4�szMockUnseekableIO.tellcGs|jd��dS)Nznot seekable)rX)r)rYrrrr:�szMockUnseekableIO.truncateN)rrrr1r3r4r:rrrrrW�srWc@seZdZejZdS)�CMockUnseekableION)rrr�iorXrrrrrZ�srZc@seZdZejZdS)�PyMockUnseekableION)rrr�pyiorXrrrrr\�sr\c@sdeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dS)�MockNonBlockWriterIOcCsg|_d|_dS)N)r&�
_blocker_char)r)rrrr*�s	zMockNonBlockWriterIO.__init__cCs)dj|j�}g|jdd�<|S)Nr?)�joinr&)r)�srrr�pop_written�sz MockNonBlockWriterIO.pop_writtencCs
||_dS)z'Block when a given char is encountered.N)r_)r)�charrrr�block_on�szMockNonBlockWriterIO.block_oncCsdS)NTr)r)rrrr0�szMockNonBlockWriterIO.readablecCsdS)NTr)r)rrrr1�szMockNonBlockWriterIO.seekablecCsdS)NTr)r)rrrr-�szMockNonBlockWriterIO.writablecCs�t|�}d}|jr}y|j|j�}Wntk
rEYn8X|dkrp|jj|d|��|Sd|_dS|jj|�t|�S)Nr5r���)rr_�index�
ValueErrorr&r+r)r)r	r8rrrr,s	
	zMockNonBlockWriterIO.writeN)
rrrr*rbrdr0r1r-r,rrrrr^�sr^c@seZdZejZdS)�CMockNonBlockWriterION)rrrr[�BlockingIOErrorrrrrrhsrhc@seZdZejZdS)�PyMockNonBlockWriterION)rrrr]rirrrrrjsrjc@seZdZdd�Zdd�Zdd�Zddd	�Zd[Zdd
�Zdd�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Zd8d9�Zd:d;�Zd<d=�Z d>d?�Z!d@dA�Z"dBdC�Z#dDdE�Z$dFdG�Z%dHdI�Z&dJdK�Z'dLdM�Z(dNdO�Z)dPdQ�Z*dRdS�Z+dTdU�Z,dVdW�Z-dXdY�Z.dZS)\�IOTestcCstjtj�dS)N)r�unlink�TESTFN)r)rrr�setUpszIOTest.setUpcCstjtj�dS)N)rrlrm)r)rrr�tearDown szIOTest.tearDowncCs�|j|jd�d�|jd�|j|j�d�|jd�|j|jd�d�|j|jd�d�|j|jd�d�|j|j�d�|j|jdd�d�|j|j�d�td�}|j|j|�d�d|dd�<|j|jd�d�|j|jd
�d�|j|jdd�d�|j|j�d�|j|jd
�d
�|j|j�d�|jt|jd�dS)Nsblah.rIrsHello.�r5s	 world


�	�*�hrE�
�gres	*********re)�assertEqualr,r:r4r3�	bytearray�assertRaises�	TypeError)r)r!�bufferrrr�	write_ops#s(

zIOTest.write_opsFcCs�|jd�}|j|d�t|�}|j|j|�d�|jt|�d�td�}|j|j|�d�|jt|�d�|j|dd�d�|j|jd�d�|j|jd�d�|j|jd	�d
�|j|jtd��d�|j|jdd�d�|j|jd�d
�|j|jd�d
�|j|jt��d�|j|jdd	�d�|j|jd�d�|j|j�d�|j	t
|jd�|r�|jd�|j|j�d�|jd�|j|j�d�|j|j�d
�|jd�td�}|j|j|�d�|jt|�d�dS)NrIshellos worlrEsd
r�shello world
r5r?�xrpsworld�
gsworld
i����i����)rArvrr9rrwrr3r4rxry�	readinto1)r)r!Zbufferedrrrr�read_ops;s>


zIOTest.read_opsrE�cCs�|j|j|j�|j�|j|j�|j�|j|jd�d�|j|j�|jd�|j|jdd�|jd�|j|j�|jd�|j|j�|jd�|j|jdd�|jd�|j|j|jd�|jd�|j|j�|jd�|j|jdd�|jd�|j|jdd�|j�|j|jd�d�dS)	Nsxxx�r5rErr}rere)rvr3�LARGEr4r,r:rA)r)r!rrr�large_file_ops^s##'#zIOTest.large_file_opsc!Cs�|j}xSdD]K}|jtj|��-}|j||j�|j||j�WdQRXqW|jtjddd��-}|j||j�|j||j�WdQRX|jtjddd��6}|j||jd�|j||jdg�WdQRX|jtjd��6}|j||jd�|j||jdg�WdQRX|jtjd��n}|j||jd	�|j||jd
g�|j||j	d|j
�|j||j	d
|j�WdQRXdS)N�w�wb�	bufferingr�rbsblahsblah
rZblahzblah
r5)r�r�re)rXrrrmrxrA�readliner,�
writelinesr3�SEEK_CUR�SEEK_END)r)�exc�mode�fprrr�test_invalid_operationsos&	
  zIOTest.test_invalid_operationscsc�fdd�}�fdd�}�fdd�}�fdd�}�fd	d
�}�fdd�}�fd
d�}�fdd�}|df|df|df|df|df|df|df|df�jdf�jdff
}	xf|	D]^\}
}|
|krtrq��j|
��*|
��}d|k}
�j|j�|
�d|k}�j|j�|�t|�j�r�d}n1t|�j	�j
f�r�d}n
�jd�d|kr�|j�n�j
t|j�|
r|jd�|j�n)�j
t|jd��j
t|j�|rV|j|�n�j
t|j|�tjjd�r�|
||fkr�w�d|k}�j|j�|�|r�|j�|jd�n)�j
t|j��j
t|jd�|r$|r$|j�|jd�n)�j
t|j��j
t|jd�WdQRXWdQRXq�WdS)Ncs/tj�\}}tj|��j|d�S)Nr)�os�piperO�FileIO)rr�)r)rr�pipe_reader�s
z3IOTest.test_optional_abilities.<locals>.pipe_readercsptj�\}}�jtj|�tjdtjd|df�}|j��j|j��j	|d�S)N�targetrY�dr�)
r�r��
addCleanuprO�	threading�ThreadrA�startr`r�)rr�Zthread)r)rr�pipe_writer�s!
z3IOTest.test_optional_abilities.<locals>.pipe_writercs�j�j��S)N)�BufferedReaderrWr)r)rr�buffered_reader�sz7IOTest.test_optional_abilities.<locals>.buffered_readercs�j�j��S)N)�BufferedWriterrWr)r)rr�buffered_writer�sz7IOTest.test_optional_abilities.<locals>.buffered_writercs�j�j��S)N)�BufferedRandom�BytesIOr)r)rr�buffered_random�sz7IOTest.test_optional_abilities.<locals>.buffered_randomcs�j�j��j��S)N)�BufferedRWPairrWr)r)rr�buffered_rw_pair�sz8IOTest.test_optional_abilities.<locals>.buffered_rw_paircs2G�fdd�d�j�}�j|�d�S)Ncs(eZdZ�jjZ�jjZdS)zMIOTest.test_optional_abilities.<locals>.text_reader.<locals>.UnseekableReaderN)rrr�BufferedIOBaser-r,r)r)rr�UnseekableReader�sr��ascii)rW�
TextIOWrapper)r�)r)rr�text_reader�sz3IOTest.test_optional_abilities.<locals>.text_readercs2G�fdd�d�j�}�j|�d�S)Ncs(eZdZ�jjZ�jjZdS)zMIOTest.test_optional_abilities.<locals>.text_writer.<locals>.UnseekableWriterN)rrrr�r0rAr)r)rr�UnseekableWriter�sr�r�)rWr�)r�)r)rr�text_writer�sz3IOTest.test_optional_abilities.<locals>.text_writerZfrZfwrr�Zrws�rw�3�3zUnknown base classr!r5�winrar)r��StringIOr��subTestrvr0r-�
isinstance�
TextIOBaser��	RawIOBase�failr/rxrNrAr,�sys�platform�
startswithr1r4r3r:)r)r�r�r�r�r�r�r�r��tests�testZ	abilitiesrr0r-rr1r)r)r�test_optional_abilities�sh			





zIOTest.test_optional_abilitiescCsEd}|jt|j|d�|jt|jt|d�d�dS)Nzfoobarr�r�)rxrgrr)r)Zfn_with_NULrrr�test_open_handles_NUL_chars�sz"IOTest.test_open_handles_NUL_charscCs�|jtjddd��V}|j|j�d�|j|j�d�|j|j�d�|j|�WdQRX|jtjddd��V}|j|j�d�|j|j�d�|j|j�d�|j|�WdQRXdS)Nr�r�rFTr�)	rrrmrvr0r-r1r{r�)r)r!rrr�test_raw_file_io�szIOTest.test_raw_file_iocCs�|jtjd��V}|j|j�d�|j|j�d�|j|j�d�|j|�WdQRX|jtjd��Y}|j|j�d�|j|j�d�|j|j�d�|j|d�WdQRXdS)Nr�FTr�)	rrrmrvr0r-r1r{r�)r)r!rrr�test_buffered_file_ioszIOTest.test_buffered_file_iocCs*|jtjd��}|jd�WdQRX|jtjd���}|j|j�d�|j|jd�d�|j|jd�d�|j|jd	�d
�|j|j�d�|j|jd�d�|jt|jd
�WdQRX|jtjd��}|jt|jd
�WdQRXdS)Nr�s"abc
def
xyzzy
foobar
another liner�sabc
r~sdef
rEsxy�szzy
sfoobar
sanother lineg333333@r)rrrmr,rvr�rxry)r)r!rrr�
test_readline
szIOTest.test_readlinecCs9Gdd�d|j�}|jttft|��dS)Nc@seZdZdd�ZdS)z+IOTest.test_readline_nonsizeable.<locals>.RcSsdS)Nr)r)rrrr�sz4IOTest.test_readline_nonsizeable.<locals>.R.readlineN)rrrr�rrrr�Rsr�)�IOBaserxry�
StopIteration�next)r)r�rrr�test_readline_nonsizeablesz IOTest.test_readline_nonsizeablecCs6Gdd�d|j�}|jt|�jd�dS)Nc@seZdZdd�ZdS)z'IOTest.test_next_nonsizeable.<locals>.RcSsdS)Nr)r)rrr�__next__'sz0IOTest.test_next_nonsizeable.<locals>.R.__next__N)rrrr�rrrrr�&sr�r5)r�rxry�	readlines)r)r�rrr�test_next_nonsizeable#szIOTest.test_next_nonsizeablecCsX|j�}|j|�|j�}|j|d�|j|�}|j|d�dS)Nshello world
T)r�r{�getvaluervr�)r)r!rrrr�test_raw_bytes_io+s
zIOTest.test_raw_bytes_iocCs�tjdd�dks(tjdkr?tjdd|j�|jtjdd��}|j|�WdQRX|jtjd��}|j|�WdQRXdS)Nr�r��darwinZ	largefilez-test requires %s bytes and a long time to runzw+br)r�r�rZrequiresr�rrmr�)r)r!rrr�test_large_file_ops3s(zIOTest.test_large_file_opscCs�x�dD]�}d}|jtjd|��}|jd�WdQRX|j|jd�d}y.|jtjd|��}ddWdQRXWn%tk
r�|j|jd�YqX|jd�qWdS)	Nrr5r�r�sxxxTz1/0 didn't raise an exception)rr5r�)rrrmr,rvrM�ZeroDivisionErrorr�)r)�bufsizer!rrr�test_with_open@s

zIOTest.test_with_opencCs�|jtjd��}|jd�WdQRX|jtjddd��}|j|j�d�WdQRX|jtjd��}|j|j�d�WdQRX|jtjd��}|j|j�d�WdQRXdS)Nr�sxxx�abr�rr��a)rrrmr,rvr4�
assertGreater)r)r!rrr�test_append_mode_tellPszIOTest.test_append_mode_tellcs�g�G�fdd�d|j�}tjdtf��|tjd�}|jd�~tj�|j�dddg�|jtjd	��}|j|j	�d�WdQRXWdQRXdS)
NcsOeZdZ��fdd�Z��fdd�Z��fdd�Z�S)z(IOTest.test_destructor.<locals>.MyFileIOcs=�jd�yt�j}Wntk
r1YnX|�dS)Nr5)r+rF�__del__�AttributeError)r)r!)rG�recordrrr�]s

z0IOTest.test_destructor.<locals>.MyFileIO.__del__cs�jd�t�j�dS)NrE)r+rFrO)r))rGr�rrrOes
z.IOTest.test_destructor.<locals>.MyFileIO.closecs�jd�t�j�dS)Nr�)r+rF�flush)r))rGr�rrr�hs
z.IOTest.test_destructor.<locals>.MyFileIO.flush)rrrr�rOr�r)r�)rGr�MyFileIO\sr��r�sxxxr5rEr�r�)
r�r�check_warnings�ResourceWarningrmr,�
gc_collectrvrrA)r)r�r!r)r�r�test_destructorZs

zIOTest.test_destructorcsUg�G�fdd�d|�}|�}~tj�|j�dddg�dS)Ncs[eZdZdd�Z��fdd�Z��fdd�Z��fdd�Z�S)	z+IOTest._check_base_destructor.<locals>.MyIOcSsd|_d|_d|_dS)Nr5rEr�)�on_del�on_close�on_flush)r)rrrr*ws		z4IOTest._check_base_destructor.<locals>.MyIO.__init__cs@�j|j�yt�j}Wntk
r4YnX|�dS)N)r+r�rFr�r�)r)r!)rGr�rrr�s
z3IOTest._check_base_destructor.<locals>.MyIO.__del__cs!�j|j�t�j�dS)N)r+r�rFrO)r))rGr�rrrO�sz1IOTest._check_base_destructor.<locals>.MyIO.closecs!�j|j�t�j�dS)N)r+r�rFr�)r))rGr�rrr��sz1IOTest._check_base_destructor.<locals>.MyIO.flush)rrrr*r�rOr�r)r�)rGr�MyIOvsr�r5rEr�)rr�rv)r)�baser�r!r)r�r�_check_base_destructorts	
zIOTest._check_base_destructorcCs|j|j�dS)N)r�r�)r)rrr�test_IOBase_destructor�szIOTest.test_IOBase_destructorcCs|j|j�dS)N)r�r�)r)rrr�test_RawIOBase_destructor�sz IOTest.test_RawIOBase_destructorcCs|j|j�dS)N)r�r�)r)rrr�test_BufferedIOBase_destructor�sz%IOTest.test_BufferedIOBase_destructorcCs|j|j�dS)N)r�r�)r)rrr�test_TextIOBase_destructor�sz!IOTest.test_TextIOBase_destructorcCse|jtjd��}|jd�WdQRX|jtjd��}|j|j�d�WdQRXdS)Nr�sxxxr�)rrrmr,rvrA)r)r!rrr�test_close_flushes�szIOTest.test_close_flushescs�tjdtd���t�j������fdd�}|�j��|�jtjd��|�j�j	���|�j
�j	���|�j�j	��j	���dS)N�ir~c
s;|�.�j|j����|j�f�WdQRXdS)N)rvr,r�)r!)r�r8r)rr�check�sz'IOTest.test_array_writes.<locals>.checkr�)r
�ranger�tobytesr�r�rrmr�r>r�r�)r)r�r)r�r8r)r�test_array_writes�szIOTest.test_array_writescCs&|jt|jtjddd�dS)Nr��closefdF)rxrgrrrm)r)rrr�test_closefd�szIOTest.test_closefdcCs�|jtjd��}|jd�WdQRX|jtjd��e}|j|j�ddd�}|j|j�d�|jd�|j�|j	t
|j�WdQRXdS)Nr�zegg
rr�Fr)rrrmr,r/rvrAr3rOrxrg)r)r!�filerrr�test_read_closed�s

zIOTest.test_read_closedcCs&|jt|jtjddd�dS)Nrr�F)rxrgrrrm)r)rrr�test_no_closefd_with_filename�sz$IOTest.test_no_closefd_with_filenamecCs�|jtjd��}|jd�WdQRX|jtjd��W}|j|jjjd�|j|j�ddd�}|j|jjjd�WdQRXdS)Nr�segg
rTr�F)	rrrmr,rvrz�rawr�r/)r)r!r�rrr�test_closefd_attr�szIOTest.test_closefd_attrcCs�tjdtf��L|jtjd�}|jd�||_tj|�}~tj	�WdQRX|j
|�|�|jtjd��}|j|j
�d�WdQRXdS)Nr�r�sabcxxxr�)rr�r�r�rmr,r!�weakref�refr��assertIsNonerrvrA)r)r!�wrrrr�test_garbage_collection�s
	zIOTest.test_garbage_collectioncCsd}tjj|�s.|jdj|��tjdkrJ|jd�tjtj	kri|jd�|j
|ddd��}|jt|j
�WdQRX|j
|d��}|jt|j
�WdQRX|j
|d	��}|jt|j
�WdQRXdS)
Nz	/dev/zeroz{0} does not existi���z+test can only run in a 32-bit address spacez$test requires at least 2GB of memoryr�r�rr)r��path�existsZskipTest�formatr��maxsizerZreal_max_memuseZ_2Grrx�
OverflowErrorrA)r)Zzeror!rrr�test_unbounded_file�s

zIOTest.test_unbounded_filecs�|j||��g���fdd�}|�_|jt�j�|j�j�|j��|j�d�dd��_dS)Ncs#�jg�dd�<t��dS)N)rMrNr)rMr!rr�	bad_flush�sz4IOTest.check_flush_error_on_close.<locals>.bad_flushrcSsdS)Nrrrrr�<lambda>�sz3IOTest.check_flush_error_on_close.<locals>.<lambda>)rr�rxrNrO�
assertTruerM�assertFalse)r)rY�kwargsrr)rMr!r�check_flush_error_on_close�s	
z!IOTest.check_flush_error_on_closecCs�|jtjddd�tjtjtjtjB�}|j|ddd�tjtjtjtjB�}|j|ddddd�tj|�|jtjd�tjtjtjtjB�}|j|d�tjtjtjtjB�}|j|ddd�tj|�|jtjd�tjtjtjtjB�}|j|d�tjtjtjtjB�}|j|ddd�tj|�dS)Nr�r�rr�Fr�)rrrmr�r�O_WRONLY�O_CREATrO)r)�fdrrr�test_flush_error_on_close�s$

z IOTest.test_flush_error_on_closecCsP|jtjddd�}|j�|j�|j�|jt|j�dS)Nr�r�r)rrrmrOrxrgr�)r)r!rrr�test_multi_closes



zIOTest.test_multi_closecCs�|jd
�}|j|jd�d�|j|jd�d�|j|jd�d�|j|jd�d�|j|jd�d�|j|jd�d�|j|jd�d�|j|jd�d	�dS)N�abc�d�efgrEsab�csef�gr?)rrNr
N)r#rvrA)r)�rawiorrr�test_RawIOBase_readszIOTest.test_RawIOBase_readcCs^|j�|j�|j�|j�|j�f}x$|D]}|jt|d��q:WdS)N�__dict__)r�r�r�r�r�r�hasattr)r)r�rrrr�test_types_have_dict$s				
zIOTest.test_types_have_dictcs�|jtjd��}|jd�WdQRXtjtjtj���fdd�}|jddd|��}|j|j�d�WdQRXdS)Nr�zegg
cs�S)Nr)r��flags)rrr�opener3sz"IOTest.test_opener.<locals>.openerznon-existentrr)rrrmr,r��O_RDONLYrvrA)r)r!rr)rr�test_opener/szIOTest.test_openercCsUdd�}|jt��}tddd|�WdQRX|jt|j�d�dS)NcSsdS)Nr5rer)�fnamerrrr�	badopener:sz4IOTest.test_bad_opener_negative_1.<locals>.badopenerznon-existentrrzopener returned -1)rxrgrrv�str�	exception)r)r�cmrrr�test_bad_opener_negative_18sz!IOTest.test_bad_opener_negative_1cCsUdd�}|jt��}tddd|�WdQRX|jt|j�d�dS)NcSsdS)NrE���r)rrrrrrBsz8IOTest.test_bad_opener_other_negative.<locals>.badopenerznon-existentrrzopener returned -2)rxrgrrvrr)r)rrrrr�test_bad_opener_other_negative@sz%IOTest.test_bad_opener_other_negativecCs�|jtd��u}|jtd��Y}|j|j�dd�}|j|j�dd�|j�|j�|j�WdQRXWdQRXdS)Nr�r�F)rrr�r/r*r�rO)r)�f1�f2Zfileiorrr�test_fileio_closefdHs

zIOTest.test_fileio_closefdcCsKtj|��5|jt��|jtjddd�WdQRXWdQRXdS)Nr�r�r)r�check_no_resource_warningrxrgrrm)r)rrr�test_nonbuffered_textioTszIOTest.test_nonbuffered_textiocCsKtj|��5|jt��|jtjddd�WdQRXWdQRXdS)Nr��newlineZinvalid)rr$rxrgrrm)r)rrr�test_invalid_newlineYszIOTest.test_invalid_newlinecCs�Gdd�d|j�}|�}xfdD]^}|j|��Ftd�}|jt||�|�d�|jt|�d�WdQRXq)WdS)Nc@s"eZdZdd�ZeZdS)z3IOTest.test_buffered_readinto_mixin.<locals>.StreamcSsdS)Ns12345r)r)�sizerrrrAasz8IOTest.test_buffered_readinto_mixin.<locals>.Stream.readN)rrrrA�read1rrrr�Stream`sr*r9rrIs12345)r9r)r�r�rrv�getattrr)r)r*�stream�methodrzrrr�test_buffered_readinto_mixin^s	
z#IOTest.test_buffered_readinto_mixinNl)/rrrrnror{r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr	r
rrrrr r#r%r'r.rrrrrksX!j




	rkc@seZdZdd�ZdS)�CIOTestcCshGdd�d|j�}|�|�}||_tj|�}~~tj�|j|�|�dS)Nc@seZdZdd�ZdS)z*CIOTest.test_IOBase_finalize.<locals>.MyIOcSsdS)Nr)r)rrrrOssz0CIOTest.test_IOBase_finalize.<locals>.MyIO.closeN)rrrrOrrrrr�rsr�)r�rr�r�rr�r�)r)r�rr�rrr�test_IOBase_finalizens		
zCIOTest.test_IOBase_finalizeN)rrrr0rrrrr/lsr/c@seZdZdS)�PyIOTestN)rrrrrrrr1�sr1c@s(eZdZdd�Zdd�ZdS)�APIMismatchTestcCs;tjtjtjdd�}|j|t�dd�dS)z:Test that pyio RawIOBase class has all c RawIOBase methods�ignore�__weakref__�msgz6Python RawIOBase does not have all C RawIOBase methodsN)r4)r�detect_api_mismatchr]r�r[rv�set)r)�mismatchrrr�test_RawIOBase_io_in_pyio_match�s	z/APIMismatchTest.test_RawIOBase_io_in_pyio_matchcCs5tjtjtj�}|j|t�dd�dS)z:Test that c RawIOBase class has all pyio RawIOBase methodsr5z6C RawIOBase does not have all Python RawIOBase methodsN)rr6r[r�r]rvr7)r)r8rrr�test_RawIOBase_pyio_in_io_match�sz/APIMismatchTest.test_RawIOBase_pyio_in_io_matchN)rrrr9r:rrrrr2�sr2c@s�eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdS)�CommonBufferedTestscCsR|j�}|j|�}|j|j�|�|jt|j�t|�dS)N)r>�tp�assertIs�detachrxrg�repr)r)r�r7rrr�test_detach�s
zCommonBufferedTests.test_detachcCs5|j�}|j|�}|jd|j��dS)Nr.)r>r<rvr/)r)r�bufiorrr�test_fileno�szCommonBufferedTests.test_filenocCsQ|j�}|j|�}|jt|jdd�|jt|jdd�dS)Nrr5rqre)r>r<rxrgr3)r)rrArrr�test_invalid_args�sz%CommonBufferedTests.test_invalid_argscsm|j}g�G�fdd�d|�}|j�}||�}~tj�|j�dddg�dS)NcsOeZdZ��fdd�Z��fdd�Z��fdd�Z�S)zBCommonBufferedTests.test_override_destructor.<locals>.MyBufferedIOcs=�jd�yt�j}Wntk
r1YnX|�dS)Nr5)r+rFr�r�)r)r!)rGr�rrr��s

zJCommonBufferedTests.test_override_destructor.<locals>.MyBufferedIO.__del__cs�jd�t�j�dS)NrE)r+rFrO)r))rGr�rrrO�s
zHCommonBufferedTests.test_override_destructor.<locals>.MyBufferedIO.closecs�jd�t�j�dS)Nr�)r+rFr�)r))rGr�rrr��s
zHCommonBufferedTests.test_override_destructor.<locals>.MyBufferedIO.flush)rrrr�rOr�r)r�)rGr�MyBufferedIO�srDr5rEr�)r<r>rr�rv)r)r<rDrrAr)r�r�test_override_destructor�s	
z,CommonBufferedTests.test_override_destructorcsH|j�}|j|���fdd�}|�|jt|�dS)Nc	s��WdQRXdS)Nrr)rArr�_with�sz7CommonBufferedTests.test_context_manager.<locals>._with)r>r<rxrg)r)rrFr)rAr�test_context_manager�s
z(CommonBufferedTests.test_context_managerc
s��j����fdd�}tjd��}�jt|�WdQRX|j�j�}|r��jt|j	��d��j
|jd�|��j
|jd�|�dS)Ncs�j��jdS)N)r<�xyzzyr)rr)rrr!�sz<CommonBufferedTests.test_error_through_destructor.<locals>.f�stderrr5zException OSError: z ignored)
rLr�captured_outputrxr�r��striprvr�
splitlinesrr��endswith)r)r!rar)rr)r�test_error_through_destructor�sz1CommonBufferedTests.test_error_through_destructorcCs�|j�}|j|�}d|jj|jjf}|jt|�d|�d|_|jt|�d|�d|_|jt|�d|�dS)Nz%s.%sz<%s>�dummyz<%s name='dummy'>sdummyz<%s name=b'dummy'>)r>r<rrrvr?�name)r)r�r	Zclsnamerrr�	test_repr�s		zCommonBufferedTests.test_reprcCs_|j�}|j|�}tj|d|��(yt|�Wntk
rSYnXWdQRXdS)NrP)r>r<r�	swap_attrr?�RuntimeError)r)r�r	rrr�test_recursive_repr�s
z'CommonBufferedTests.test_recursive_reprcs�|j��g����fdd�}|�_|j���|jt�j�|j�j�|j�j�|j��|j�d�|j�d�dd��_dS)Ncs)�j�jg�dd�<t��dS)N)rMrNr)r	rMr�rrr�sz@CommonBufferedTests.test_flush_error_on_close.<locals>.bad_flushrr5cSsdS)Nrrrrrrsz?CommonBufferedTests.test_flush_error_on_close.<locals>.<lambda>)	r>r�r<rxrNrOrrMr)r)rr)r	rMr�rr	�s	
z-CommonBufferedTests.test_flush_error_on_closec
Cs�|j�}dd�}dd�}||_|j|�}||_|jt��}|j�WdQRX|j|jjd�|j	|jj
t�|j|jj
jd�|j|j�dS)	NcSstd��dS)Nr�)rNrrrrrsz@CommonBufferedTests.test_close_error_on_close.<locals>.bad_flushcSstd��dS)NrO)rNrrrr�	bad_closesz@CommonBufferedTests.test_close_error_on_close.<locals>.bad_closerOr�)rO)r�)
r>rOr<r�rxrNrvrrY�assertIsInstance�__context__rrM)r)r�rrUr	�errrrr�test_close_error_on_closes		z-CommonBufferedTests.test_close_error_on_closecCs�|j�}dd�}dd�}||_|j|�}||_|jt��}|j�WdQRX|jdt|j��|j	|jj
t�|jdt|jj
��|j|j�dS)NcSs
t�dS)N)�non_existing_flushrrrrrszNCommonBufferedTests.test_nonnormalized_close_error_on_close.<locals>.bad_flushcSs
t�dS)N)�non_existing_closerrrrrUszNCommonBufferedTests.test_nonnormalized_close_error_on_close.<locals>.bad_closer[rZ)
r>rOr<r�rx�	NameError�assertInrrrVrWrrM)r)r�rrUr	rXrrr�'test_nonnormalized_close_error_on_closes		z;CommonBufferedTests.test_nonnormalized_close_error_on_closecCsP|j�}|j|�}|j�|j�|j�|jt|j�dS)N)r>r<rOrxrgr�)r)r�r	rrrr
%s


z$CommonBufferedTests.test_multi_closecCsK|j|jd��}|j|j|j�|j|j|jd�dS)N�Ar~rs
AAAAAAAAAA)r<rWrxrXr4r3)r)rArrr�test_unseekable-sz#CommonBufferedTests.test_unseekablec	CsK|j�}|j|�}|j�}|jt��||_WdQRXdS)N)r>r<rxr�r�)r)r�r7�xrrr�test_readonly_attributes2s
z,CommonBufferedTests.test_readonly_attributesN)rrrr@rBrCrErGrNrQrTr	rYr^r
r`rbrrrrr;�s

r;c@s:eZdZejdd��Zejdd��ZdS)�
SizeofTestcCs�d}d}|j�}|j|d|�}tj|�|}|j�}|j|d|�}|jtj|�||�dS)Nii �buffer_size)r>r<r��	getsizeofrv)r)Zbufsize1Zbufsize2rrAr(rrr�test_sizeof<szSizeofTest.test_sizeofcCsad}|j�}|j|d|�}tj|�|}|j�|jtj|�|�dS)Nird)r>r<r�rerOrv)r)r�rrAr(rrr�test_buffer_freeingGs
zSizeofTest.test_buffer_freeingN)rrrr�cpython_onlyrfrgrrrrrc:srcc@seZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zejed�ejd�dd���Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(S))�BufferedReaderTestr�cCs�|jdg�}|j|�}|j|�|j|dd�|j|dd�|jd|j��|jt|j|dd�|jt|j|dd�|jt|j|dd�|jdg�}|j|�|jd|j��dS)	Nsabcrdi�rr5i�re)r>r<r*rvrArxrg)r)rrArrr�test_constructorSs

z#BufferedReaderTest.test_constructorcCs||jj|j�}~|jj|j�}|jttfd|jd�|j|j��|j|jd�d�dS)Nzuninitialized|has no attributerr?)	r<�__new__�assertRaisesRegexrgr�rAr*r>rv)r)rArrr�test_uninitializedas
z%BufferedReaderTest.test_uninitializedcCsbxEdD]=}|jd�}|j|�}|jd|j|��qW|jt|jd	�dS)
N��abcr�efgsabcdefgrE)Nro)rprrqr)r>r<rvrArxrg)r)�argrrArrr�	test_readks

zBufferedReaderTest.test_readcCs-|jd
�}|j|�}|jd|jd��|jd|jd��|j|jd�|jd|jd��|j|jd�|jd|jd��|j|jd	�|jd|jd��|j|jd
�|jd|jd��|j|jd�|jt|jd�dS)N�abcr�efg�ar5�brr�rEr�r?r�)rtrrure)r>r<rvrAr)r'rxrg)r)rrArrr�
test_read1sszBufferedReaderTest.test_read1cCsk|jd�}|j|�}td�}|j|j|�d�|j|d�|j|j|�d�|j|d�|j|j|�d�|j|d�|j|j|�d�|j|d	�|j|j|�d
�|j|d	�|jd
�}|j|�}|j|j|�d�|j|d�|j|j|�d�|j|d�dS)N�abcr�efgrEsabscdsefr5sgfrscb)ryrrz)ryN)r>r<rwrvr9)r)rrAr	rrr�
test_readinto�s&z BufferedReaderTest.test_readintocCs�d}|jd�}|j|d|�}td�}|j|jd�d�|j|jd	�|j|j|�d�|j|d
�|j|jd	�|j|j|�d	�|j|dd	�d�|j|jd	�|j|j|�d�|j|d�|j|jd�td|�}|j|jd�d�|j|jd�|j|j|�d�|j|dd�d
�|j|jd�dS)Nr~�abc�de�fgh�jklrdrEr�r5sabrrpsfghjklr�)r|r}r~r)r>r<rwrv�peekr'r)r)rdrrAr	rrr�test_readinto1�s*z!BufferedReaderTest.test_readinto1cCs�d}dd}|j|f�}|j|d|�}tjddd�}|j|�}|j|t|��t|�jd�}|j|t|��|j	|d|�|d|��|j	||d�dt||d���dS)	N�<rv�rdr�r}� r)
r>r<r
r9r�rrr�
assertLessrv)r)rdrrrAr	r8�bmrrr�test_readinto_array�s
$z&BufferedReaderTest.test_readinto_arraycCs�d}dd}|j|f�}|j|d|�}tjddd�}|j|�}|j|t|��t|�jd�}|j|t|��|j	|d|�|d|��|j	||d�dt||d���dS)	Nr�rvr�rdr�r}r�r)
r>r<r
rr�rrrr�rv)r)rdrrrAr	r8r�rrr�test_readinto1_array�s
$z'BufferedReaderTest.test_readinto1_arraycs�fdd�}�j|�j�dddg��j|�jd�ddg��j|�jd�dddg�dS)Ncs�jd�}�j|�S)N�abc
�d
�ef)r�r�r�)r>r<)r)r)rrrA�sz0BufferedReaderTest.test_readlines.<locals>.bufiosabc
sd
sefrI)rvr�)r)rAr)r)r�test_readlines�s""z!BufferedReaderTest.test_readlinescCsd}t|�}dddddg|dggddddg|ggdddddgdddggg}x�|D]�\}}}|j|�}|j|d	|�}d}	x?|D]7}
|j|j|
�||	|	|
��|	|
7}	q�W|j|j|�qvWdS)
Ns	abcdefghir�r�r5r��rrErd)rrRr<rvrArS)r)rZdlenr�r�Zbuf_read_sizesZraw_read_sizesrrAr�nbytesrrr�test_buffering�s'
'z!BufferedReaderTest.test_bufferingcCs�|jd�}|j|�}|jd|jd��|jd|jd��|jd|j��|jd	|jd��|j|j��|jd	|j��|jd�}|jd
|j��|j|j��dS)
N�abcr�efgsabcdrp�er5sfgr?rv)r�rNr�NNN)rvNN)r>r<rvrAr�r��readall)r)rrArrr�test_read_non_blocking�sz)BufferedReaderTest.test_read_non_blockingcCs;|jd�}|j|�}|jd|jd��dS)N�abcr�efgsabcdefgi(#)r�rr�)r>r<rvrA)r)rrArrr�test_read_past_eofsz%BufferedReaderTest.test_read_past_eofcCs8|jd�}|j|�}|jd|j��dS)N�abcr�efgsabcdefg)r�rr�)r>r<rvrA)r)rrArrr�
test_read_allsz BufferedReaderTest.test_read_allz!Threading required for this test.�cpucs�ztd}ttd��|}tj|�tt|��}|jtjd����j	|�WdQRX|jtj|j
dd���}|j|d��g�g����fdd���fd	d
�td�D�}tj|��t
jd�WdQRX|j�d
��dj��}xBtd�D]4}tt|g��}|j|j|�|�q4WWdQRXWdtjtj�XdS)Ni��r�r�rr�cs�yDx=tddg�D])}�j|�}|s2P�j|�qWWn5tk
r{}z�j|��WYdd}~XnXdS)Nr5�)rrAr+�	Exception)r8ra�e)rA�errors�resultsrrr!"s
z*BufferedReaderTest.test_threads.<locals>.fcs"g|]}tjd���qS)r�)r�r�)�.0ra)r!rr�
<listcomp>.s	z3BufferedReaderTest.test_threads.<locals>.<listcomp>r|g{�G�z�?z(the following exceptions were caught: %rr?)r$r��randomZshufflerrwrrrmr,�	read_moder<�
start_threads�time�sleeprr`rvrrl)r)�N�lrar��threadsr��cr)rAr�r!r�r�test_threadss,
!	(zBufferedReaderTest.test_threadscCs�|j|jd��}|j|j|j�|j|j|jd�|jd�|j|j|jd�|j|j|j�dS)Nr_r~rr5s
AAAAAAAAAA)r<rWrxrXr4r3rA)r)rArrrr`:s
z"BufferedReaderTest.test_unseekablecCsK|jd�}|j|�}|jt|jd�|jt|j�dS)N�abcr�efgr)r�rr�)rDr<rxrNr3r4)r)rrArrr�test_misbehaved_ioBsz%BufferedReaderTest.test_misbehaved_iocCsd}xd|d||d|dfD]�}|jd|g�}|j||�}|j|j|�d|�|j|jddj||j��|jd|ddg�}|j||�}|j|j|�d|�|j|jddj||j��q(WdS)NrjrEr5r}rzfailed for {}: {} != 0)r>r<rvrAr(r�)r)r�r8rrArrr�test_no_extraneous_readHs(z*BufferedReaderTest.test_no_extraneous_readcCs\tjtjd��}|jd�|j�|jt|j�|jt|jd�dS)Ns12r5)	r[r�r�rArOrxrgr�r))r)r	rrr�test_read_on_closed\s


z&BufferedReaderTest.test_read_on_closedN)rrrr�rkrnrsrxr{r�r�r�r�r�r�r�r��unittest�
skipUnlessr�r�requires_resourcer�r`r�r�r�rrrrriPs(
(ric@sUeZdZejZdd�Zdd�Zdd�Zdd�Z	d	d
�Z
dS)�CBufferedReaderTestcCs`tj|�tjdkr\|j�}|j|�}|jttt	f|j
|tj�dS)Ni���)rirkr�r�r>r<rxr��MemoryErrorrgr*)r)rrArrrrkhs
z$CBufferedReaderTest.test_constructorcCs�|jdg�}|j|�}|jt|j|dd�|jt|j�|jt|j|dd�|jt|j�|jt|j|dd�|jt|j�dS)Nsabcrdrrjr5i�re)r>r<rxrgr*rA)r)rrArrr�test_initializationrsz'CBufferedReaderTest.test_initializationcCs8|jd�}|j|�}|jt|jd�dS)N�abcr�efgr~)r�rr�)rDr<rxrNrA)r)rrArrr�test_misbehaved_io_read|sz+CBufferedReaderTest.test_misbehaved_io_readc
Cs}tjdtf��N|jtjd�}|j|�}||_tj|�}~tj	�WdQRX|j
|�|�dS)Nr�zw+b)rr�r�r�rmr<r!r�r�r�r�)r)rr!r�rrrr��s	z+CBufferedReaderTest.test_garbage_collectioncCs:|jtd��!|jtj�ddd�WdQRXdS)Nr�i)rmryr<r[r�)r)rrr�test_args_error�sz#CBufferedReaderTest.test_args_errorN)rrrr[r�r<rkr�r�r�r�rrrrr�es	

r�c@seZdZejZdS)�PyBufferedReaderTestN)rrrr]r�r<rrrrr��sr�c@s?eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zejed&�ejd'�d(d)���Zd*d+�Zd,d-�Zd.d/�Zd0S)1�BufferedWriterTestr�cCs|j�}|j|�}|j|�|j|dd�|j|dd�|jd|jd��|j�|jt|j|dd�|jt|j|dd�|jt|j|dd�|j|�|jd|jd��|j�|jd	j|j	�d
�dS)
Nrdirjr�sabcrr5sghir?sabcghii�re)
r>r<r*rvr,r�rxrgr`r&)r)rrArrrrk�s



z#BufferedWriterTest.test_constructorcCs||jj|j�}~|jj|j�}|jttfd|jd�|j|j��|j|jd�d�dS)Nzuninitialized|has no attributer?r)	r<rlrmrgr�r,r*r>rv)r)rArrrrn�s
z%BufferedWriterTest.test_uninitializedcCs\|j�}|j|�}|jd�|j|j�|j�|j|jdg�dS)Nshowdy!)r>r<r,rr&r>rv)r)r�r7rrr�test_detach_flush�s

z$BufferedWriterTest.test_detach_flushcCs�|j�}|j|d�}|jd�|j|j�td�}|j|�d|dd�<|j�|jdj|j�d�dS)Nr�sabcsdefs***r?sabcdef)	r>r<r,rr&rwr�rvr`)r)�writerrArzrrr�
test_write�s


zBufferedWriterTest.test_writecCs�|j�}|j|d�}d}x;tdt|�d�D]!}|j|||d��q=Wdj|j�}|j|j|dd��|�dS)Nr�sabcdefghijklmnoprr�r?i����)	r>r<r�rr,r`r&rr�)r)r�rA�contentsr8Zflushedrrr�test_write_overflow�sz&BufferedWriterTest.test_write_overflowc	Cs�ttd��d}d}|j�}|j|d�}dd�}|�}xp|t|�kr�tt|�t|�|�}|j|j||||��|�||�||7}qRW|j	�|j|dj
|j��dS)Nr�i�rrtcss7x0td�D]"}xtd�D]}|Vq Wq
WdS)Nr5�)rr�)r(r�rrr�	gen_sizes�sz2BufferedWriterTest.check_writes.<locals>.gen_sizesr?)rr�r>r<r�minr�rvr,r�r`r&)	r)Zintermediate_funcr�r8r�rAr��sizesr(rrr�check_writes�s	'

zBufferedWriterTest.check_writescCs|jdd��dS)NcSsdS)Nr)rArrrr�sz0BufferedWriterTest.test_writes.<locals>.<lambda>)r�)r)rrr�test_writes�szBufferedWriterTest.test_writescCs|jdd��dS)NcSs
|j�S)N)r�)rArrrr�sz<BufferedWriterTest.test_writes_and_flushes.<locals>.<lambda>)r�)r)rrr�test_writes_and_flushes�sz*BufferedWriterTest.test_writes_and_flushescCs6dd�}|j|�dd�}|j|�dS)NcSsH|j�}|j|dd�|j|dd�|j|d�dS)Nr5r)r4r3)rArrrr�_seekabs�sz:BufferedWriterTest.test_writes_and_seeks.<locals>._seekabscSsF|jdd�}|jdd�|jdd�|j|d�dS)Nrr5r5re)r3)rArrrr�_seekrel�sz:BufferedWriterTest.test_writes_and_seeks.<locals>._seekrel)r�)r)r�r�rrr�test_writes_and_seeks�s
z(BufferedWriterTest.test_writes_and_seekscCs|jdd��dS)NcSs|j|j��S)N)r:r4)rArrrr�sz>BufferedWriterTest.test_writes_and_truncates.<locals>.<lambda>)r�)r)rrr�test_writes_and_truncates�sz,BufferedWriterTest.test_writes_and_truncatescCs=|j�}|j|d�}|j|jd�d�|j|jd�d�|jd�|j|jd�d�|jd�y|jd	�Wn1|jk
r�}z|j}WYdd}~XnX|jd
�|j|d�|j|j�d�|j|jd
�d�|j�}|j	|j
d�|�dS)Nr�sabcdr�sefghirI�ksjklmn�0sopqrwxyz0123456789z'BlockingIOError should have been raisedrjsabcdefghijklmnopqrwxyzs	ABCDEFGHIrqs	01234567A)r^r<rvr,rdri�characters_writtenr�rbrr�)r)r�rAr��writtenrarrr�test_write_non_blockings$


z*BufferedWriterTest.test_write_non_blockingcCs�tj�}|j|d�}|j|jd�d�|j|j�d�|jdd�|j|jd�d�|jdd�|j|j�d�|j|jd�d�|j�|j|j�d	�dS)
Nr�sabcdefrprsXYrEsXYcdefs123456sXYcdef123456)	r[r�r<rvr,r4r3r�r�)r)r�rArrr�test_write_and_rewinds
z(BufferedWriterTest.test_write_and_rewindcCsP|j�}|j|d�}|jd�|j�|jd|jd�dS)Nr�sabcr)r>r<r,r�rvr&)r)r�rArrr�
test_flush(s


zBufferedWriterTest.test_flushcCsddddg}|j�}|j|d�}|j|�|j�|jdj|j�d�dS)Nsabscdsefr�r?sabcdef)r>r<r�r�rvr`r&)r)r�r�rArrr�test_writelines/s

z"BufferedWriterTest.test_writelinescCsjtdddg�}|j�}|j|d�}|j|�|j�|jdj|j�d�dS)Nsabscdsefr�r?sabcdef)rr>r<r�r�rvr`r&)r)r�r�rArrr�test_writelines_userlist7s

z+BufferedWriterTest.test_writelines_userlistcCsm|j�}|j|d�}|jt|jdddg�|jt|jd�|jt|jd�dS)Nr�r5rEr��abc)r>r<rxryr�)r)r�rArrr�test_writelines_error?s
z(BufferedWriterTest.test_writelines_errorcCsS|j�}|j|d�}|jd�~tj�|jd|jd�dS)Nr�sabcr)r>r<r,rr�rvr&)r)r�rArrrr�Fs

z"BufferedWriterTest.test_destructorcCs�|jtj|jdd��U}|j|d�}|jd�|j|jd�d�|j|j�d�WdQRX|jtjddd��}|j|j	�d�WdQRXdS)	Nr�rr�sabcdefr�rpr�sabc)
rrrm�
write_moder<r,rvr:r4rA)r)r�rAr!rrr�
test_truncateNs!
z BufferedWriterTest.test_truncatez!Threading required for this test.r�c
 s�z�d}ttd��|}tddg�}d}t��xG|t|�kr�t|�}�j||||��||7}qCW~|jtj	|j
dd���}|j|d��g����fdd	���fd
d�td�D�}tj|��t
jd
�WdQRX|j�d���j�WdQRX|jtj	d����j�}WdQRXx6td�D](}	|j|jt|	g��|�q~WWdtjtj	�XdS)Ni�r�r5r�rr�r�cs}yAx:y�j�}Wntk
r.dSYnX�j|�qWWn5tk
rx}z�j|��WYdd}~XnXdS)N)�popleftr6r,r�r+)rar�)rAr��queuerrr!ps
	
z*BufferedWriterTest.test_threads.<locals>.fcs"g|]}tjd���qS)r�)r�r�)r�ra)r!rrr�{s	z3BufferedWriterTest.test_threads.<locals>.<listcomp>r|g{�G�z�?z(the following exceptions were caught: %rr�)rr�rrrr�r+rrrmr�r<r�r�r�rrOrArvrrl)
r)r�r�r�r8r(r�r�rar�r)rAr�r!r�rr�Xs4	!	*zBufferedWriterTest.test_threadscCsa|j�}|j|d�}|jt|jd�|jt|j�|jt|jd�dS)NrIrsabcdef)rDr<rxrNr3r4r,)r)rrArrrr��s
z%BufferedWriterTest.test_misbehaved_iocCs4|jt��|j|j�dd�WdQRXdS)Nr�ru)rxryr<r>)r)rrr�test_max_buffer_size_removal�sz/BufferedWriterTest.test_max_buffer_size_removalcCsd|j�}dd�}||_|j|�}|jd�|jt|j�|j|j�dS)NcSs
t��dS)N)rN)r	rrr�	bad_write�sz?BufferedWriterTest.test_write_error_on_close.<locals>.bad_writesspam)r>r,r<rxrNrOrrM)r)r�r�r	rrr�test_write_error_on_close�s	
z,BufferedWriterTest.test_write_error_on_closeN)rrrr�rkrnr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�r�r�r�rrrrr��s0


/r�c@sIeZdZejZdd�Zdd�Zdd�Zdd�Z	d	S)
�CBufferedWriterTestcCs`tj|�tjdkr\|j�}|j|�}|jttt	f|j
|tj�dS)Ni���)r�rkr�r�r>r<rxr�r�rgr*)r)rrArrrrk�s
z$CBufferedWriterTest.test_constructorcCs�|j�}|j|�}|jt|j|dd�|jt|jd�|jt|j|dd�|jt|jd�|jt|j|dd�|jt|jd�dS)Nrdrsdefrjr5i�re)r>r<rxrgr*r,)r)rrArrrr��sz'CBufferedWriterTest.test_initializationcCs�tjdtf��[|jtjd�}|j|�}|jd�||_tj	|�}~tj
�WdQRX|j|�|�|jtjd��}|j
|j�d�WdQRXdS)Nr�zw+bs123xxxr�)rr�r�r�rmr<r,rar�r�r�r�rrvrA)r)rr!r�rrrr��s
	z+CBufferedWriterTest.test_garbage_collectioncCs:|jtd��!|jtj�ddd�WdQRXdS)Nr�i)rmryr<r[r�)r)rrrr��sz#CBufferedWriterTest.test_args_errorN)
rrrr[r�r<rkr�r�r�rrrrr��s
	

r�c@seZdZejZdS)�PyBufferedWriterTestN)rrrr]r�r<rrrrr��sr�c@seZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+S),�BufferedRWPairTestcCs2|j|j�|j��}|j|j�dS)N)r<r>rrM)r)�pairrrrrk�sz#BufferedRWPairTest.test_constructorcCs�|jj|j�}~|jj|j�}|jttfd|jd�|jttfd|jd�|j|j�|j��|j	|jd�d�|j	|jd�d�dS)Nzuninitialized|has no attributerr?)
r<rlrmrgr�rAr,r*r>rv)r)r�rrrrn�s

z%BufferedRWPairTest.test_uninitializedcCs8|j|j�|j��}|j|j|j�dS)N)r<r>rxrXr>)r)r�rrrr@�szBufferedRWPairTest.test_detachcCs=|jt��'|j|j�|j�dd�WdQRXdS)Nr�ru)rxryr<r>)r)rrr�(test_constructor_max_buffer_size_removal�sz;BufferedRWPairTest.test_constructor_max_buffer_size_removalcCs<Gdd�dt�}|jt|j|�|j��dS)Nc@seZdZdd�ZdS)zJBufferedRWPairTest.test_constructor_with_not_readable.<locals>.NotReadablecSsdS)NFr)r)rrrr0�szSBufferedRWPairTest.test_constructor_with_not_readable.<locals>.NotReadable.readableN)rrrr0rrrr�NotReadable�sr�)r>rxrNr<)r)r�rrr�"test_constructor_with_not_readable�sz5BufferedRWPairTest.test_constructor_with_not_readablecCs<Gdd�dt�}|jt|j|j�|��dS)Nc@seZdZdd�ZdS)zLBufferedRWPairTest.test_constructor_with_not_writeable.<locals>.NotWriteablecSsdS)NFr)r)rrrr-�szUBufferedRWPairTest.test_constructor_with_not_writeable.<locals>.NotWriteable.writableN)rrrr-rrrr�NotWriteable�sr�)r>rxrNr<)r)r�rrr�#test_constructor_with_not_writeable�sz6BufferedRWPairTest.test_constructor_with_not_writeablecCs�|j|jd�|j��}|j|jd�d�|j|jd�d�|j|j�d�|j|jd�|j��}|j|jd�d�dS)Nsabcdefr�sabcr5rsef)r<r�r>rvrA)r)r�rrrrs�s!!zBufferedRWPairTest.test_readcs|�fdd�}�j|�j�dddg��j|�j�dddg��j|�jd�ddg�dS)Ncs�j�jd��j��S)Ns	abc
def
h)r<r�r>r)r)rrrsz3BufferedRWPairTest.test_readlines.<locals>.<lambda>sabc
sdef
rsrI)rvr�)r)r�r)r)rr�s""z!BufferedRWPairTest.test_readlinescCs>|j|jd�|j��}|j|jd�d�dS)Nsabcdefr�sabc)r<r�r>rvr))r)r�rrrrxs!zBufferedRWPairTest.test_read1cCs�x�dD]}|j|��g|j|jd�|j��}td�}|jt||�|�d�|jt|�d�WdQRXqWdS)Nr9rsabcdefrIsabcde)r9r)r�r<r�r>rrvr+r)r)r-r�rrrrr{s
!z BufferedRWPairTest.test_readintocCs�|j�}|j|j�|�}|jd�|j�td�}|j|�d|dd�<|j�|j|jddg�dS)Nsabcsdefs***)r>r<r,r�rwrvr&)r)r�r�rzrrrr�s



zBufferedRWPairTest.test_writecCs]|j|jd�|j��}|j|jd�jd��|j|jd�d�dS)Nsabcdefr�sabc)r<r�r>rr�r�rvrA)r)r�rrr�	test_peek#s!zBufferedRWPairTest.test_peekcCs5|j|j�|j��}|j|j��dS)N)r<r>rr0)r)r�rrr�
test_readable)sz BufferedRWPairTest.test_readablecCs5|j|j�|j��}|j|j��dS)N)r<r>rr-)r)r�rrr�test_writeable-sz!BufferedRWPairTest.test_writeablecCs5|j|j�|j��}|j|j��dS)N)r<r>rr1)r)r�rrr�
test_seekable1sz BufferedRWPairTest.test_seekablecCsL|j|j�|j��}|j|j�|j�|j|j�dS)N)r<r>rrMrOr)r)r�rrr�test_close_and_closed:s
z(BufferedRWPairTest.test_close_and_closedcCs�dd�}|j�}||_|j�}|j||�}|jt��}|j�WdQRX|jdt|j��|j|j	�|j
|j	�|j|j	�dS)NcSstdS)N)�reader_non_existingrrrr�reader_closeAszIBufferedRWPairTest.test_reader_close_error_on_close.<locals>.reader_closer�)r>rOr<rxr\r]rrrrMr)r)r��readerr�r�rXrrr� test_reader_close_error_on_close@s	z3BufferedRWPairTest.test_reader_close_error_on_closecCs�dd�}|j�}|j�}||_|j||�}|jt��}|j�WdQRX|jdt|j��|j|j	�|j
|j	�|j|j	�dS)NcSstdS)N)�writer_non_existingrrrr�writer_closeOszIBufferedRWPairTest.test_writer_close_error_on_close.<locals>.writer_closer�)r>rOr<rxr\r]rrrrMr)r)r�r�r�r�rXrrr� test_writer_close_error_on_closeNs	z3BufferedRWPairTest.test_writer_close_error_on_closecCs�dd�}dd�}|j�}||_|j�}||_|j||�}|jt��}|j�WdQRX|jdt|j��|j|jj	t�|jdt|jj	��|j
|j�|j
|j�|j
|j�dS)NcSstdS)N)r�rrrrr�]szPBufferedRWPairTest.test_reader_writer_close_error_on_close.<locals>.reader_closecSstdS)N)r�rrrrr�_szPBufferedRWPairTest.test_reader_writer_close_error_on_close.<locals>.writer_closer�r�)r>rOr<rxr\r]rrrVrWrrM)r)r�r�r�r�r�rXrrr�'test_reader_writer_close_error_on_close\s		z:BufferedRWPairTest.test_reader_writer_close_error_on_closecCs�Gdd�dt�}|j|d�|d��}|j|j��|j|d�|d��}|j|j��|j|d�|d��}|j|j��|j|d�|d��}|j|j��dS)Nc@s(eZdZdd�Zdd�ZdS)z8BufferedRWPairTest.test_isatty.<locals>.SelectableIsAttycSstj|�||_dS)N)r>r*�_isatty)r)�isattyrrrr*qs
zABufferedRWPairTest.test_isatty.<locals>.SelectableIsAtty.__init__cSs|jS)N)r�)r)rrrr�usz?BufferedRWPairTest.test_isatty.<locals>.SelectableIsAtty.isattyN)rrrr*r�rrrr�SelectableIsAttypsr�FT)r>r<rr�r)r)r�r�rrr�test_isattyoszBufferedRWPairTest.test_isattycCs=|j|j�|j��}tj|�}d}d}dS)N)r<r>r�r�)r)Zbrwr�rrr�test_weakref_clearing�sz(BufferedRWPairTest.test_weakref_clearingN)rrrrkrnr@r�r�r�rsr�rxr{r�r�r�r�r�r�r�r�r�r�r�rrrrr��s*			r�c@seZdZejZdS)�CBufferedRWPairTestN)rrrr[r�r<rrrrr��sr�c@seZdZejZdS)�PyBufferedRWPairTestN)rrrr]r�r<rrrrr��sr�c@seZdZdZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+Zd+S),�BufferedRandomTestzrb+zwb+cCstj|�tj|�dS)N)rirkr�)r)rrrrk�s
z#BufferedRandomTest.test_constructorcCstj|�tj|�dS)N)rirnr�)r)rrrrn�s
z%BufferedRandomTest.test_uninitializedcCs�|jd
�}|j|d�}|jd|jd��|jd�|jd�|j|j�|jd|j��|jd|jd	�dS)N�asdf�ghjkr�sasrEsdddseeesdddeeer)r�r)r>r<rvrAr,rr&)r)r�r�rrr�test_read_and_write�s

z&BufferedRandomTest.test_read_and_writecCs^|jd�}|j|�}|jd|jd��|jd|j��|jdd�|jd|jd��|jd�|jdd�|jd|j��|jd	|j��|jdd�|jd
|j��|jdd�|jd|j��|jd
|jd��|j�|jd|j��|j	t
|jd�dS)Ns	asdfghjklsasrErsasdfr�s123fs	asdf123flrqrIr5rosfl�g���)r�r<rvrAr4r3r,r�r�rxry)r)r�r�rrr�test_seek_and_tell�s$

z%BufferedRandomTest.test_seek_and_tellcCs�|jd�}|j|�}|jd||d��|jd�|jd||d��|jd|j��|j�|jd|j��|jd||��|jdd�|jd	�|j�|jdd�|jd	||d
��dS)Ns	abcdefghisabrEs12sefrpsghirsXYZr�)r�r<rvr,r4r�r3)r)Z	read_funcr�rArrr�check_flush_and_read�s



z'BufferedRandomTest.check_flush_and_readcCs|jdd��dS)NcWs
|j|�S)N)rA)rArYrrrr�sz8BufferedRandomTest.test_flush_and_read.<locals>.<lambda>)r)r)rrr�test_flush_and_read�sz&BufferedRandomTest.test_flush_and_readcCs ddd�}|j|�dS)Nr5cSsAt|dkr|nd�}|j|�}t|d|��S)Nri')rwr9r)rAr8r	rrr�	_readinto�sz=BufferedRandomTest.test_flush_and_readinto.<locals>._readintore)r)r)rrrr�test_flush_and_readinto�sz*BufferedRandomTest.test_flush_and_readintocCs ddd�}|j|�dS)Nr5cSsE|j|�}|dkr+|d|�}|jt|�d�|S)Nr5re)r�r3r)rAr8r	rrr�_peek�s
z5BufferedRandomTest.test_flush_and_peek.<locals>._peekre)r)r)r	rrr�test_flush_and_peek�sz&BufferedRandomTest.test_flush_and_peekcCs�|jd�}|j|�}|jd�|j�|jd�|j�|jdd�|jd|j��|jd|j��dS)Ns	abcdefghis123s45rs	12345fghi)r�r<r,r�r3rvr�rA)r)r�rArrr�test_flush_and_write�s



z'BufferedRandomTest.test_flush_and_writecCstj|�tj|�dS)N)rir�r�)r)rrrr��s
zBufferedRandomTest.test_threadscCs6dd�}|j|�dd�}|j|�dS)NcSs|jd�dS)Nr5)r�)rArrrr	�sz6BufferedRandomTest.test_writes_and_peek.<locals>._peekcSs=|j�}|jdd�|jd�|j|d�dS)Nr5rre)r4r3r�)rArrrrr	�s
)r�)r)r	rrr�test_writes_and_peek�s
z'BufferedRandomTest.test_writes_and_peekcCsdd�}|j|�dS)NcSs!|jdd�|jd�dS)Nr5re)r3rA)rArrr�_readsz7BufferedRandomTest.test_writes_and_reads.<locals>._read)r�)r)r
rrr�test_writes_and_readssz(BufferedRandomTest.test_writes_and_readscCsdd�}|j|�dS)NcSs!|jdd�|jd�dS)Nr5re)r3r))rArrr�_read1sz9BufferedRandomTest.test_writes_and_read1s.<locals>._read1)r�)r)rrrr�test_writes_and_read1ssz)BufferedRandomTest.test_writes_and_read1scCsdd�}|j|�dS)NcSs'|jdd�|jtd��dS)Nr5re)r3r9rw)rArrrr
sz;BufferedRandomTest.test_writes_and_readintos.<locals>._read)r�)r)r
rrr�test_writes_and_readintos
sz,BufferedRandomTest.test_writes_and_readintoscCs�x�ddgD]�}|jd�}|j|d�}|j|jd�d�|j|j�d�|jd|�|j|j�|d�|j�|j|j�|d�|j�}|j|dd|dd|�q
WdS)	Nr5rIr_r~r��Brqs
AAAAAAAAAA)r�r<rvrAr4r,r�r�)r)Zoverwrite_sizer�rArarrr�test_write_after_readaheads
	z-BufferedRandomTest.test_write_after_readaheadcCs�dd�}d}x�tdt|��D]�}x�t|t|��D]�}|j|�}|j|d�}||||�|j�t|�}d||<d||<|j|j�|d||f�qDWq(WdS)	NcSsI|j|�|j||�|jd�|j|�|jd�dS)Nss)r3rAr,)rAZpos1Zpos2rrr�mutate)s



z:BufferedRandomTest.test_write_rewind_write.<locals>.mutates�����rr�rEr5zfailed result for i=%d, j=%d)r�rr�r<r�rwrvr�)r)rr	r��jr�rA�expectedrrr�test_write_rewind_write's


z*BufferedRandomTest.test_write_rewind_writecCs�|jd�}|j|d�}|j|jd�d�|j|j�d�|j|jd�d�|j|j�d�dS)	Nr_r~r�rEsAAsBBr�s
AAAAAAAAAA)r�r<rvrAr:r,)r)r�rArrr�!test_truncate_after_read_or_writeAsz4BufferedRandomTest.test_truncate_after_read_or_writecCstj|�tj|�dS)N)rir�r�)r)rrrr�Is
z%BufferedRandomTest.test_misbehaved_iocCs�|jd���}|j|d���}|jd�|j|jd�d�|jd�|j|jd�d�|jd�td�}|j|�|j|d	�|jd
�|j|jd�d�|j	�|j|j
�d�WdQRXWdQRX|jd
���}|j|d��f}|j|jd�d�|jd�|j|jd�d�|j	�|j|j
�d�WdQRXWdQRXdS)Nsabcdefghr��1r5rw�2rr��f�4rss1b2d3f4hsabcrvrsa2c)r�r<r,rvrAr)rwr9r�r�r�)r)r�r!r7rrr�test_interleaved_read_writeMs*





$

z.BufferedRandomTest.test_interleaved_read_writecCs�|jd���}|j|���}|jd�|j|j�d�|jd�|j|j�d�|jd�|j|j�d�|j�|j|j�d�WdQRXWdQRXdS)	Ns
ab
cdef
g
rsb
rsdef
r�s
s
1b
2def
3
)r�r<r,rvr�r�r�)r)r�r!rrr�test_interleaved_readline_writefs



z2BufferedRandomTest.test_interleaved_readline_writeN)rrrr�r�rkrnrrrrrr
rr�rrrrrrrr�rrr`rrrrr��s.
r�c@s=eZdZejZdd�Zdd�Zdd�ZdS)�CBufferedRandomTestcCs`tj|�tjdkr\|j�}|j|�}|jttt	f|j
|tj�dS)Ni���)r�rkr�r�r>r<rxr�r�rgr*)r)rrArrrrkys
z$CBufferedRandomTest.test_constructorcCstj|�tj|�dS)N)r�r�r�)r)rrrr��s
z+CBufferedRandomTest.test_garbage_collectioncCs:|jtd��!|jtj�ddd�WdQRXdS)Nr�i)rmryr<r[r�)r)rrrr��sz#CBufferedRandomTest.test_args_errorN)	rrrr[r�r<rkr�r�rrrrrvs	
rc@seZdZejZdS)�PyBufferedRandomTestN)rrrr]r�r<rrrrr �sr c@s�eZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
dd�Z	dd�Z
d
Zedd��Z
dS)�StatefulIncrementalDecodera�
    For testing seek/tell behavior with a stateful, buffering decoder.

    Input is a sequence of words.  Words may be fixed-length (length set
    by input) or variable-length (period-terminated).  In variable-length
    mode, extra periods are ignored.  Possible words are:
      - 'i' followed by a number sets the input length, I (maximum 99).
        When I is set to 0, words are space-terminated.
      - 'o' followed by a number sets the output length, O (maximum 99).
      - Any other word is converted into a word followed by a period on
        the output.  The output word consists of the input word truncated
        or padded out with hyphens to make its length equal to O.  If O
        is 0, the word is output verbatim without truncating or padding.
    I and O are initially set to 1.  When I changes, any buffered input is
    re-scanned according to the new I.  EOF also terminates the last word.
    �strictcCs!tjj||�|j�dS)N)�codecs�IncrementalDecoderr*�reset)r)r�rrrr*�sz#StatefulIncrementalDecoder.__init__cCsdt|�S)Nz<SID %x>)�id)r)rrr�__repr__�sz#StatefulIncrementalDecoder.__repr__cCs"d|_d|_t�|_dS)Nr5)r��orwrz)r)rrrr%�s		z StatefulIncrementalDecoder.resetcCs6|jdA|jdA}}t|j�|d|fS)Nr5r�)r�r(rrz)r)r�r(rrr�getstate�sz#StatefulIncrementalDecoder.getstatecCsO|\}}t|�|_t|d�\}}|dA|dA|_|_dS)Nr�r5)rwrz�divmodr�r()r)�staterzr[r�r(rrr�setstate�sz#StatefulIncrementalDecoder.setstateFcCs�d}x�|D]�}|jdkrc|td�krP|jr`||j�7}q�|jj|�q
|jj|�t|j�|jkr
||j�7}q
W|r�|jr�||j�7}|S)Nr�r�.)r��ordrz�process_wordr+r)r)�input�final�outputr	rrr�decode�s
	z!StatefulIncrementalDecoder.decodecCsd}|jdtd�krMtdt|jdd�p>d��|_n�|jdtd�kr�tdt|jdd�p�d��|_n^|jjd�}t|�|jkr�|d|j7}|jr�|d|j�}|d	7}t�|_|S)
Nr�rr��cr5r(r��-r-)	rzr.r��intr�r(r3rrw)r)r2rrrr/�s..	
z'StatefulIncrementalDecoder.process_wordcCs_|jr[|dkr[tjd�}tjddd|jddddddddd	|�SdS)
N�test_decoderzlatin-1rP�encoder3�incrementalencoder�streamreader�streamwriter�incrementaldecoder)�codecEnabledr#�lookup�	CodecInfor8)�clsrP�latin1rrr�lookupTestDecoder�s	z,StatefulIncrementalDecoder.lookupTestDecoderN)rrrr;r*r'r%r)r,r3r/r=�classmethodrBrrrrr!�sr!c
@sjeZdZdZdddd d!d"ddddddddddddfgZdd�ZdS)#�StatefulIncrementalDecoderTestzB
    Make sure the StatefulIncrementalDecoder actually works.
    �abcdF�a.b.c.d.�oiabcdT�abcd.�oi...abcd...�i.o6.x.xyz.toolongtofit.�x-----.xyz---.toolon.�
i.i2.o6xyz�xy----.z-----.�i.o3.i6.abcdefghijklmnop�abc.ghi.mno.s;i.o29.a.b.cde.o15.abcdefghijabcdefghij.i3.a.b.c.d.ei00k.l.mza----------------------------.zb----------------------------.zcde--------------------------.zabcdefghijabcde.za.b------------.z.c.------------.zd.e------------.zk--------------.zl--------------.zm--------------.cCs�x?|jD]4\}}}t�}|j|j||�|�q
Wt�}|j|jd�d�|j|jdd�d�dS)Nsoiabcdr�r?r5zabcd.)�
test_casesr!rvr3)r)r0�eofr2�drrrr7	s	 	z+StatefulIncrementalDecoderTest.test_decoderN)rEFrF)rGTrH)rITrH)rJFrK)rLTrM)rNTrO)rrrr;rPr7rrrrrD�s	#
rDc@s"eZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Ze
jdd��Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Z d9d:�Z!d;d<�Z"d=d>�Z#d?d@�Z$dAdB�Z%dCdD�Z&dEdF�Z'dGdH�Z(dIdJ�Z)dKdL�Z*dMdN�Z+dOdP�Z,dQdR�Z-dSdT�Z.dUdV�Z/dWdX�Z0e
j1e2j3e4dY�dZd[���Z5d\d]�Z6d^d_�Z7d`da�Z8dbdc�Z9ddde�Z:dfdg�Z;dhdi�Z<djdk�Z=dldm�Z>dndo�Z?dpdq�Z@drds�ZAe
jBdtdu��ZCe
jBdvdw��ZDdxdy�ZEdzd{�ZFd|S)}�TextIOWrapperTestcCs/d|_djd�|_tjtj�dS)NsAAA
BBB
CCC
DDD
EEE
sAAA
BBB
CCC
DDD
EEE
r�)�testdatar3�
normalizedrrlrm)r)rrrrn#	s	zTextIOWrapperTest.setUpcCstjtj�dS)N)rrlrm)r)rrrro(	szTextIOWrapperTest.tearDowncCs|jd�}|j|d�}|j|�}|j|dddd�|j|jd�|j|jd�|j|ddd	d
�|j|jd�|j|jd
�|jd|j��|jt	|j|dd�|jt
|j|dd
�dS)Nsé

i�rzlatin-1r&z
Fzutf-8�line_bufferingTué
r.rH)r�r�r�r*rvrrVr�rxryrg)r)rr	�trrrrk+	sz"TextIOWrapperTest.test_constructorcCs�|jj|j�}~|jj|j�}|jtt|�|jttfd|jd�|j	|j
��|j|jd�d�dS)Nzuninitialized|has no attributerr�)r�rlrxr�r?rmrgr�rAr*r>rv)r)rWrrrrn9	s
z$TextIOWrapperTest.test_uninitializedcCsL|j�}|j|�}|jtd��|j|dd�WdQRXdS)Nzis not a text encodingr�hex)r�r�rm�LookupErrorr�)r)rr	rrr�*test_non_text_encoding_codecs_are_rejectedD	sz<TextIOWrapperTest.test_non_text_encoding_codecs_are_rejectedcCs�|j�}|j|�}|j|�}|j|j�|�|j|dd�}|jd�|j|j��|j�|j|j�d�|j	t
|j�t|�|j|jd�|j|j
d�|j|j�dS)Nrr�Zhowdyshowdyr")r�r�r�r=r>r,rr�rvrxrgr?rr�rV)r)rr	rWrrrr@M	s


zTextIOWrapperTest.test_detachcCs�|jdjd��}|j|�}|j|dd�}|jj}|jt|�d|�d|_|jt|�d|�d|_|jt|�d|�d	|_|jt|�d
|�|j	j
�t|�dS)NZhellozutf-8rz#<%s.TextIOWrapper encoding='utf-8'>rOz0<%s.TextIOWrapper name='dummy' encoding='utf-8'>rz9<%s.TextIOWrapper name='dummy' mode='r' encoding='utf-8'>sdummyz:<%s.TextIOWrapper name=b'dummy' mode='r' encoding='utf-8'>)r�r8r�r�rrvr?rPr�rzr>)r)r�r	rW�modnamerrrrQ`	s"			
zTextIOWrapperTest.test_reprcCs_|j�}|j|�}tj|d|��(yt|�Wntk
rSYnXWdQRXdS)NrP)r�r�rrRr?rS)r)r�rWrrrrTt	s
z%TextIOWrapperTest.test_recursive_reprcCs�|j�}|j|d�}|j|dddd�}|jd�|j|j�d�|jd�|j|j�d	�|jd
�|j|j�d�dS)Ni�r&�
rVT�Xr?zY
ZsXY
ZzA
BsXY
ZA
B)r�r�r�r,rvr�)r)rr	rWrrr�test_line_buffering~	s


z%TextIOWrapperTest.test_line_bufferingcCs�ttj�}zkx'dD]}|tjkrtj|=qWtjd�}|j�}|j|�}|j|j|�Wdtjj	�tjj
|�XdS)N�LC_ALL�LANG�LC_CTYPEF)r_r`ra)�dictr��environ�locale�getpreferredencodingr�r�rvr�clear�update)r)Zold_environ�keyZcurrent_locale_encodingr	rWrrr�test_default_encoding�	s

z'TextIOWrapperTest.test_default_encodingcsrddl�|j�}�fdd�|_|jt|j|��fdd�|_|jt|j|�dS)Nrcs�jdS)Nr5)ZINT_MAXr)�	_testcapirrr�	sz8TextIOWrapperTest.test_device_encoding.<locals>.<lambda>cs�jdS)Nr5)ZUINT_MAXr)rjrrr�	s)rjr�r/rxr�r�)r)r	r)rjr�test_device_encoding�	sz&TextIOWrapperTest.test_device_encodingcCsg|j�}|j|dd�}|j|jd�|j|�}|j|j�tj|j�dS)Nrzutf-8)r�r�rvr�assertIsNotNoner#r>)r)r	rWrrr�
test_encoding�	szTextIOWrapperTest.test_encodingcCs�|jd�}|j|dd�}|jt|j�|jd�}|j|dddd�}|jt|j�|jd�}|j|dddd�}|j|j�d�|jd�}|j|dddd�}|j|j�d	�dS)
Nsabc
�
rr�r�r"r3zabc

�replaceuabc
�
)r�r�rx�UnicodeErrorrArv)r)r	rWrrr�test_encoding_errors_reading�	sz.TextIOWrapperTest.test_encoding_errors_readingcCs,|j�}|j|dd�}|jt|jd�|j�}|j|dddd�}|jt|jd�|j�}|j|dddddd�}|jd	�|j�|j|j�d
�|j�}|j|dddddd�}|jd	�|j�|j|j�d�dS)
Nrr��ÿr�r"r3r&r\u	abcÿdef
sabcdef
rnsabc?def
)r�r�rxror,r�rvr�)r)r	rWrrr�test_encoding_errors_writing�	s$	

	

z.TextIOWrapperTest.test_encoding_errors_writingc
Cs�dddddg}ddddddggd|gd	ddd
dggddd
ggddddggg}d!}x[|D]S}tdj|�j|��}x,d"D]$}xtdd�D]
}x|D]�\}}	|j|j|�|�}
|j|
d|d|�}|rng}x\|jd �}
|
dkr:P|jt	|
�d �|j
|
|j��qWnt|�}x-t
||	�D]\}}|j||�q�W|jt	|�t	|	��q�Wq�Wq�WqWdS)#Nzunix
z	windows
zos9
zlast
Znonlzwindows
zos9
r�r\z	os9
last
z
zunix
windows
z
os9
last
nonl�
z
unix
windows
z
os9
z	last
nonl�utf-8�latin-1�utf-16�	utf-16-le�	utf-16-be�utf-32�	utf-32-le�	utf-32-beFTr5r~r&rrE)rtrurvrwrxryrzr{)FT)rr`r8r�r�r�r�rArvrr+r�r$�zip)r)Zinput_linesr��	encodingsrrZdo_readsr�r&Z	exp_linesrA�textioZ	got_linesZc2Zgot_lineZexp_linerrr�
test_newlines�	s:	

	zTextIOWrapperTest.test_newlinesc
Cs)d}|jdd�jdd�}x�d|jd�jdd�fd|jd�jdd�fd	d
ddd
dgfddd
dgfddddddgfgD]x\}}|j|�}|j|ddd|�}|j|j�|�|jd�|j|j�dj	|��q�WdS)NsAAA
BBB
CCC
DDD
EEE
FFF
GGGs
s
s
r��keependsTr�r\zAAA
zBBB
z
CCC
DDD
EEE
zFFF
ZGGGz
zAAA
BBB
CCC
DDD
EEE
rsz
AAA
BBB
CCC
zDDD
zEEE
z
FFF
z
GGGrr&r)
rnr3rLr�r�rvr�r3rAr`)r)rTrUr&rr7�txtrrr�test_newlines_input
s(
z%TextIOWrapperTest.test_newlines_inputcCs�ddddddddi}d|tjfgt|j��}x�|D]�\}}|j�}|j|dd	d
|�}|jd�|jd�|jd
�|j�|j|j	d�|j|j
�|�qKWdS)Nr�sAAA
BBB
CCC
X
Y
Zr\rssAAA
BBB
CCC
X
Y

Zz
sAAA
BBB
CCC
X
Y

Zrr�r&zAAA
BzBB
CCC
zX
Y
ZF)r��linesep�sorted�itemsr�r�r,r�rvrMr�)r)Ztestdictr�r&rr7r�rrr�test_newlines_output
s&



z&TextIOWrapperTest.test_newlines_outputcs}g�|j�G��fdd�d��}|�}|j|dd�}|jd�~tj�|jdg��dS)Ncs%eZdZ��fdd�ZdS)z4TextIOWrapperTest.test_destructor.<locals>.MyBytesIOcs$�j|j���j|�dS)N)r+r�rO)r))r�r�rrrO(
sz:TextIOWrapperTest.test_destructor.<locals>.MyBytesIO.closeN)rrrrOr)r�r�rr�	MyBytesIO'
sr�rr�r�sabc)r�r�r,rr�rv)r)r�r	rWr)r�r�rr�$
s		

z!TextIOWrapperTest.test_destructorcsmg�G�fdd�d|j�}|j�}||dd�}~tj�|j�dddg�dS)NcsOeZdZ��fdd�Z��fdd�Z��fdd�Z�S)z<TextIOWrapperTest.test_override_destructor.<locals>.MyTextIOcs=�jd�yt�j}Wntk
r1YnX|�dS)Nr5)r+rFr�r�)r)r!)rGr�rrr�5
s

zDTextIOWrapperTest.test_override_destructor.<locals>.MyTextIO.__del__cs�jd�t�j�dS)NrE)r+rFrO)r))rGr�rrrO=
s
zBTextIOWrapperTest.test_override_destructor.<locals>.MyTextIO.closecs�jd�t�j�dS)Nr�)r+rFr�)r))rGr�rrr�@
s
zBTextIOWrapperTest.test_override_destructor.<locals>.MyTextIO.flush)rrrr�rOr�r)r�)rGr�MyTextIO4
sr�rr�r5rEr�)r�r�rr�rv)r)r�r	rWr)r�rrE2
s
z*TextIOWrapperTest.test_override_destructorc
s��j����fdd�}tjd��}�jt|�WdQRX|j�j�}|r��jt|j	��d��j
|jd�|��j
|jd�|�dS)Ncs�j��jdS)N)r�rHr)rr)rrr!M
sz:TextIOWrapperTest.test_error_through_destructor.<locals>.frIr5zException OSError: z ignored)
rLrrJrxr�r�rKrvrrLrr�rM)r)r!rar)rr)rrNI
sz/TextIOWrapperTest.test_error_through_destructorcCs%xdD]}x
dD]}|jtjdd|�}||_|j|jd�d�|j�|jtjdd|�}||_|j|j�d�|j|j�d�|j�}|j|j	d�d�|j|jd�d�|j	d�|j|jd�d�|j|jd�d�|j|jd�d�|j|j�d�|j|j�|�|j|j	d�d�|j|j	dd�|�|j|jd�d�|j|j	|�|�|j|j�d�|j
d�r|j||�|j�qWqWdS)Nr5rEr�r�rIr�rj�r�r��!�?�@�Ar��latin-1�utf-8zw+rr�zr+rr�r�r��def�utf)r5rEr�r�rIr�rjr�r�r�r�r�r�r�)r�r�r�)rrrmr rvr,rOr4rAr3r��multi_line_test)r)Z	chunksize�encr!�cookierrr�
test_basic_ioZ
s6

	
	
zTextIOWrapperTest.test_basic_iocCs|jd�|j�d}g}xdD]w}g}x/t|�D]!}|j||t|��qCWdj|�d}|j|j�|f�|j|�q*W|jd�g}	x6|j�}
|j�}|s�P|	j|
|f�q�W|j	|	|�dS)Nru	sÿ࿿￿r5rEr�r�rI�r�r�r��>r�r�r���r�r\)rr5rEr�r�rIr�r�r�r�r�r�r�r�r�)
r3r:r�r+rr`r4r,r�rv)r)r!r�ZsampleZwlinesr(�charsr��lineZrlinesrrrrr�w
s(



z!TextIOWrapperTest.multi_line_testcCs9|jtjddd�}|j�}|jd�|j�}|jd�|j�}|jd�|j|j�|�|j|j�d�|j|j�|�|j|j�d�|j|j�|�|jd�x1|D])}|j|d�|jt	|j�q�W|j|j�|�|j
�dS)Nzw+rzutf-8uÿ
r)rrrmr4r,r3rvr�rxrNrO)r)r!Zp0Zp1Zp2r�rrr�test_telling�
s$




zTextIOWrapperTest.test_tellingc
Cs t�}|d}d|}t|jd��}|jt|�t|��d}t|jd��}||}|jtjd��}|j|d�WdQRX|jtjddd��[}|j	|�}	|j|	t
|d��|j|j�|�|j|j�|�WdQRXdS)	NrEr�zutf-8u袈
r�rrr�)
r"rr8rvrrrrmr,rArr4r�)
r)Z
chunk_sizeZprefix_sizeZu_prefix�prefixZu_suffix�suffixr�r!rarrr�test_seeking�
s	


zTextIOWrapperTest.test_seekingcCsd}|jtjd��}|j|�WdQRX|jtjddd��+}|jd|_|j�|j�WdQRXdS)Ns࿿
r�rrzutf-8rE)rrrmr,r r�r4)r)rr!rrr�test_seeking_too�
s	
z"TextIOWrapperTest.test_seeking_toocs�d�d��fdd�}dt_z�x$tjD]\}}}||�q4WxStjD]H\}}}�t|�d}d|}|d}||||�q[WWddt_XdS)N�rcsT�jtjd�}|j|�|j��jtjdd�}�|_|j�}|j�x�t|t|�d�D]�}x�ddt|�|gD]�}�jtjdd�}�j	|j|�|d|��|j
�}�j	|j|�||||��|j|��j	|j�||d��|j�q�Wq}WdS)zTell/seek to various points within a data stream and ensure
            that the decoded data returned by read() is consistent.r�rr7r5rIN)rrrmr,rOr rAr�rrvr4r3)r�min_posr!Zdecodedr�rr�)�
CHUNK_SIZEr)rr�test_seek_and_tell_with_data�
s 

	
  #'
 zJTextIOWrapperTest.test_seek_and_tell.<locals>.test_seek_and_tell_with_datar5rE�.)r!r=rDrPr)r)r�r0�_�offsetr�r�r)r�r)rr�
s	

z$TextIOWrapperTest.test_seek_and_tellcCs�d}d}x�|D]�}|j�}|j|d|�}|j|�|j|�|jd	�|j|j�|d
�|jd	�|j|j�|d
�|j|j�|d
j|��qWdS)NZ
1234567890�utf-16�	utf-16-le�	utf-16-be�utf-32�	utf-32-le�	utf-32-berrrE)r�r�r�r�r�r�)r�r�r,r3rvrAr�r8)r)rr�rr7r!rrr�test_encoded_writes�
s"




z%TextIOWrapperTest.test_encoded_writescCsBGdd�d|j�}|j|��}|jt|j�dS)Nc@seZdZdd�ZdS)z5TextIOWrapperTest.test_unreadable.<locals>.UnReadablecSsdS)NFr)r)rrrr0sz>TextIOWrapperTest.test_unreadable.<locals>.UnReadable.readableN)rrrr0rrrr�
UnReadablesr�)r�r�rxrNrA)r)r�r�rrr�test_unreadablesz!TextIOWrapperTest.test_unreadablecCsY|j|jd��}d}x$|jd�}|s7P||7}q!W|j|d�dS)NsAA
BBr�r5zAA
BB)r�r�rArv)r)r��readsr�rrr�test_read_one_by_onesz&TextIOWrapperTest.test_read_one_by_onecCs�|j|jd��}|j|j�dddg�|jd�|j|jd�dddg�|jd�|j|jd�ddg�dS)NsAA
BB
CCzAA
zBB
�CCrrI)r�r�rvr�r3)r)r�rrrr�s
"
z TextIOWrapperTest.test_readlinescCsi|j|jddd��}d}x$|jd�}|s?P||7}q)W|j|ddd�dS)Nr_�s
Br�r��Az
B)r�r�rArv)r)r�r�r�rrr�test_read_by_chunks z$TextIOWrapperTest.test_read_by_chunkcCs[dddg}|j�}|j|�}|j|�|j�|j|j�d�dS)Nr��cd�efsabcdef)r�r�r�r�rvr�)r)r�r7r�rrrr�%s

z!TextIOWrapperTest.test_writelinescCsatdddg�}|j�}|j|�}|j|�|j�|j|j�d�dS)Nr�r�r�sabcdef)rr�r�r�r�rvr�)r)r�r7r�rrrr�-s

z*TextIOWrapperTest.test_writelines_userlistcCsd|j|j��}|jt|jdddg�|jt|jd�|jt|jd�dS)Nr5rEr�sabc)r�r�rxryr�)r)r�rrrr�5sz'TextIOWrapperTest.test_writelines_errorcCse|j|j|j�dd�}d}x$|jd�}|s@P||7}q*W|j||j�dS)Nrr�r�r5)r�r�rTrArvrU)r)r�r�r�rrr�test_issue1395_1;s!z"TextIOWrapperTest.test_issue1395_1cCsn|j|j|j�dd�}d|_d}x$|jd�}|sIP||7}q3W|j||j�dS)Nrr�r�r�)r�r�rTr rArvrU)r)r�r�r�rrr�test_issue1395_2Gs!	z"TextIOWrapperTest.test_issue1395_2cCs�|j|j|j�dd�}d|_|jd�}||jd�7}||j�7}||j�7}||j�7}|j||j�dS)Nrr�r�)r�r�rTr rAr�rvrU)r)r�r�rrr�test_issue1395_3Ss!	z"TextIOWrapperTest.test_issue1395_3cCs`|j|j|j�dd�}d|_|jd�}||j�7}|j||j�dS)Nrr�r�)r�r�rTr rArvrU)r)r�r�rrr�test_issue1395_4^s
!	z"TextIOWrapperTest.test_issue1395_4cCs||j|j|j�dd�}d|_|jd�}|j�}|jd�|j|�|j|jd�d�dS)Nrr�r�rzBBB
)r�r�rTr rAr4r3rv)r)r�r�rrrr�test_issue1395_5fs!	

z"TextIOWrapperTest.test_issue1395_5cCsG|j|j�}|j|dd�}|j|j�|j��dS)Nrr�)r�rTr�rvr1)r)rzr�rrr�test_issue2282psz TextIOWrapperTest.test_issue2282c!Cs�tj}x�dD]�}|j|dd|�� }|jd�|j�}WdQRX|j|d��&}|j|j�dj|��WdQRX|j|dd|��}|jd	�WdQRX|j|d��&}|j|j�d
j|��WdQRXqWdS)N�	utf-8-sig�utf-16�utf-32r�r�aaar�r��xxx�aaaxxx)r�r�r�)rrmrr,r4rvrAr8)r)�filename�charsetr!rrrr�test_append_bomvs	

&z!TextIOWrapperTest.test_append_bomcCs�tj}x�d
D]�}|j|dd|�� }|jd�|j�}WdQRX|j|dd|��;}|j|�|jd�|jd	�|jd
�WdQRX|j|d��&}|j|j�dj|��WdQRXqWdS)N�	utf-8-sig�utf-16�utf-32r�rr�zr+ZzzzrZbbbr�Zbbbzzz)r�r�r�)	rrmrr,r4r3rvrAr8)r)r�r�r!rrrr�
test_seek_bom�s	




zTextIOWrapperTest.test_seek_bomcCs�tj}x�dD]�}|j|dd|��}|jd�WdQRX|j|dd|��4}|jd�|jd|j�|jd	�WdQRX|j|d
��&}|j|j�dj|��WdQRXqWdS)
N�	utf-8-sig�utf-16�utf-32r�rr�r�rr�r�r�)r�r�r�)	rrmrr,r3r�rvrAr8)r)r�r�r!rrr�test_seek_append_bom�s	

z&TextIOWrapperTest.test_seek_append_bomcCsn|jtjd��}|j|jd�WdQRX|jtjddd��}|j|jd�WdQRXdS)Nr�r"r�rn)rrrmrvr�)r)r!rrr�test_errors_property�sz&TextIOWrapperTest.test_errors_propertyz!Threading required for this test.cs�tj��|jtjddd��e���fdd���fdd�td�D�}tj|�j��tj	d	�WdQRXWdQRX|jtj��G��j
�}x1td�D]#}|j|jd
|�d�q�WWdQRXdS)Nr�r�r5cs%d|}�j��j|�dS)NzThread%03d
)�waitr,)r8�text)�eventr!rr�run�s

z1TextIOWrapperTest.test_threads_write.<locals>.runcs+g|]!}tjd�d|f��qS)r�rY)r�r�)r�ra)r�rrr��s	z8TextIOWrapperTest.test_threads_write.<locals>.<listcomp>r|g{�G�z�?zThread%03d
)
r�ZEventrrrmr�r�r7r�r�rArvr)r)r�Zcontentr8r)r�r!r�r�test_threads_write�sz$TextIOWrapperTest.test_threads_writecs�|j|j|j�dd��g���fdd�}|�_|jt�j�|j�j�|j�j	j�|j��|j
�d�|j
�d�dd��_dS)	Nrr�cs,�j�jjg�dd�<t��dS)N)rMrzrNr)rMr�rrr�sz>TextIOWrapperTest.test_flush_error_on_close.<locals>.bad_flushrr5cSsdS)Nrrrrrr�sz=TextIOWrapperTest.test_flush_error_on_close.<locals>.<lambda>)r�r�rTr�rxrNrOrrMrzr)r)rr)rMr�rr	�s!	
z+TextIOWrapperTest.test_flush_error_on_closec
Cs�|j|j�}dd�}dd�}||_|j|dd�}||_|jt��}|j�WdQRX|j|jj	d	�|j
|jjt�|j|jjj	d
�|j|j
�dS)NcSstd��dS)Nr�)rNrrrrr�sz>TextIOWrapperTest.test_close_error_on_close.<locals>.bad_flushcSstd��dS)NrO)rNrrrrrU�sz>TextIOWrapperTest.test_close_error_on_close.<locals>.bad_closerr�rOr�)rO)r�)r�rTrOr�r�rxrNrvrrYrVrWrrM)r)rzrrUr�rXrrrrY�s		z+TextIOWrapperTest.test_close_error_on_closecCs�|j|j�}dd�}dd�}||_|j|dd�}||_|jt��}|j�WdQRX|jdt|j	��|j
|j	jt�|jdt|j	j��|j|j
�dS)	NcSs
t�dS)N)rZrrrrr�szLTextIOWrapperTest.test_nonnormalized_close_error_on_close.<locals>.bad_flushcSs
t�dS)N)r[rrrrrU�szLTextIOWrapperTest.test_nonnormalized_close_error_on_close.<locals>.bad_closerr�r[rZ)r�rTrOr�r�rxr\r]rrrVrWrrM)r)rzrrUr�rXrrrr^�s		z9TextIOWrapperTest.test_nonnormalized_close_error_on_closecCsV|j|j|j�dd�}|j�|j�|j�|jt|j�dS)Nrr�)r�r�rTrOrxrgr�)r)r�rrrr
�s
!


z"TextIOWrapperTest.test_multi_closecCsN|j|j|j��}|j|j|j�|j|j|jd�dS)Nr)r�rWrTrxrXr4r3)r)r�rrrr`�sz!TextIOWrapperTest.test_unseekablec	CsW|j|j|j�dd�}|j|j�}|jt��||_WdQRXdS)Nrr�)r�r�rTrxr�rz)r)r�r7rrrrb�s!z*TextIOWrapperTest.test_readonly_attributescCs�|jdddg�}|j|dddd�}|j|jd�d	�|j|j�d
�|jt|�ddg�dS)
Nsabcsdefsghi
jkl
opq
rr�r&r\r�Zabcdzefghi
zjkl
zopq
)r>r�rvrAr�r$)r)r�r�rrr�
test_rawio�s
zTextIOWrapperTest.test_rawiocCs�|jdddg�}|j|dddddd	�}|jd
�|jd�|jd�|jd
j|j�d�dS)Nsabcsdefsghi
jkl
opq
rr�r&r\�
write_throughT�1z23
4�5r?s123
45)r>r�r,rvr`r&)r)r�r�rrr�test_rawio_write_through	s	


z*TextIOWrapperTest.test_rawio_write_throughcsgg��G��fdd�d|j�}|j�}d}||t|�d�}|j|dddd�}|jd�}|j|�|j��|j��|j|j	�d	�g�|j|d
�|j��|j|j	�|d�dS)Ncs:eZdZ��fdd�Z��fdd�Z�S)zBTextIOWrapperTest.test_bufio_write_through.<locals>.BufferedWritercs �jd�t�j||�S)NT)r+rFr�)r)rYr)rG�flush_calledrrr�s
zHTextIOWrapperTest.test_bufio_write_through.<locals>.BufferedWriter.flushcs �jd�t�j||�S)NT)r+rFr,)r)rYr)rG�write_calledrrr,s
zHTextIOWrapperTest.test_bufio_write_through.<locals>.BufferedWriter.write)rrrr�r,r)r�r�)rGrr�sr�rvrErr�r�Tr?r~r)
r�r�rr�r3r,rrrvr�)r)r�rrrAr~r�r)r�r�r�test_bufio_write_throughs 
"	



z*TextIOWrapperTest.test_bufio_write_throughcCs�|j|jd��}|jt|jd�|j|jd��}|jt|j�|j|jd��}|jt|j�dS)Nr�r5)r�r�rxryrAr�)r)rWrrr�test_read_nonbytes3sz$TextIOWrapperTest.test_read_nonbytescsm�fdd�}|�}�jt|jd�|�}�jt|j�|�}�jt|j�dS)NcsQtjd�}d|_z(�j�jd�dddd�}Wdd|_X|S)N�quopriTsaaaaaar&r\rF)r#r>�_is_text_encodingr�r�)r�rW)r)rr�_make_illegal_wrapper@s	
zETextIOWrapperTest.test_illegal_decoder.<locals>._make_illegal_wrapperr5)rxryrAr�)r)r�rWr)r)r�test_illegal_decoder=s
			z&TextIOWrapperTest.test_illegal_decodercKs1|jj}djd|d|�}td|�S)Na�if 1:
            import codecs
            import {iomod} as io

            # Avoid looking up codecs at shutdown
            codecs.lookup('utf-8')

            class C:
                def __init__(self):
                    self.buf = io.BytesIO()
                def __del__(self):
                    io.TextIOWrapper(self.buf, **{kwargs})
                    print("ok")
            c = C()
            �iomodrz-c)r[rr�r)r)rr��coderrr�_check_create_at_shutdownQsz+TextIOWrapperTest._check_create_at_shutdowncCsW|j�\}}}|r7|j|j|j��n|jd|j�j��dS)N�ok)r�r]�shutdown_errorr3rvrK)r)�rc�outrXrrr�(test_create_at_shutdown_without_encodingfsz:TextIOWrapperTest.test_create_at_shutdown_without_encodingcCsN|jdddd�\}}}|j|�|jd|j�j��dS)Nrzutf-8r�r"r�)r�rrvr3rK)r)r�r�rXrrr�%test_create_at_shutdown_with_encodingps
z7TextIOWrapperTest.test_create_at_shutdown_with_encodingcCs\td�}|j|d�}t|j��j�}|j|jd�|jd��dS)NsJust some random string
zutf-8��)�MemviewBytesIOr��_to_memoryviewr�r�rvrAr3)r)rrWZ	bytes_valrrr�test_read_byteslikewsz%TextIOWrapperTest.test_read_byteslikecCs�Gdd�dt�}xCtd�D]5}y|j|�dd�Wq#tk
rWYq#Xq#Wdd�|_|j|�dd�}dS)Nc@s4eZdZdd�Zdd�Zdd�ZdS)z,TextIOWrapperTest.test_issue22849.<locals>.FcSsdS)NTr)r)rrrr0�sz5TextIOWrapperTest.test_issue22849.<locals>.F.readablecSsdS)NTr)r)rrrr-�sz5TextIOWrapperTest.test_issue22849.<locals>.F.writablecSsdS)NTr)r)rrrr1�sz5TextIOWrapperTest.test_issue22849.<locals>.F.seekableN)rrrr0r-r1rrrr�F�sr�r~rzutf-8cSsdS)Nrr)rarrrr�sz3TextIOWrapperTest.test_issue22849.<locals>.<lambda>)�objectr�r�r�r4)r)r�r�rWrrr�test_issue22849�s
	z!TextIOWrapperTest.test_issue22849N)GrrrrnrorkrnrZr@rQrTr^rirrhrkrmrprrrr�r�r�rErNr�r�r�r�r�rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r��
no_tracingr�r�r�r�r	rYr^r
r`rbr�r�r�r�r�r�Zrequires_type_collectingr�r�r�r�rrrrrS!	s|	

	*/
	

!
 

rScs:eZdZdZ�fdd�Z�fdd�Z�S)r�zOA BytesIO object whose read method returns memoryviews
       rather than bytescstt�j|��S)N)r�rFr))r)�len_)rGrrr)�szMemviewBytesIO.read1cstt�j|��S)N)r�rFrA)r)r�)rGrrrA�szMemviewBytesIO.read)rrrr;r)rArr)rGrr��sr�cCsMtjd�}t|�t|�|j}|j|d|��t|�S)z6Convert bytes-object *buf* to a non-trivial memoryviewr�N)r
r�itemsizeZ	frombytesr)r7Zarr�idxrrrr��sr�c@s@eZdZeZdZdd�Zdd�Zdd�ZdS)	�CTextIOWrapperTestz,RuntimeError: could not find io module statecCs�|jd�}|j|d�}|j|�}|jt|j|dd�|jt|j�|jj|j�}|jtt	|�dS)Nsé

i�r&rH)
r�r�r�rxrgr*rArlr�r?)r)rr	rWrrrr��sz&CTextIOWrapperTest.test_initializationcCs�tjdtf��ptjtjd�}|j|�}|j|dd�}|jd�||_	t
j|�}~tj�WdQRX|j
|�|�|jtjd��}|j|j�d�WdQRXdS)Nr�r�rr�Z456defr�s456def)rr�r�r[r�rmr�r�r,rar�r�r�r�rrvrA)r)rr	rWr�r!rrrr��s
	z*CTextIOWrapperTest.test_garbage_collectioncCs�x�td�D]~}|j|j�|j��}|j|dd�}|j|j�|j��}|j|dd�}||_||_q
Wtj�dS)Ni�rr�)r�r�r>r�Zbuddyrr�)r)r�Zb1Zt1Zb2Zt2rrr�!test_rwpair_cleared_before_textio�s	
z4CTextIOWrapperTest.test_rwpair_cleared_before_textioN)rrrr[r�r�r�r�rrrrr��s

r�c@seZdZeZdZdS)�PyTextIOWrapperTestz,TypeError: 'NoneType' object is not iterableN)rrrr]r[r�rrrrr��sr�c@s@eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�IncrementalNewlineDecoderTestcsv��fdd�}|dd�|dd�|dd�|dd�|dd�|dd�|dd�|dd��jt�jd	d
d��j�|dd
�|dd�|d	d
d
d�|dd
d
d�|dd�|dd�|dd�|dd�|dd
�|dd�|dd�|dd�|dd
�|dd�|dd
�dS)NcsU�j�}�j�j||�|��j|��j�j||�|�dS)N)r)rvr3r,)r	rarr+)�decoderr)rr�
_check_decode�s
zPIncrementalNewlineDecoderTest.check_newline_decoding_utf8.<locals>._check_decodes袈u袈s�r�s�s�r?r1Ts
r\s
rvz
as

z

s
as袈
u袈
s袈
)rx�UnicodeDecodeErrorr3r%)r)r�r�r)r�r)r�check_newline_decoding_utf8�s4




















z9IncrementalNewlineDecoderTest.check_newline_decoding_utf8csig�|dk	r?tj|������fdd�}nd���fdd�}|j�jd�|d�|j�jd�|d�|j�jd
�|d�|j�jd�|d	�|j�jd�|d�|jdj��d��j�d	}�dk	r9�j��j|�}|j�j|�d	�|j�jd�dS)Ncs=x6�j|�D]%}�j�jt|g���qWdS)N)r8r+r3r)rar	)r��encoder�resultrr�_decode_bytewise	
szNIncrementalNewlineDecoderTest.check_newline_decoding.<locals>._decode_bytewisecs+x$|D]}�j�j|��qWdS)N)r+r3)rar�)r�r�rrr
s
zabc

r\z
abc�
zabc
r�rsr�zabc

abcabc
abcabc)r\r)r\r)rsr\r)r#�getincrementalencoderrv�newlinesr`r%r8r3)r)r�rrr0r)r�r�r�r�check_newline_decoding
s0






z4IncrementalNewlineDecoderTest.check_newline_decodingc	Cs�d}xK|D]C}|o(tj|��}|j|d	d
�}|j||�q
Wtjd��}|j|d	d
�}|j|�dS)N�utf-8�latin-1�utf-16�	utf-16-le�	utf-16-be�utf-32�	utf-32-le�	utf-32-be�	translateT)	Nrrrrr	r
rr)r#�getincrementaldecoder�IncrementalNewlineDecoderrr�)r)r}r�r�rrr�test_newline_decoder&
s
z2IncrementalNewlineDecoderTest.test_newline_decodercsT�fdd�}�jddd�}||��jddd�}||�dS)Ncso�j|jd��j|jd�d��j|jd��j|jd�d��j|jd�dS)Nuഀu਀)rvrr3)�dec)r)rr�_check8
s
z@IncrementalNewlineDecoderTest.test_newline_bytes.<locals>._checkr
FT)r)r)rrr)r)r�test_newline_bytes6
s

z0IncrementalNewlineDecoderTest.test_newline_bytesN)rrrr�rrrrrrrr��s*!r�c@seZdZdS)�CIncrementalNewlineDecoderTestN)rrrrrrrrC
src@seZdZdS)�PyIncrementalNewlineDecoderTestN)rrrrrrrrF
src@seZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zejeed!�d"�d#d$��Zd%d&�Zd'd(�Zd)d*�Zd+S),�
MiscIOTestcCstjtj�dS)N)rrlrm)r)rrrroN
szMiscIOTest.tearDowncCs�x�|jjD]�}t|j|d�}|j||�|dkrJq
q
d|j�ksh|dkr�|jt|t�|�q
|jd�s
|jt||j	��q
WdS)Nr�errorrXZSEEK_)
r[�__all__r+rl�lowerr�
issubclassr�r�r�)r)rPrrrr�test___all__Q
szMiscIOTest.test___all__cCs�|jtjddd�}|j|jd�|j�tjdtf��|jtjd�}WdQRX|j|jtj�|j|j	jtj�|j|j	j
jtj�|j|jd�|j|j	jd�|j|j	j
jd�|j�|jtjd�}|j|jd�|j|j	jd�|j|j	j
jd�|j|j�dd	d
�}|j|jd�|j|j
jd�|j|j|j��|j|j
j|j��|j�|j�dS)Nr�r�rr��Ur�zw+zrb+r�F)rrrmrvr�rOr��DeprecationWarningrPrzr�r/)r)r!�grrr�test_attributes\
s.


zMiscIOTest.test_attributescCs�x�ddiddiddddiddddiddddiddidd	iddddiddddidd	ddidd
iddidd
ddidd
ddiddddigD]}|jtj|�}|j�|jt|j�|jt|j�|jt|j�|jt|j	�t
|d�rZ|jt|jd�|jt|j�t
|d
�r�|jt|j
d�t
|d�r�|jt|j�t
|d�r�|jt|jtd��t
|d�r
|jt|jtd��|jt|j�|jt|j�|jt|jd�|jt|jd�|jt|j�|jt|j�|jt|jd|dkr�dnd�|jt|jg�|jtt|�q�WdS)Nr�r�r�r�r5rErrr�zw+zw+br�r)ir�r9rr	r?r�)rrrmrOrxrgr�r/r��__iter__rr�rAr)r�r9rwrr�r�r3r4r:r,r�r�)r)rr!rrr�test_io_after_closex
sV						
zMiscIOTest.test_io_after_closecCs|Gdd�dt�}|d�}|jd|�}||_||_tj|�}~~tj�|j|�|�dS)Nc@seZdZdS)z*MiscIOTest.test_blockingioerror.<locals>.CN)rrrrrrr�C�
sr"r�r5)	rrir	r�r�r�rr�r�)r)r"r�r	r�rrr�test_blockingioerror�
s		
zMiscIOTest.test_blockingioerrorcCs\|j|jtj�|j|jtj�|j|jtj�|j|jtj�dS)N)rVr�r��ABCMetar�r�r�)r)rrr�	test_abcs�
szMiscIOTest.test_abcscCsK|jtjddd��S}|j||j�|j||j�|j||j�|j||j�WdQRX|jtjd��S}|j||j�|j||j�|j||j�|j||j�WdQRX|jtjd��S}|j||j�|j||j�|j||j�|j||j�WdQRXdS)Nr�r�rr�)	rrrmrVr�r�ZassertNotIsInstancer�r�)r)Z	abcmoduler!rrr�_check_abc_inheritance�
sz!MiscIOTest._check_abc_inheritancecCs|j|�dS)N)r&)r)rrr�test_abc_inheritance�
szMiscIOTest.test_abc_inheritancecCs|jt�dS)N)r&r[)r)rrr�test_abc_inheritance_official�
sz(MiscIOTest.test_abc_inheritance_officialcOsht||�}t|�}|jt��}d}tj�WdQRX|j|t|jj	d��dS)Nr)
rr?ZassertWarnsr�rr�r]rZwarningrY)r)rYrr!rrrrr�_check_warn_on_dealloc�
sz!MiscIOTest._check_warn_on_dealloccCsC|jtjddd�|jtjd�|jtjd�dS)Nr�r�rr�)r)rrm)r)rrr�test_warn_on_dealloc�
szMiscIOTest.test_warn_on_deallocc
s�g��fdd�}|j|�tj�\}}�||f7�|j|||�tj�\}}�||f7�tj|��t||dd|�WdQRXdS)Ncscx\�D]T}ytj|�Wqtk
rZ}z|jtjkrH�WYdd}~XqXqWdS)N)r�rOrN�errno�EBADF)rr�)�fdsrr�cleanup_fds�
s
z9MiscIOTest._check_warn_on_dealloc_fd.<locals>.cleanup_fdsr�F)r�r�r�r)rr$r)r)rYrr.rr�r)r-r�_check_warn_on_dealloc_fd�
s
z$MiscIOTest._check_warn_on_dealloc_fdcCs1|jddd�|jd�|jd�dS)Nr�r�rr)r/)r)rrr�test_warn_on_dealloc_fd�
s
z"MiscIOTest.test_warn_on_dealloc_fdcCs�x�ddiddiddddiddiddiddddiddidd	idd	ddig	D]\}xSttjd
�D]>}|jtj|�� }|jttj||�WdQRXq�WqjWdS)Nr�r�r�r�rrr�zw+zw+br5)	r��pickleZHIGHEST_PROTOCOLrrrmrxry�dumps)r)rZprotocolr!rrr�
test_pickling�
s						zMiscIOTest.test_picklingcCs|jd�dS)Nrjii@)�_test_nonblock_pipe_write)r)rrr�test_nonblock_pipe_write_bigbufsz*MiscIOTest.test_nonblock_pipe_write_bigbufcCs|jd�dS)Ni)r4)r)rrr�!test_nonblock_pipe_write_smallbufsz,MiscIOTest.test_nonblock_pipe_write_smallbuf�set_blockingz(os.set_blocking() required for this testcCs�g}g}tj�\}}tj|d�tj|d�|j|ddddd|�}|j|ddddd|�}|��|��xdD]}yPd}	xCt|	dd
g�|}
|j|
�|j|
�|	d7}	q�WWq�|jk
r�}z�|j|j	dt
j�|j|j	d|j�|dd|j�|d<|j|j
��d}
|j|
�|j|
�WYdd}~Xq�Xq�Wx�y|j�PWq�|jk
r2}z_|j|j	dt
j�|j|j	d|j�|j|jd�|j|j
��WYdd}~Xq�Xq�W|t|j
d�7}WdQRXWdQRXdj|�dj|�}}|j||�|j|j�|j|j�dS)NFr�r�r�Tr�r��'�I�rr��ar5rEsBLOCKEDr?)r8r9r:rere)r�r�r7rrr+r,rirvrYr+ZEAGAINr�rAr��iterr`rrM)r)r�ZsentZreceivedrr�ZrfZwfr�r�r5r�rrrr4sL!!



$
*$z$MiscIOTest._test_nonblock_pipe_writecCs=|jtjd��WdQRX|jt|jtjd�dS)Nr�ra)rrrmrx�FileExistsError)r)rrr�test_create_failEszMiscIOTest.test_create_failcCse|jtjd��}|jd�WdQRX|jtjd��}|jd|j��WdQRXdS)NZxbsspamr�)rrrmr,rvrA)r)r!rrr�test_create_writesKszMiscIOTest.test_create_writescCs |jt|jtjd�dS)Nzrwax+)rxrgrrrm)r)rrr�test_open_allargsRszMiscIOTest.test_open_allargsN)rrrrorrr!r#r%r&r'r(r)r*r/r0r3r5r6r�r�rr�r4r>r?r@rrrrrL
s*.
3rc@sXeZdZeZdd�Zejed�dd��Zdd�Z	dd	�Z
d
S)�CMiscIOTestcCsKGdd�d|jj�}|�}td�}|jt|j|�dS)Nc@seZdZddd�ZdS)z<CMiscIOTest.test_readinto_buffer_overflow.<locals>.BadReaderr5cSsddS)Nr}r~rpi@Br)r)r8rrrrA]szACMiscIOTest.test_readinto_buffer_overflow.<locals>.BadReader.readNre)rrrrArrrr�	BadReader\srBrE)r[r�rwrxrgr9)r)rBrAr	rrr�test_readinto_buffer_overflowZs	z)CMiscIOTest.test_readinto_buffer_overflowz!Threading required for this test.cCs~djt��}td|�\}}|jj�}|jdkrd|jdjt��|�n|j|jd��dS)Na�if 1:
            import sys
            import time
            import threading
            from test.support import SuppressCrashReport

            file = sys.{stream_name}

            def run():
                while True:
                    file.write('.')
                    file.flush()

            crash = SuppressCrashReport()
            crash.__enter__()
            # don't call __exit__(): the crash occurs at Python shutdown

            thread = threading.Thread(target=run)
            thread.daemon = True
            thread.start()

            time.sleep(0.5)
            file.write('!')
            file.flush()
            z-crz�Fatal Python error: could not acquire lock for <_io.BufferedWriter name='<{stream_name}>'> at interpreter shutdown, possibly due to daemon threadsz.!)	�
format_map�localsrrXr3r�r]rrK)r)Zstream_namer�rTr�rXrrr�&check_daemon_threads_shutdown_deadlockcs	
z2CMiscIOTest.check_daemon_threads_shutdown_deadlockcCs|jd�dS)N�stdout)rF)r)rrr�,test_daemon_threads_shutdown_stdout_deadlock�sz8CMiscIOTest.test_daemon_threads_shutdown_stdout_deadlockcCs|jd�dS)NrI)rF)r)rrr�,test_daemon_threads_shutdown_stderr_deadlock�sz8CMiscIOTest.test_daemon_threads_shutdown_stderr_deadlockN)rrrr[rCr�r�r�rFrHrIrrrrrAWs
	)rAc@seZdZeZdS)�PyMiscIOTestN)rrrr]r[rrrrrJ�srJ�ntz%POSIX signals required for this test.c@seZdZdd�Zdd�Zdd�Zejed�dd	��Z	d
d�Z
dd
�Zej
d�dd��Zejdd��Zdd�Zdd�Zdd�Zdd�Zdd�Zejed�dd��Zdd �Zd!d"�Zd#S)$�SignalsTestcCstjtj|j�|_dS)N)�signal�SIGALRM�alarm_interrupt�oldalrm)r)rrrrn�szSignalsTest.setUpcCstjtj|j�dS)N)rMrNrP)r)rrrro�szSignalsTest.tearDowncCsdddS)Nr5rr)r)�sig�framerrrrO�szSignalsTest.alarm_interruptz!Threading required for this test.c
s�g���fdd�}tjd|�}d|_tj�\�}d|d<|tjt|�d}z�|jj	||�}|j
�tjd�z|j
t|j|�Wdtjd	�|j�X�jtj�d��|j�|d	d�|dd
�g�Wdtj|�tj��y|j�Wn:tk
r|}	z|	jtjkrj�WYdd}	~	XnXXdS)z�Check that a partial write, when it gets interrupted, properly
        invokes the signal handler, and bubbles up the exception raised
        in the latter.csKttd�r(tjtjtjg�tj�d�}�j|�dS)N�pthread_sigmaskr5)rrMrS�	SIG_BLOCKrNr�rAr+)ra)r�read_resultsrrr
�sz2SignalsTest.check_interrupted_write.<locals>._readr�TFr�r5NrrE)r�r��daemonr�r�r�
PIPE_MAX_SIZErr[rr�rM�alarmrxr�r,r`r+rArvrOrNr+r,)
r)�itemr�
fdopen_kwargsr
rWr��
large_data�wior�r)rrUr�check_interrupted_write�s0	



.

z#SignalsTest.check_interrupted_writecCs |jdddddd�dS)Nsxyr�r�r�r)r])r)rrr�!test_interrupted_write_unbuffered�sz-SignalsTest.test_interrupted_write_unbufferedcCs|jdddd�dS)Nsxyr�r�)r])r)rrr�test_interrupted_write_buffered�sz+SignalsTest.test_interrupted_write_bufferedr�cCs |jdddddd�dS)N�xysxyr�r�rr�)r])r)rrr�test_interrupted_write_text�sz'SignalsTest.test_interrupted_write_textc	s*��fdd�}tjtj|�tj�\}}|jj||��z�tjd�|jtt	f��V}xLx+t
d�D]}�j���j�q�Wtj
|t��d�qzWWdQRX|j}t|t	�r
|jt|�jd�t|��Wd�j�tj|�XdS)Ncs�j��dddS)Nr5r)r,)rY)rr\rr�on_alarm�s
z3SignalsTest.check_reentrant_write.<locals>.on_alarmr5r�zreentrant call)rMrNr�r�r[rrXrxr�rSr�r,r�rArrr�rrr�rO)	r)rrZrbrr�rr�r�r)rr\r�check_reentrant_write�s"

%	)
z!SignalsTest.check_reentrant_writecCs|jddd�dS)Nsxyr�r�)rc)r)rrr�test_reentrant_write_buffered�sz)SignalsTest.test_reentrant_write_bufferedcCs|jddddd�dS)Nr`r�r�rr�)rc)r)rrr�test_reentrant_write_text�sz%SignalsTest.test_reentrant_write_textcs�tj�\}�d|d<�fdd�}tjtj|�zU|jj||�}tj�d�tjd�|j||j	d��d�Wd	|j
�tj
��tj
|�Xd	S)
z�Check that a buffered read, when it gets interrupted (either
        returning a partial result or EINTR), properly invokes the signal
        handler and retries if the latter returned successfully.Fr�cstj�d�dS)Nsbar)r�r,)rQrR)r�rr�
alarm_handlersz?SignalsTest.check_interrupted_read_retry.<locals>.alarm_handlersfoor5rpZfoobarN)r�r�rMrNr[rr,rXrvrArO)r)r3rZrrfZrior)r�r�check_interrupted_read_retry�s

#

z(SignalsTest.check_interrupted_read_retrycCs|jdd�dd�dS)NcSs
|jd�S)NrA)r3)rarrrrszBSignalsTest.test_interrupted_read_retry_buffered.<locals>.<lambda>r�r�)rg)r)rrr�$test_interrupted_read_retry_bufferedsz0SignalsTest.test_interrupted_read_retry_bufferedcCs|jdd�dd�dS)NcSs|S)Nr)rarrrrsz>SignalsTest.test_interrupted_read_retry_text.<locals>.<lambda>r�r)rg)r)rrr� test_interrupted_read_retry_textsz,SignalsTest.test_interrupted_read_retry_textcs�tjd��tj}tj�\�}d|d<g�d�d������fdd�}tjd|��d�_�fd	d
�}�fdd��||}tjtj	|�z�|j
j||�}tjd
�|j
|�}	|j||	�|j�d��j�|j��|j|tdd��D���Wdd�tj|�tj��y|j�Wn:tk
r�}
z|
jtjkr��WYdd}
~
XnXXdS)z�Check that a buffered write, when it gets interrupted (either
        returning a partial result or EINTR), properly invokes the signal
        handler and retries if the latter returned successfully.�selectFr�Ncs�y\xU�sZxH��j�gggd�dkrVtj�d�}�j|�qWqWWn+tk
r�}z|�WYdd}~XnXdS)Ng�?ri)rjr�rAr+�
BaseException)rar�)rrrUrj�write_finishedrrr
0s	(z8SignalsTest.check_interrupted_write_retry.<locals>._readr�Tcs$tjtj��tjd�dS)Nr5)rMrNrX)rQrR)�alarm2rr�alarm1;sz9SignalsTest.check_interrupted_write_retry.<locals>.alarm1cs�j�dS)N)r�)rQrR)rWrrrm>sz9SignalsTest.check_interrupted_write_retry.<locals>.alarm2r5css|]}t|�VqdS)N)r)r�rarrr�	<genexpr>Ssz<SignalsTest.check_interrupted_write_retry.<locals>.<genexpr>)r�
import_modulerWr�r�r�r�rVrMrNr[rrXr,rvr�r`r��sumrOrNr+r,)r)rYrZr�r�r
rnr[r\r�r�r)rmrrrUrjrWrlr�check_interrupted_write_retrys@	
		




'

z)SignalsTest.check_interrupted_write_retrycCs|jddd�dS)Nr}r�r�)rr)r)rrr�%test_interrupted_write_retry_bufferedasz1SignalsTest.test_interrupted_write_retry_bufferedcCs|jddddd�dS)Nrar�r�rrA)rr)r)rrr�!test_interrupted_write_retry_textdsz-SignalsTest.test_interrupted_write_retry_textN)rrrrnrorOr�r�r�r]r^r_rZrequires_freebsd_versionrar�rcrdrergrhrirrrsrtrrrrrL�s /DrLc@seZdZeZdS)�CSignalsTestN)rrrr[rrrrruhsruc@s"eZdZeZdZdZdS)�
PySignalsTestN)rrrr]r[rdrerrrrrvksrvc
s�tttttttttt	t
ttt
ttttttf}tttttttf}tjdg}dd�|D�}dd�|D�}t��|j�fdd�|D��|j�fdd�|D��tj |d<x�|D]�}|j!j"d	�r8xl|j#�D]\}}t$|||�qWq�|j!j"d
�r�x*|j#�D]\}}t$|||�qWWq�Wt%j&dd�|D��}	|	S)
NrcSs"i|]}tt|�|�qSr)r+r[)r�rPrrr�
<dictcomp>�s	zload_tests.<locals>.<dictcomp>cSs"i|]}tt|�|�qSr)r+r])r�rPrrrrw�s	c3s)|]}|j�d|jfVqdS)r"N)r)r�ra)�globsrrro�szload_tests.<locals>.<genexpr>c3s)|]}|j�d|jfVqdS)�PyN)r)r�ra)rxrrro�srr"rycSsg|]}tj|��qSr)r�Z	makeSuite)r�r�rrrr��s	zload_tests.<locals>.<listcomp>)'r/r1r2r�r�r�r�r�r�rr rDrrr�r�rArJrurvr>rDrRrLr^rWr#r[r�globalsrgr]�OpenWrapperrr�r��setattrr�Z	TestSuite)
rYr�ZmocksZall_membersZc_io_nsZpy_io_nsr�rPrZsuiter)rxr�
load_teststs8		  

r}�__main__)gr;r�r
r+rdr�r1r�rMr�r�r��warningsr��collectionsrr�	itertoolsrrr�rZtest.support.script_helperrrr#r[Z_pyior]r��ImportErrorrrZ	Structurerr"r#r�r<r=r>rBrCrDrJrKrLrPrQrRr�rUrVrWrZr\r^rhrjZTestCaserkr/r1rhr2r;rcrir�r�r�r�r�r�r�r�r�rr r$r!�registerrBrDrSr�r�r�r�r�rrrrArJZskipIfrPrLrurvr}r�mainrrrr�<module>s�

8

,��S��0�-��W+���t
	.j�<%�	$