HEX
Server: Apache
System: Linux scp1.abinfocom.com 5.4.0-216-generic #236-Ubuntu SMP Fri Apr 11 19:53:21 UTC 2025 x86_64
User: confeduphaar (1010)
PHP: 8.1.33
Disabled: exec,passthru,shell_exec,system
$ pwd: /usr/lib/python3/dist-packages/twisted/internet/test/__pycache__/
Upload Files
File: //usr/lib/python3/dist-packages/twisted/internet/test/__pycache__/test_unix.cpython-38.pyc
U


W[���@s�dZddlmZmZddlmZddlmZmZmZm	Z	m
Z
ddlmZm
Z
ddlmZmZmZmZmZddlmZddlmZdd	lmZzdd
lmZWnek
r�dZYnXddlmZdd
lmZmZddl m!Z!ddl"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(ddl)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1ddl2m3Z3ddl2m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddl<m=Z=ddl>m?Z?m@Z@mAZAmBZBddl8mCZCddl8mDZDddl8mEZEddl8mFZFddlGmHZHmIZImJZJddlKmLZLdd lMmNZNmOZOmPZPdd!lQmRZRdd"lSmTZTdd#lUmVZVeTd$�dk	�r.dZWnd%ZWGd&d'�d'eX�ZYd(d)�ZZGd*d+�d+e9�Z[Gd,d-�d-eC�Z\ee.�Gd.d/�d/eC��Z]Gd0d1�d1eYe;eD�Z^Gd2d3�d3eYe;�Z_Gd4d5�d5eX�Z`Gd6d7�d7eX�ZaGd8d9�d9eX�ZbGd:d;�d;eaebe;e=e?�ZcGd<d=�d=e`ebe;e=e?�ZdGd>d?�d?e@e;�Zeef��ge^�h��ef��ge_�h��ef��gec�h��ef��ged�h��ef��gee�h��Gd@dA�dAe;eE�Zief��gei�h��dS)Bz/
Tests for implementations of L{IReactorUNIX}.
�)�division�absolute_import)�S_IMODE)�stat�close�urandom�unlink�fstat)�mktemp�mkstemp)�AF_INET�SOCK_STREAM�
SOL_SOCKET�socket�error)�pformat)�md5)�pack)�AF_UNIXN)�implementer)�
interfaces�base)�UNIXAddress)�Deferred�fail�
gatherResults)�UNIXServerEndpoint�UNIXClientEndpoint)�ConnectionClosed�FileDescriptorOverrun�CannotListenError)�IFileDescriptorReceiver�IReactorUNIX�IReactorSocket�
IReactorFDSet)�DatagramProtocol)�
ServerFactory�
ClientFactory)�LoopingCall)�EndpointCreator)�ReactorBuilder)�ObjectModelIntegrationMixin)�StreamTransportTestsMixin�WriteSequenceTestsMixin�MyClientFactory�MyServerFactory)�ConnectableProtocol)�ConnectionTestsMixin)�StreamClientTestsMixin)�runProtocolsWithReactor)�nativeString�_PY3�	iteritems)�Failure)�addObserver�removeObserver�err)�platform)�
requireModule)�_coerceToFilesystemEncodingztwisted.python.sendmsgz>sendmsg extension unavailable, extended UNIX features disabledc@seZdZdZdd�ZdS)�UNIXFamilyMixinzK
    Test-helper defining mixin for things related to AF_UNIX sockets.
    cCsBd}|��}t||�|||d�}|��|�tt|�j�|�dS)z}
        Assert that the mode of the created unix socket is set to the mode
        specified to the reactor method.
        i�)�modeN)�buildReactor�getattrZ
stopListening�assertEqualrr�st_mode)�selfZ
methodName�path�factoryr?�reactorZunixPort�rH�A/usr/lib/python3/dist-packages/twisted/internet/test/test_unix.py�	_modeTest@s
zUNIXFamilyMixin._modeTestN)�__name__�
__module__�__qualname__�__doc__rJrHrHrHrIr><sr>cCsttd����S)zI
    Return a new, unique abstract namespace path to be listened on.
    �d)rrZ	hexdigest)ZcaserHrHrI�
_abstractPathLsrPc@s(eZdZdZejfZdd�Zdd�ZdS)�UNIXCreatorz(
    Create UNIX socket end points.
    cCstddd�}t||�S)z3
        Construct a UNIX server endpoint.
        �.sock�.��suffix�dir)r
r)rDrGrErHrHrI�serverZszUNIXCreator.servercCst||j�S)z3
        Construct a UNIX client endpoint.
        )r�name)rDrGZ
serverAddressrHrHrI�clientcszUNIXCreator.clientN)	rKrLrMrNrr"�requiredInterfacesrWrYrHrHrHrIrQTs	rQc@s,eZdZdZdZdd�Zdd�Zdd�ZdS)	�SendFileDescriptorz�
    L{SendFileDescriptorAndBytes} sends a file descriptor and optionally some
    normal bytes and then closes its connection.

    @ivar reason: The reason the connection was lost, after C{connectionLost}
        is called.
    NcCs||_||_dS)z�
        @param fd: A C{int} giving a file descriptor to send over the
            connection.

        @param data: A C{str} giving data to send over the connection, or
            L{None} if no data is to be sent.
        N)�fd�data)rDr\r]rHrHrI�__init__uszSendFileDescriptor.__init__cCs0|j�|j�|jr"|j�|j�|j��dS)zn
        Send C{self.fd} and, if it is not L{None}, C{self.data}.  Then close the
        connection.
        N)�	transport�sendFileDescriptorr\r]�write�loseConnection�rDrHrHrI�connectionMade�sz!SendFileDescriptor.connectionMadecCst�||�||_dS�N)r0�connectionLost�reason�rDrgrHrHrIrf�sz!SendFileDescriptor.connectionLost)rKrLrMrNrgr^rdrfrHrHrHrIr[ks
r[c@s8eZdZdZdZdZdd�Zdd�Zdd�Zd	d
�Z	dS)�ReceiveFileDescriptora}
    L{ReceiveFileDescriptor} provides an API for waiting for file descriptors to
    be received.

    @ivar reason: The reason the connection was lost, after C{connectionLost}
        is called.

    @ivar waiting: A L{Deferred} which fires with a file descriptor once one is
        received, or with a failure if the connection is lost with no descriptor
        arriving.
    NcCs&|jdkrt�|_|jSt|j�SdS)z�
        Return a L{Deferred} which will fire with the next file descriptor
        received, or with a failure if the connection is or has already been
        lost.
        N)rgr�waitingrrcrHrHrI�waitForDescriptor�s
z'ReceiveFileDescriptor.waitForDescriptorcCs|j�|�d|_dS)z�
        Fire the waiting Deferred, initialized by C{waitForDescriptor}, with the
        file descriptor just received.
        N)rj�callback)rD�
descriptorrHrHrI�fileDescriptorReceived�sz,ReceiveFileDescriptor.fileDescriptorReceivedcCs.|jdk	r*|j�ttd|f���d|_dS)a_
        Fail the waiting Deferred, if it has not already been fired by
        C{fileDescriptorReceived}.  The bytes sent along with a file descriptor
        are guaranteed to be delivered to the protocol's C{dataReceived} method
        only after the file descriptor has been delivered to the protocol's
        C{fileDescriptorReceived}.
        Nz&Received bytes (%r) before descriptor.)rj�errbackr7�	Exception�rDr]rHrHrI�dataReceived�s


�z"ReceiveFileDescriptor.dataReceivedcCs2t�||�|jdk	r(|j�|�d|_||_dS)zj
        Fail the waiting Deferred, initialized by C{waitForDescriptor}, if there
        is one.
        N)r0rfrjrorgrhrHrHrIrf�s

z$ReceiveFileDescriptor.connectionLost)
rKrLrMrNrgrjrkrnrrrfrHrHrHrIri�s
	ric@s,eZdZdZefZe�Zdd�Zdd�Z	e
��s6de	_dd�Z
d	d
�Ze
��sTde_dd�Zd
d�Zedk	rree_dd�Zedk	r�ee_dd�Zedk	r�ee_dd�Zdd�Zedk	r�ee_dd�Ze
��r�de_nedk	r�ee_dd�Zedk	r�ee_dd�Zedk	�ree_dd �Zedk	�r(ee_dS)!�UNIXTestsBuilderz=
    Builder defining tests relating to L{IReactorUNIX}.
    cCs|�d|��t��dS)zs
        The UNIX socket created by L{IReactorUNIX.listenUNIX} is created with
        the mode specified.
        �
listenUNIXN)rJr
r&rcrHrHrI�	test_mode�szUNIXTestsBuilder.test_modecCs>t|�}|��}|�d|t��}|�|��td|��dS)z�
        On Linux, a UNIX socket path may begin with C{''} to indicate a socket
        in the abstract namespace.  L{IReactorUNIX.listenUNIX} accepts such a
        path.
        �N)rPr@rtr&rB�getHostr�rDrErG�portrHrHrI�#test_listenOnLinuxAbstractNamespace�sz4UNIXTestsBuilder.test_listenOnLinuxAbstractNamespace�8Abstract namespace UNIX sockets only supported on Linux.c	CsHdd�}|�tjd|�|��}|�t��|�dt��W5QRXdS)z�
        L{IReactorUNIX.listenUNIX} raises L{CannotListenError} if the
        underlying port's createInternetSocket raises a socket error.
        cSstd��dS)Nz FakeBasePort forced socket.error)rrcrHrHrI�raiseSocketError�sz=UNIXTestsBuilder.test_listenFailure.<locals>.raiseSocketErrorZcreateInternetSocketznot-usedN)�patchrZBasePortr@ZassertRaisesr rtr&)rDr|rGrHrHrI�test_listenFailure�s
z#UNIXTestsBuilder.test_listenFailurecCs>t|�}|��}|�d|t��}|�|��td|��dS)zc
        L{IReactorUNIX.connectUNIX} also accepts a Linux abstract namespace
        path.
        rvN)rPr@�connectUNIXr'rBZgetDestinationr)rDrErGZ	connectorrHrHrI�$test_connectToLinuxAbstractNamespacesz5UNIXTestsBuilder.test_connectToLinuxAbstractNamespacecCs`Gdd�dt�}|�}|�}t||||j�|�|jd|jd�|�|jd|jd�dS)z�
        A client's transport's C{getHost} and C{getPeer} return L{UNIXAddress}
        instances which have the filesystem path of the host and peer ends of
        the connection.
        c@seZdZdd�ZdS)z4UNIXTestsBuilder.test_addresses.<locals>.SaveAddresscSs"t|��|��d�|_|��dS)N)�host�peer)�dictrw�getPeer�	addressesrb)rDr_rHrHrI�makeConnections
�zCUNIXTestsBuilder.test_addresses.<locals>.SaveAddress.makeConnectionN)rKrLrMr�rHrHrHrI�SaveAddresssr�r�r�N)r0r3�	endpointsrBr�)rDr�rWrYrHrHrI�test_addressesszUNIXTestsBuilder.test_addressescs�ddlm�t����d�t���d��t�}|��}���fdd�}|�|�|�t	d�|�
�fdd	��t��|�j�d
S)z�
        L{IUNIXTransport.sendFileDescriptor} accepts an integer file descriptor
        and sends a copy of it to the process reading from the connection.
        r)�fromfd)�r�junkcs@�|tt�}t|������|��������|���dSre)rr
rrBZgetsocknameZassertNotEqual�fileno)rmZreceived)r��srDrHrI�checkDescriptor3szAUNIXTestsBuilder.test_sendFileDescriptor.<locals>.checkDescriptorz-Sending file descriptor encountered a problemcs
�j��Sre�r_rb�Zignored�rWrHrI�<lambda>B�z:UNIXTestsBuilder.test_sendFileDescriptor.<locals>.<lambda>N)
rr��bindr[r�rirk�addCallback�
addErrbackr:�addBothr3r�)rDrY�dr�rH)r�r�rDrWrI�test_sendFileDescriptor&s

z(UNIXTestsBuilder.test_sendFileDescriptorNcCsTGdd�dt�}Gdd�dt�}|�}|�}||_t||||j�|�|jd�dS)z�
        If a L{IUNIXTransport.sendFileDescriptor} call fills up the send buffer,
        any registered producer is paused.
        c@seZdZdd�ZdS)zSUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.DoesNotReadcSs|j��dSre)r_�pauseProducingrcrHrHrIrdOszbUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.DoesNotRead.connectionMadeN�rKrLrMrdrHrHrHrI�DoesNotReadNsr�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
z`UNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptorsFcsPt��_�j��d��fdd�}t|��_�jj�j_�j�d��t	d�dS)NTcs"�j��j����j�d�dS)N�x)r_r`rr�rarHrcrHrI�senderXszUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.connectionMade.<locals>.senderrzSend loop failure)
rr_ZregisterProducerr(�taskrGZclock�startr�r:)rDr�rHrcrIrdUs
zoUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.connectionMadecSs|��dSre��_disconnectrcrHrHrI�
stopProducing_sznUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.stopProducingcSs|��dSrer�rcrHrHrI�resumeProducingbszpUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.resumeProducingcSsd|_|j��|��dS)NT)�pausedr_ZunregisterProducerr�rcrHrHrIr�es
zoUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors.pauseProducingcSs$|j��|j��|jj��dSre)r��stopr_ZabortConnection�otherrcrHrHrIr�js

zlUNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducing.<locals>.SendsManyFileDescriptors._disconnectN)	rKrLrMr�rdr�r�r�r�rHrHrHrI�SendsManyFileDescriptorsRs
r�z*sendFileDescriptor producer was not pausedN)r0r�r3r��
assertTruer�)rDr�r�rWrYrHrHrI�-test_sendFileDescriptorTriggersPauseProducingIs�z>UNIXTestsBuilder.test_sendFileDescriptorTriggersPauseProducingcs�t�}t|��d��t�}g}|��}|�|j�|��fdd��t|�||j�|�	|dt
�|d�t�|�	�j
jt�dS)ag
        If L{IUNIXTransport.sendFileDescriptor} is used to queue a greater
        number of file descriptors than the number of bytes sent using
        L{ITransport.write}, the connection is closed and the protocol connected
        to the transport has its C{connectionLost} method called with a failure
        wrapping L{FileDescriptorOverrun}.
        Ncs
�j��Srer�r�r�rHrIr��r�z=UNIXTestsBuilder.test_fileDescriptorOverrun.<locals>.<lambda>r)rr[r�rirkr��appendr3r��assertIsInstancer7Ztraprrg�valuer)rD�cargorY�resultr�rHr�rI�test_fileDescriptorOverrunzsz+UNIXTestsBuilder.test_fileDescriptorOverruncs>ddlm}ddlm}ddlm}dd��tt�G�fdd�dt��}Gd	d
�d
|�}|t	t
�\}}|�|j�|�|j�|�}	|||	�}
t
�\}}t
�\}
}|�t|�|�t|�d}||
g}||�\}}||||�|
��|�t|	j�|�|�t|��t|	j���|	j�r:�fdd
�|D�}|�||	j�dS)a�
        Drive _SendmsgMixin via sendmsg socket calls to check that
        L{IFileDescriptorReceiver.fileDescriptorReceived} is called once
        for each file descriptor received in the ancillary messages.

        @param ancillaryPacker: A callable that will be given a list of
            two file descriptors and should return a two-tuple where:
            The first item is an iterable of zero or more (cmsg_level,
            cmsg_type, cmsg_data) tuples in the same order as the given
            list for actual sending via sendmsg; the second item is an
            integer indicating the expected number of FDs to be received.
        r��
socketpair)�
_SendmsgMixin��sendmsgcSst|�}|j|jfSre)r	�st_dev�st_ino)r\ZfsrHrHrI�deviceInodeTuple�szTUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.deviceInodeTuplecs eZdZdd�Z�fdd�ZdS)zPUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeProtocolcSsg|_g|_dSre)�fds�deviceInodesReceivedrcrHrHrIr^�szYUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeProtocol.__init__cs(|j�|�|j��|��t|�dSre)r�r�r�r)rDr\�r�rHrIrn�szgUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeProtocol.fileDescriptorReceivedN)rKrLrMr^rnrHr�rHrI�FakeProtocol�sr�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
zPUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver�cSs||_||_dSre)rZprotocol)rD�skt�protorHrHrIr^�szYUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver.__init__cSsdSrerHrqrHrHrI�
_dataReceived�sz^UNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver._dataReceivedcSsdSrerHrcrHrHrIrw�szXUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver.getHostcSsdSrerHrcrHrHrIr��szXUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver.getPeercSsdSrerH)rD�orHrHrI�
_getLogPrefix�sz^UNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.FakeReceiver._getLogPrefixN)	rKrLrMZ
bufferSizer^r�rwr�r�rHrHrHrI�FakeReceiver�sr�ssome data needs to be sentcsg|]}�|��qSrHrH��.0r\r�rHrI�
<listcomp>�szNUNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDriver.<locals>.<listcomp>N)rr�Ztwisted.internet.unixr��twisted.python.sendmsgr�rr!r0rr
�
addCleanuprrrZdoReadrB�lenr�ZassertFalse�set�intersectionr�)rD�ancillaryPackerr�r�r�r�r�Z
sendSocketZ
recvSocketr�ZreceiverZ	fileOneFDZfileOneNameZ	fileTwoFDZfileTwoNameZ
dataToSend�	fdsToSend�	ancillary�
expectedCountZdeviceInodesSentrHr�rI�)_sendmsgMixinFileDescriptorReceivedDriver�s4	


z:UNIXTestsBuilder._sendmsgMixinFileDescriptorReceivedDrivercs&ddlm��fdd�}|�|�dS)z�
        _SendmsgMixin handles multiple file descriptors per recvmsg, calling
        L{IFileDescriptorReceiver.fileDescriptorReceived} once per received
        file descriptor. Scenario: single CMSG with two FDs.
        r��
SCM_RIGHTScs t�td|��fg}d}||fS)N�ii�)r��rr�r�r�r�r�rHrIr��sz[UNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgOneCMSG.<locals>.ancillaryPackerN�r�r�r��rDr�rHr�rI�1test_multiFileDescriptorReceivedPerRecvmsgOneCMSG�szBUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgOneCMSGcs&ddlm��fdd�}|�|�dS)z�
        _SendmsgMixin handles multiple file descriptors per recvmsg, calling
        L{IFileDescriptorReceiver.fileDescriptorReceived} once per received
        file descriptor. Scenario: two CMSGs with one FD each.
        rr�cs�fdd�|D�}d}||fS)Ncsg|]}t�td|�f�qS)�ir�r�r�rHrIr�s�zpUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGs.<locals>.ancillaryPacker.<locals>.<listcomp>r�rHr�r�rHrIr�s

�z\UNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGs.<locals>.ancillaryPackerNr�r�rHr�rI�2test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGsszCUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgTwoCMSGsz=Multi control message ancillary sendmsg not supported on Mac.cs~ddlm�dd�}�fdd�}g}t|j�|�t|j�|��d|�|�|�d�t�fd	d
�|D��}|�	|d�dS)
z�
        _SendmsgMixin handles multiple file descriptors per recvmsg, calling
        L{IFileDescriptorReceiver.fileDescriptorReceived} once per received
        file descriptor. Scenario: unsupported CMSGs.
        rr�cSsg}d}||fS)NrrHr�rHrHrIr�)sz[UNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSG.<locals>.ancillaryPackercsd}dg}d}��|||�S)Ns	some data)NNr�r)ZRecievedMessage)r��args�kwargsr]r��flagsr�rHrI�fakeRecvmsgUnsupportedAncillary.szkUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSG.<locals>.fakeRecvmsgUnsupportedAncillaryZrecvmsgz#received unsupported ancillary datac3s|]}�|dkVqdS)�formatNrH)r��e)�expectedMessagerHrI�	<genexpr>=szUUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSG.<locals>.<genexpr>z+Expected message not found in logged eventsN)
Ztwisted.pythonr�r8r�r�r9r}r��anyr�)rDr�r��events�foundrH)r�r�rI�1test_multiFileDescriptorReceivedPerRecvmsgBadCMSGs

zBUNIXTestsBuilder.test_multiFileDescriptorReceivedPerRecvmsgBadCMSGcCs�ddlm}|�\}}g}t|j�|�t|j�Gdd�dt�}||��d�}t�}t	||||j
�|��|�d�|�
d|�d��d	}d
}	t|j|j|	|d�}
|D],}t|
�D]\}}
|
|�|�kr�q�q�q�q�|�d|
t|�f�d
S)z�
        If associated with a protocol which does not provide
        L{IFileDescriptorReceiver}, file descriptors received by the
        L{IUNIXTransport} implementation are closed and a warning is emitted.
        rr�c@seZdZdd�ZdS)zRUNIXTestsBuilder.test_avoidLeakingFileDescriptors.<locals>.RecordEndpointAddressescSs&|j��|_|j��|_t�|�dSre)r_rw�hostAddressr��peerAddressr[rdrcrHrHrIrdVszaUNIXTestsBuilder.test_avoidLeakingFileDescriptors.<locals>.RecordEndpointAddresses.connectionMadeNr�rHrHrHrI�RecordEndpointAddressesUsr�r�Fr�r�z�%(protocolName)s (on %(hostAddress)r) does not provide IFileDescriptorReceiver; closing file descriptor received (from %(peerAddress)r).r0)r�r�ZprotocolNamer�z3Expected event (%s) not found in logged events (%s)N)rr�r8r�r�r9r[r�r0r3r�r�setblockingrBZrecvr�r�r�r6�getrr)rDr�ZprobeClientZprobeServerr�r�rWrYr�ZclsNameZ
expectedEventZlogEvent�k�vrHrHrI� test_avoidLeakingFileDescriptorsCs>


����z1UNIXTestsBuilder.test_avoidLeakingFileDescriptorscs�tt�G�fdd�dt��}t�}t|��d�}|�}t�||�j���t	|j
d�trx��dt|j
dd���n��dd�
|j
dd���dS)z�
        L{IUNIXTransport.sendFileDescriptor} sends file descriptors before
        L{ITransport.write} sends normal bytes.
        cs(eZdZdd�Z�fdd�Zdd�ZdS)zJUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEventscSst�|�g|_dSre)r0rdr�rcrHrHrIrd�s
zYUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEvents.connectionMadecs ��t|�|j�t|��dSre)r�rr�r��type)Z	innerSelfrmrcrHrIrn�szaUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEvents.fileDescriptorReceivedcSs|j�|�dSre)r��extendrqrHrHrIrr�szWUNIXTestsBuilder.test_descriptorDeliveredBeforeBytes.<locals>.RecordEvents.dataReceivedN)rKrLrMrdrnrrrHrcrHrI�RecordEvents�sr�r�r�Nr�)rr!r0rr[r�r3r�rB�intr�r5�bytes�join)rDr�r�rWrYrHrcrI�#test_descriptorDeliveredBeforeBytes�s
z4UNIXTestsBuilder.test_descriptorDeliveredBeforeBytes)rKrLrMrNr"rZrQr�rurzr;�isLinux�skipr~r�r�r��sendmsgSkipr�r�r�r�r�ZisMacOSXr�r�r�rHrHrHrIrs�sT�	�-]�$A

rsc@s6eZdZdZejfZdd�Zdd�Ze	�
�s2de_dS)�UNIXDatagramTestsBuilderzE
    Builder defining tests relating to L{IReactorUNIXDatagram}.
    cCs|�d|��t��dS)z�
        The UNIX socket created by L{IReactorUNIXDatagram.listenUNIXDatagram}
        is created with the mode specified.
        �listenUNIXDatagramN)rJr
r%rcrHrHrI�test_listenMode�sz(UNIXDatagramTestsBuilder.test_listenModecCs>t|�}|��}|�d|t��}|�|��td|��dS)z�
        On Linux, a UNIX socket path may begin with C{''} to indicate a socket
        in the abstract namespace.  L{IReactorUNIX.listenUNIXDatagram} accepts
        such a path.
        rvN)rPr@r�r%rBrwrrxrHrHrIrz�sz<UNIXDatagramTestsBuilder.test_listenOnLinuxAbstractNamespacer{N)rKrLrMrNrZIReactorUNIXDatagramrZr�rzr;r�r�rHrHrHrIr��s
�r�c@s(eZdZdZeefZdd�Zdd�ZdS)�SocketUNIXMixinzb
    Mixin which uses L{IReactorSocket.adoptStreamPort} to hand out listening
    UNIX ports.
    cCsZtt�}tddd�}|�|�|�d�|�d�z|�|��|j	|�W�S|��XdS)zj
        Get a UNIX port from a reactor, wrapping an already-initialized file
        descriptor.
        rRrSrT�FN)
rrr
r��listenr�rZadoptStreamPortr�Zfamily)rDrGrFZportSockrErHrHrI�getListeningPort�s


�z SocketUNIXMixin.getListeningPortcCs|�|j|�S�aZ
        Connect to a listening UNIX socket.

        @param reactor: The reactor under test.
        @type reactor: L{IReactorUNIX}

        @param address: The listening's address.
        @type address: L{UNIXAddress}

        @param factory: The client factory.
        @type factory: L{ClientFactory}

        @return: The connector
        �rrX�rDrG�addressrFrHrHrI�connectToListener�sz!SocketUNIXMixin.connectToListenerN)	rKrLrMrNr"r#rZrrrHrHrHrIr��sr�c@s eZdZdZdd�Zdd�ZdS)�ListenUNIXMixinzZ
    Mixin which uses L{IReactorTCP.listenUNIX} to hand out listening UNIX
    ports.
    cCstddd�}|�||�S)z0
        Get a UNIX port from a reactor
        rRrSrT)r
rt)rDrGrFrErHrHrIr�sz ListenUNIXMixin.getListeningPortcCs|�|j|�SrrrrHrHrIrsz!ListenUNIXMixin.connectToListenerN)rKrLrMrNrrrHrHrHrIr�s	rc@s"eZdZefZdd�Zdd�ZdS)�UNIXPortTestsMixincCsd|t|��j�fS)zZ
        Get the message expected to be logged when a UNIX port starts listening.
        z%s starting on %r�r4rwrX)rDryrFrHrHrI�#getExpectedStartListeningLogMessages�z6UNIXPortTestsMixin.getExpectedStartListeningLogMessagecCsdt|��j�fS)zJ
        Get the expected connection lost message for a UNIX port
        z(UNIX Port %s Closed)r
)rDryrHrHrI�getExpectedConnectionLostLogMsg$sz2UNIXPortTestsMixin.getExpectedConnectionLostLogMsgN)rKrLrMr"rZrrrHrHrHrIr	sr	c@seZdZdZdS)�UNIXPortTestsBuilderz.
    Tests for L{IReactorUNIX.listenUnix}
    N�rKrLrMrNrHrHrHrIr
,sr
c@seZdZdZdS)�UNIXFDPortTestsBuilderz3
    Tests for L{IReactorUNIX.adoptStreamPort}
    NrrHrHrHrIr4src@s.eZdZeeefZdd�Zdd�Zdd�Z	dS)�%UNIXAdoptStreamConnectionTestsBuilderc	Cs~|��}ddlm}Gdd�dt�}|tt�\}}|�d�|�|j�|�|j�|�	�}|�}|�
|t|�}|�|�dS)z�
        {IReactorSocket.adoptStreamConnection} returns None if the given
        factory's buildProtocol returns None.
        rr�c@seZdZdd�ZdS)zXUNIXAdoptStreamConnectionTestsBuilder.test_buildProtocolReturnsNone.<locals>.NoneFactorycSsdSrerH)rDrrHrHrI�
buildProtocolNszfUNIXAdoptStreamConnectionTestsBuilder.test_buildProtocolReturnsNone.<locals>.NoneFactory.buildProtocolN)rKrLrMrrHrHrHrI�NoneFactoryMsrFN)r@rr�r&rr
r�r�rr��adoptStreamConnectionZassertIsNone)	rDrGr�r�s1�s2Zs1FDrFr�rHrHrI�test_buildProtocolReturnsNone?s

zCUNIXAdoptStreamConnectionTestsBuilder.test_buildProtocolReturnsNonecs<�fdd�}���}�j|ddd�}|�|���|�dS)z>
        Helper method to test UNIX server addresses.
        cs�|\}}}zftd|��j�}��d|jj|ft|j����d|jj|f|jj�|j	j
d}��|t�W5|j��XdS)Nr�z <AccumulatingProtocol #%s on %s>zAccumulatingProtocol,%s,%sr)
r_rbr=rwrXrBZ	sessionno�strZlogstrrFZ
peerAddressesr�r)�	protocolsrYrWryZportPathr�rcrHrI�	connectedas$

��
��zOUNIXAdoptStreamConnectionTestsBuilder.test_ServerAddressUNIX.<locals>.connectedN)�	interface�
addressFamily)r@�getConnectedClientAndServerr�Z
runReactor)rDrrGr�rHrcrI�test_ServerAddressUNIX\s

z<UNIXAdoptStreamConnectionTestsBuilder.test_ServerAddressUNIXcs�t�}t�|_t��t��_t��_t�}t�|_t�|_tddd�}��||����fdd�}|j�|�t|j�jg�}�fdd�}	|�	|	�t����
|	�t|j�jg�}
��fdd	�}|
�|������j
|��S)
a0
        Return a L{Deferred} firing with a L{MyClientFactory} and
        L{MyServerFactory} connected pair, and the listening C{Port}. The
        particularity is that the server protocol has been obtained after doing
        a C{adoptStreamConnection} against the original server connection.
        rRrSrTcs0��|j���|j���|j��t��dSre)ZremoveReaderr_ZremoveWriterrr�r)r�)rGrWrHrI�firstServerConnected�s�z_UNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.firstServerConnectedcs�jr���|Sre)�runningr�)r�)rGrHrIr��szOUNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.stopcs|\}}��||�f�dSre)rl)rrYrW)�deferredryrHrIr��szPUNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.start)r/rZprotocolConnectionMadeZprotocolConnectionLostr.r
rtr�rr�r�rrwrX)rDrGrrZfirstServerrYrErZlostDeferredr�Z
startDeferredr�rH)r ryrGrWrIr{s4�

�
zAUNIXAdoptStreamConnectionTestsBuilder.getConnectedClientAndServerN)
rKrLrMr$r#r"rZrrrrHrHrHrIr<s
rc@s6eZdZdZefZdZedd��Zdd�Z	dd�Z
dS)	�UnixClientTestsBuilderz7
    Define tests for L{IReactorUNIX.connectUNIX}.
    NcCs|jdkrt|�|_|jS)z�
        Return a path usable by C{connectUNIX} and C{listenUNIX}.

        @return: A path instance, built with C{_abstractPath}.
        N)�_pathrPrcrHrHrIrE�s

zUnixClientTestsBuilder.pathcCs|�|j|�S)z�
        Start an UNIX server with the given C{factory}.

        @param reactor: The reactor to create the UNIX port in.

        @param factory: The server factory.

        @return: A UNIX port instance.
        )rtrE�rDrGrFrHrHrIr�s
zUnixClientTestsBuilder.listencCs|�|j|�S)z�
        Start an UNIX client with the given C{factory}.

        @param reactor: The reactor to create the connection in.

        @param factory: The client factory.

        @return: A UNIX connector instance.
        )rrEr#rHrHrI�connect�s
zUnixClientTestsBuilder.connect)rKrLrMrNr"rZr"�propertyrErr$rHrHrHrIr!�s

r!)jrNZ
__future__rrrr�osrrrr	Ztempfiler
rrrr
rrZpprintrZhashlibrZstructrr�ImportErrorZzope.interfacerZtwisted.internetrrZtwisted.internet.addressrZtwisted.internet.deferrrrZtwisted.internet.endpointsrrZtwisted.internet.errorrrr Ztwisted.internet.interfacesr!r"r#r$Ztwisted.internet.protocolr%r&r'Ztwisted.internet.taskr(Z&twisted.internet.test.connectionmixinsr)Z#twisted.internet.test.reactormixinsr*Ztwisted.internet.test.test_corer+Ztwisted.internet.test.test_tcpr,r-r.r/r0r1r2r3Ztwisted.python.compatr4r5r6Ztwisted.python.failurer7Ztwisted.python.logr8r9r:Ztwisted.python.runtimer;Ztwisted.python.reflectr<Ztwisted.python.filepathr=r��objectr>rPrQr[rirsr�r�rr	r
rr�globals�updateZmakeTestCaseClassesr!rHrHrHrI�<module>s�
�'AZ!,!��u/
@ Telegram