HEX

File: //usr/lib/python3/dist-packages/twisted/internet/test/__pycache__/test_tcp.cpython-38.pyc
U


W[���
@s�dZddlmZmZeZddlZddlZddlZddl	Z	ddl
Z
ddlmZddl
Z
ddlmZmZddlmZmZddlmZddlmZdd	lmZdd
lmZddlmZddlmZm Z m!Z!dd
l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9ddl:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAddlBmCZCmDZDddlEmFZFmGZGmHZHmIZImJZJmKZKddlLmMZMmNZNddlOmPZPmQZQmRZRddl:mSZSmTZTmUZUddlVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]ddl^m_Z_ddl`maZambZbddl`mcZcmdZdddlemfZfmgZgzddlhmiZiWnejk
�rFdZkYnXddllmmZmdZkdZnze
�
e
joe
jp�Znen�qd�Wn.e
jrk
�r�Zszetes�ZuW5dZs[sXYnXdZuendk	�r�en�v�e�w��r�dd lxmyZyeyjzZ{d!Z|n:zdd"lxm}Z}Wnejk
�rd#d$�Z{YnXe}j~Z{dZ|d%d&�Zd'd(�Z�Gd)d*�d*e��Z�Gd+d,�d,e!�Z�Gd-d.�d.eR�Z�ee=�Gd/d0�d0e���Z�ee=e��Gd1d2�d2e!�Z�Gd3d4�d4e!�Z�Gd5d6�d6e2�Z�Gd7d8�d8e��Z�ee@�Gd9d:�d:e���Z�Gd;d<�d<e7e.e/�Z�Gd=d>�d>e��Z�Gd?d@�d@e��Z�GdAdB�dBe7�Z�GdCdD�dDe��Z�GdEdF�dFe��Z�dGdH�Z�GdIdJ�dJe�Z�ee��e
jnGdKdL�dLe����Z�GdMdN�dNe �Z�dOdP�Z�GdQdR�dRe �Z�GdSdT�dTe-�Z�GdUdV�dVe��Z�GdWdX�dXe��Z�GdYdZ�dZe��Z�Gd[d\�d\e��Z�Gd]d^�d^e7e�e�e_e��Z�Gd_d`�d`e7e�e�e_e��Z�Gdadb�dbeR�Z�dcdd�Z�dedf�Z�dgdh�Z�Gdidj�dje7�Z�Gdkdl�dle��Z�Gdmdn�dne��Z�Gdodp�dpe�e�e7�Z�Gdqdr�dre�e�e7�Z�e����e�����e����e�����e����e�����e����e�����e����e�����e����e�����e����e�����e����e�����e����e�����Gdsdt�dte1�Z�Gdudv�dve1�Z�Gdwdx�dxe1�Z�Gdydz�dze��Z�Gd{d|�d|e1�Z�Gd}d~�d~e1�Z�Gdd��d�e1�Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e1�Z�Gd�d��d�e1�Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e��Z�Gd�d��d�e7e��Z�e����e�����Gd�d��d�e!�Z�Gd�d��d�e �Z�Gd�d��d�e �Z�Gd�d��d�e �Z�dS)�zU
Tests for implementations of L{IReactorTCP} and the TCP parts of
L{IReactorSocket}.
�)�division�absolute_importN��wraps)�	Interface�implementer)�verifyClass�verifyObject)�Logger)�long)�platform)�Failure)�log)�SkipTest�SynchronousTestCase�TestCase)	�ConnectionLost�	UserError�ConnectionRefusedError�ConnectionDone�ConnectionAborted�DNSLookupError�
NoProtocol�ConnectBindError�ConnectionClosed)	�LogObserverMixin�ConnectionTestsMixin�StreamClientTestsMixin�findFreePort�ConnectableProtocol�EndpointCreator�runProtocolsWithReactor�Stop�BrokenContextFactory)�ReactorBuilder�needsRunningReactor�stopOnError)�ILoggingContext�
IConnector�
IReactorFDSet�IReactorSocket�IReactorTCP�IResolverSimple�
ITLSTransport)�IPv4Address�IPv6Address)�Deferred�DeferredList�
maybeDeferred�
gatherResults�succeed�fail)�TCP4ServerEndpoint�TCP4ClientEndpoint)�
ServerFactory�
ClientFactory�Protocol)�
IPushProducer�
IPullProducer�IHalfCloseableProtocol)�_BuffersLogs�
Connection�_FileDescriptorReservation�_IFileDescriptorReservation�_NullFileDescriptorReservation�Server�_resolveIPv6)�ObjectModelIntegrationMixin)�MyClientFactory�MyServerFactory)�ClosingFactory�ClientStartStopFactory)�
MemoryReactor�StringTransport)�SSLF)�ClientContextFactoryT)�::1r)�_win32ifacesz9Reserved EMFILE file descriptor not supported on Windows.)�_posixifacescCsgS�N�rRrRrR�@/usr/lib/python3/dist-packages/twisted/internet/test/test_tcp.py�<lambda>b�rTcCst�}|r|dStd��dS)al
    Find and return a configured link local IPv6 address including a scope
    identifier using the % separation syntax.  If the system has no link local
    IPv6 addresses, raise L{SkipTest} instead.

    @raise SkipTest: if no link local address can be found or if the
        C{netifaces} module is not available.

    @return: a C{str} giving the address
    rz#Link local IPv6 address unavailableN)�getLinkLocalIPv6Addressesr)Z	addressesrRrRrS�getLinkLocalIPv6AddressjsrWcCsD|\}}d|ksd|kr.t�||�dd}n||f}|�|�dS)a7
    Connect a socket to the given destination.

    @param client: A C{socket.socket}.

    @param destination: A tuple of (host, port). The host is a C{str}, the
        port a C{int}. If the C{host} is an IPv6 IP, the address is resolved
        using C{getaddrinfo} and the first version found is used.
    �%�:r�N)�socket�getaddrinfo�connect)�clientZdestination�host�port�addressrRrRrSr]|s

r]c@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�
FakeSocketz�
    A fake for L{socket.socket} objects.

    @ivar data: A C{str} giving the data which will be returned from
        L{FakeSocket.recv}.

    @ivar sendBuffer: A C{list} of the objects passed to L{FakeSocket.send}.
    cCs||_g|_dSrQ)�data�
sendBuffer��selfrcrRrRrS�__init__�szFakeSocket.__init__cCs
||_dSrQ)�blocking)rfrhrRrRrS�setblocking�szFakeSocket.setblockingcCs|jSrQ�rc)rf�sizerRrRrS�recv�szFakeSocket.recvcCs|j�|�t|�S)z�
        I{Send} all of C{bytes} by accumulating it into C{self.sendBuffer}.

        @return: The length of C{bytes}, indicating all the data has been
            accepted.
        )rd�append�len�rf�bytesrRrRrS�send�szFakeSocket.sendcCsdS)z�
        Shutdown is not implemented.  The method is provided since real sockets
        have it and some code expects it.  No behavior of L{FakeSocket} is
        affected by a call to it.
        NrR)rfZhowrRrRrS�shutdown�szFakeSocket.shutdowncCsdS)z�
        Close is not implemented.  The method is provided since real sockets
        have it and some code expects it.  No behavior of L{FakeSocket} is
        affected by a call to it.
        NrR�rfrRrRrS�close�szFakeSocket.closecGsdS)z�
        Setsockopt is not implemented.  The method is provided since
        real sockets have it and some code expects it.  No behavior of
        L{FakeSocket} is affected by a call to it.
        NrR)rf�argsrRrRrS�
setsockopt�szFakeSocket.setsockoptcCsdS)z�
        Return a fake file descriptor.  If actually used, this will have no
        connection to this L{FakeSocket} and will probably cause surprising
        results.
        �rRrsrRrRrS�fileno�szFakeSocket.filenoN)�__name__�
__module__�__qualname__�__doc__rgrirlrqrrrtrvrxrRrRrRrSrb�srbc@s(eZdZdZdd�Zdd�Zdd�ZdS)	�FakeSocketTestszT
    Test that the FakeSocket can be used by the doRead method of L{Connection}
    cCs$td�}|�d�|�|jd�dS)N�someDatar)rbri�assertEqualrh�rf�sktrRrRrS�
test_blocking�s
zFakeSocketTests.test_blockingcCstd�}|�|�d�d�dS)Nr~�
)rbrrlr�rRrRrS�	test_recv�szFakeSocketTests.test_recvcCs2td�}|�d�}|�|d�|�|jdg�dS)z�
        L{FakeSocket.send} accepts the entire string passed to it, adds it to
        its send buffer, and returns its length.
        rUsfoo�N)rbrqrrd)rfr��countrRrRrS�	test_send�s
zFakeSocketTests.test_sendN)ryrzr{r|r�r�r�rRrRrRrSr}�sr}c@seZdZdZdd�ZdS)�FakeProtocolzL
    An L{IProtocol} that returns a value from its dataReceived method.
    cCsdS)zq
        Return something other than L{None} to trigger a deprecation warning for
        that behavior.
        rRrRrerRrRrS�dataReceived�szFakeProtocol.dataReceivedN�ryrzr{r|r�rRrRrRrSr��sr�c@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�_FakeFDSetReactora�
    An in-memory implementation of L{IReactorFDSet}, which records the current
    sets of active L{IReadDescriptor} and L{IWriteDescriptor}s.

    @ivar _readers: The set of L{IReadDescriptor}s active on this
        L{_FakeFDSetReactor}
    @type _readers: L{set}

    @ivar _writers: The set of L{IWriteDescriptor}s active on this
        L{_FakeFDSetReactor}
    @ivar _writers: L{set}
    cCst�|_t�|_dSrQ)�set�_readers�_writersrsrRrRrSrgsz_FakeFDSetReactor.__init__cCs|j�|�dSrQ)r��add�rf�readerrRrRrS�	addReadersz_FakeFDSetReactor.addReadercCs||jkr|j�|�dSrQ)r��remover�rRrRrS�removeReaders
z_FakeFDSetReactor.removeReadercCs|j�|�dSrQ)r�r��rf�writerrRrRrS�	addWritersz_FakeFDSetReactor.addWritercCs||jkr|j�|�dSrQ)r�r�r�rRrRrS�removeWriters
z_FakeFDSetReactor.removeWritercCs|��|��}|��|SrQ)�
getReaders�
getWritersrg�rf�resultrRrRrS�	removeAllsz_FakeFDSetReactor.removeAllcCs
t|j�SrQ)�listr�rsrRrRrSr�$sz_FakeFDSetReactor.getReaderscCs
t|j�SrQ)r�r�rsrRrRrSr�(sz_FakeFDSetReactor.getWritersN)ryrzr{r|rgr�r�r�r�r�r�r�rRrRrRrSr��s
r�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�TCPServerTestsz<
    Whitebox tests for L{twisted.internet.tcp.Server}.
    cCsJt�|_Gdd�dt�}td�|_t�|_t|j|jd|�d|j�|_dS)Nc@seZdZdZdS)z&TCPServerTests.setUp.<locals>.FakePortr�N)ryrzr{Z_realPortNumberrRrRrRrS�FakePort5sr�rU)�r)	r��reactor�objectrbr�r:�protocolrC�server)rfr�rRrRrS�setUp3s
�zTCPServerTests.setUpcCs4|j�ttd���|j�d�|�|jjg�dS)zq
        L{Server.write} discards bytes passed to it if called after it has lost
        its connection.
        �Simulated lost connection�hello worldN)r��connectionLostr
�	Exception�writerr�rdrsrRrRrS�test_writeAfterDisconnect=s

�z(TCPServerTests.test_writeAfterDisconnectcCsd|j_|��dS)z�
        L{Server.write} discards bytes passed to it if called after it has lost
        its connection when the connection had started TLS.
        TN)r��TLSr�rsrRrRrS�!test_writeAfterDisconnectAfterTLSHsz0TCPServerTests.test_writeAfterDisconnectAfterTLScCs6|j�ttd���|j�dg�|�|jjg�dS)zy
        L{Server.writeSequence} discards bytes passed to it if called after it
        has lost its connection.
        r�r�N)r�r�r
r��
writeSequencerr�rdrsrRrRrS�!test_writeSequenceAfterDisconnectQs

�z0TCPServerTests.test_writeSequenceAfterDisconnectcCsd|j_|��dS)z�
        L{Server.writeSequence} discards bytes passed to it if called after it
        has lost its connection when the connection had started TLS.
        TN)r�r�r�rsrRrRrS�)test_writeSequenceAfterDisconnectAfterTLS\sz8TCPServerTests.test_writeSequenceAfterDisconnectAfterTLSN)	ryrzr{r|r�r�r�r�r�rRrRrRrSr�/s
	r�c@s2eZdZdZdd�Zdd�Zdd�Zes.de_d	S)
�TCPConnectionTestsz@
    Whitebox tests for L{twisted.internet.tcp.Connection}.
    cCsjtd�}t�}t||�}|��|�tjg�}|�|ddt�|�|ddd�|�t|�d�dS)z�
        When an L{IProtocol} implementation that returns a value from its
        C{dataReceived} method, a deprecated warning is emitted.
        r~r�category�messagez�Returning a value other than None from twisted.internet.test.test_tcp.FakeProtocol.dataReceived is deprecated since Twisted 11.0.0.rwN)	rbr�r?ZdoReadZ
flushWarningsr�r�DeprecationWarningrn)rfr�r��conn�warningsrRrRrS�test_doReadWarningIsRaisedjs

�z-TCPConnectionTests.test_doReadWarningIsRaisedcCs(td�}t�}t||�}|�|j�dS)z
        The C{TLS} attribute of a L{Connection} instance is C{False} before
        L{Connection.startTLS} is called.
        rUN)rbr�r?�assertFalser��rfr�r�r�rRrRrS�test_noTLSBeforeStartTLS}s
z+TCPConnectionTests.test_noTLSBeforeStartTLScCsBtd�}t�}t||t�d�}d|_|�t�d�|�|j�dS)z}
        The C{TLS} attribute of a L{Connection} instance is C{True} after
        L{Connection.startTLS} is called.
        rU�r�TN)	rbr�r?r�Z_tlsClientDefault�startTLSrM�
assertTruer�r�rRrRrS�test_tlsAfterStartTLS�sz(TCPConnectionTests.test_tlsAfterStartTLSzNo SSL support availableN)	ryrzr{r|r�r�r��useSSL�skiprRrRrRrSr�fsr�c@s$eZdZdZdZdd�Zdd�ZdS)�
TCPCreatorzO
    Create IPv4 TCP endpoints for L{runProtocolsWithReactor}-based tests.
    �	127.0.0.1cCst|d|jd�S)z4
        Create a server-side TCP endpoint.
        r��	interface)r6r�)rfr�rRrRrSr��szTCPCreator.servercCst||j|j�S)z�
        Create a client end point that will connect to the given address.

        @type serverAddress: L{IPv4Address}
        )r7r�r`)rfr��
serverAddressrRrRrSr^�szTCPCreator.clientN)ryrzr{r|r�r�r^rRrRrRrSr��sr�c@seZdZdZdd�ZdS)�TCP6CreatoraV
    Create IPv6 TCP endpoints for
    C{ReactorBuilder.runProtocolsWithReactor}-based tests.

    The endpoint types in question here are still the TCP4 variety, since
    these simply pass through IPv6 address literals to the reactor, and we are
    only testing address literals, not name resolution (as name resolution has
    not yet been implemented).  See http://twistedmatrix.com/trac/ticket/4470
    for more specific information about new endpoint classes.  The naming is
    slightly misleading, but presumably if you're passing an IPv6 literal, you
    know what you're asking for.
    cCst�|_dSrQ�rWr�rsrRrRrSrg�szTCP6Creator.__init__N)ryrzr{r|rgrRrRrRrSr��sr�c@s eZdZdZdd�Zdd�ZdS)�FakeResolverzR
    A resolver implementation based on a C{dict} mapping names to addresses.
    cCs
||_dSrQ)�names)rfr�rRrRrSrg�szFakeResolver.__init__cCs:zt|j|�WStk
r4ttd|��YSXdS)z�
        Return the address mapped to C{name} if it exists, or raise a
        C{DNSLookupError}.

        @param name: The name to resolve.

        @param timeout: The lookup timeout, ignore here.
        zFakeResolver couldn't find N)r4r��KeyErrorr5r)rf�nameZtimeoutrRrRrS�
getHostByName�s	zFakeResolver.getHostByNameN)ryrzr{r|rgr�rRrRrRrSr��sr�c@sZeZdZdZefZdZedd��Zedd��Z	dd�Z
d	d
�Zdd�Zd
d�Z
dd�ZdS)�TCPClientTestsBasea�
    Base class for builders defining tests related to
    L{IReactorTCP.connectTCP}.  Classes which uses this in must provide all of
    the documented instance variables in order to specify how the test works.
    These are documented as instance variables rather than declared as methods
    due to some peculiar inheritance ordering concerns, but they are
    effectively abstract methods.

    @ivar endpoints: A client/server endpoint creator appropriate to the
        address family being tested.
    @type endpoints: L{twisted.internet.test.connectionmixins.EndpointCreator}

    @ivar interface: An IP address literal to locally bind a socket to as well
        as to connect to.  This can be any valid interface for the local host.
    @type interface: C{str}

    @ivar port: An unused local listening port to listen on and connect to.
        This will be used in conjunction with the C{interface}.  (Depending on
        what they're testing, some tests will locate their own port with
        L{findFreePort} instead.)
    @type port: C{int}

    @ivar family: an address family constant, such as L{socket.AF_INET},
        L{socket.AF_INET6}, or L{socket.AF_UNIX}, which indicates the address
        family of the transport type under test.
    @type family: C{int}

    @ivar addressClass: the L{twisted.internet.interfaces.IAddress} implementor
        associated with the transport type under test.  Must also be a
        3-argument callable which produces an instance of same.
    @type addressClass: C{type}

    @ivar fakeDomainName: A fake domain name to use, to simulate hostname
        resolution and to distinguish between hostnames and IP addresses where
        necessary.
    @type fakeDomainName: C{str}
    NcCs(|jdk	r|j��jSt|j|j�dS)z�
        Return the port number to connect to, using C{self._port} set up by
        C{listen} if available.

        @return: The port number to connect to.
        @rtype: C{int}
        Nrw)�_port�getHostr`rr��familyrsrRrRrSr`s	
zTCPClientTestsBase.portcCs|jjS)zK
        Return the interface attribute from the endpoints object.
        )�	endpointsr�rsrRrRrSr�szTCPClientTestsBase.interfacecCs|jd||jd�|_|jS)z�
        Start a TCP server with the given C{factory}.

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

        @param factory: The server factory.

        @return: A TCP port instance.
        rr�)�	listenTCPr�r��rfr��factoryrRrRrS�listens
zTCPClientTestsBase.listencCs|�|j|j|�S)z�
        Start a TCP client with the given C{factory}.

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

        @param factory: The client factory.

        @return: A TCP connector instance.
        )�
connectTCPr�r`r�rRrRrSr]+s
zTCPClientTestsBase.connectc
s�t������t�}�|_t���Gdd�dt���j����|�}���fdd�}|�	|�}�fdd�}dd�}|�
||��fd	d
�}|�	|�}|�tj
��fdd�}	|�	|	�����d
S)zr
        When the factory's C{buildProtocol} returns L{None} the connection is
        gracefully closed.
        c@seZdZdd�ZdS)zETCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.NoneFactorycSsdSrQrR�rfrarRrRrS�
buildProtocolFszSTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.NoneFactory.buildProtocolN�ryrzr{r�rRrRrRrS�NoneFactoryEsr�cs"��}�j��|���}|�|�SrQ)r�r^r�r])r`�
clientFactory�endpoint)r�r�rfrRrS�listenedKszBTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.listenedcs��d|f�dS)NzUStream client endpoint connect succeeded with %r, should have failed with NoProtocol.)r5�r�rsrRrS�connectSucceededQs
��zJTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.connectSucceededcSs|�t�dSrQ)�trapr)�reasonrRrRrS�
connectFailedUszGTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.connectFailedcs�SrQrR��ignored)r�rRrS�	connectedYszCTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.connectedcs���dSrQ��stopr�r�rRrS�disconnectedcszFTCPClientTestsBase.test_buildProtocolReturnsNone.<locals>.disconnectedN)r0�buildReactorrG�protocolConnectionLostr&r8r�r�r��addCallbackZaddCallbacks�
addErrbackr�err�
runReactor)
rf�
serverFactoryZ	listeningr�Z
connectingr�r�r�Z
disconnectingr�rR)r�r�r�rfrS�test_buildProtocolReturnsNone8s$



z0TCPClientTestsBase.test_buildProtocolReturnsNonec	s�t�j�j�dd�\}}�����j���t��ji���jdt�	t
�|d�����}dddd��G��fdd�dt
�}t���|�_
�����fdd	�}t�|������jrȈ��j���d
�dj�djt�d�f}|gtt��j�j�ddd
d��}|gtt��j|j�ddd
d��}���d�jd|������d�jd|�����t�d�|�dS)a�
        A client's transport's C{getHost} and C{getPeer} return L{IPv4Address}
        instances which have the dotted-quad string form of the resolved
        address of the local and remote endpoints of the connection
        respectively as their C{host} attribute, not the hostname originally
        passed in to
        L{connectTCP<twisted.internet.interfaces.IReactorTCP.connectTCP>}, if a
        hostname was used.
        N�rr�)r_�peer�instancecseZdZ��fdd�ZdS)z7TCPClientTestsBase.test_addresses.<locals>.CheckAddresscs,|���d<|���d<|�d<���dS)Nr_r�r�)r��getPeerr��rf�	transport�r��
transportDatarRrS�makeConnection�szFTCPClientTestsBase.test_addresses.<locals>.CheckAddress.makeConnectionN�ryrzr{r�rRr�rRrS�CheckAddress�sr�cstt�j�j�}�j|df}t�d�|��z�j����j�|d�Wnt	k
r`YqYqX|d�_
qpqdS)Nrwz#Connect attempt with bindAddress {})�bindAddress)rr�r�r�msg�formatr�r�r`r�	boundPort)r`r�)r��
fakeDomainr�rfr�rRrS�	connectMe�s ��


z4TCPClientTestsBase.test_addresses.<locals>.connectMez<%s to %s at %x>r����rwr_�TCPr�)r)r)rr�r�r��fakeDomainNameZinstallResolverr�r�r8�forProtocolr:r�r"r�r%r�Z
failReasonr5�getTraceback�	__class__Zaddr�idr�r[r\rr`r�addressClass�repr)	rfr_r�r�r�rZ
transportReprrZ
serverPortrR)r�rr�rfr�r�rS�test_addressesnsp
�


�
����
������
�z!TCPClientTestsBase.test_addressescs�����t��g�t�t�}�jd|�jd�}�j��|�	��}t
�}t|_|�|�����fdd���fdd������fdd�}t
�|�������t��d	d
�f�t�dt�rʈd���ddkr�td����tjt�d��d
S)z�
        If the context factory passed to L{ITCPTransport.startTLS} raises an
        exception from its C{getContext} method, that exception is raised by
        L{ITCPTransport.startTLS}.
        rr�cs4t�|j�s��d�n����t|jj���dS)Nr�)r-�
providedByr�rm�assertRaises�
ValueErrorr�r�)�
brokenFactory�resultsrfrRrSr��s
�z5TCPClientTestsBase.test_badContext.<locals>.connectedcs��|�dSrQ�rm)Zfailure)rrRrSr��sz9TCPClientTestsBase.test_badContext.<locals>.connectFailedcs*�����������fdd��dS)Ncs���SrQr��Zignr�rRrSrT�rUzETCPClientTestsBase.test_badContext.<locals>.whenRun.<locals>.<lambda>)r�r��addBothrR)�connectDeferredr�r�r�rRrS�whenRun�s

z3TCPClientTestsBase.test_badContext.<locals>.whenRunrwz!more than one callback result: %sr�z&Reactor does not support ITLSTransportN)r�r#r8rr:r�r�r�r^r�r9r�r]r%r�rrn�
isinstancer
�raiseExceptionrr��str)rfr�r`r�r�rrR)rrr�r�r�rrfrS�test_badContext�s,



�z"TCPClientTestsBase.test_badContext)ryrzr{r|r+�requiredInterfacesr��propertyr`r�r�r]r�rrrRrRrRrSr��s%


6Nr�c@s$eZdZdZdZejZeZ	e
�ZdS)�TCP4ClientTestsBuilderze
    Builder configured with IPv4 parameters for tests related to
    L{IReactorTCP.connectTCP}.
    zsome-fake.domain.example.comN)ryrzr{r|rr[�AF_INETr�r.r
r�r�rRrRrRrSr�s
rc@s*eZdZdZereZejZe	Z
dd�ZdS)�TCP6ClientTestsBuilderze
    Builder configured with IPv6 parameters for tests related to
    L{IReactorTCP.connectTCP}.
    cCst�|_|jj|_dSrQ)r�r�r�rrsrRrRrSr�szTCP6ClientTestsBuilder.setUpN)ryrzr{r|�ipv6Skipr�r[�AF_INET6r�r/r
r�rRrRrRrSr�src@s.eZdZdZefZdd�Zdd�Zdd�ZdS)	�TCPConnectorTestsBuilderzU
    Tests for the L{IConnector} provider returned by L{IReactorTCP.connectTCP}.
    cs�t�}|����jd||jd�}||_|��j}g�g�t�}��fdd�|_�j|_	��
|j||�}|�t�
|��|��}|�|jd�|�|j|j�|�|j|�|j��fdd��|����d�t�|��||g�dS)aU
        L{IReactorTCP.connectTCP} returns an object which provides
        L{IConnector}.  The destination of the connector is the address which
        was passed to C{connectTCP}.  The same connector object is passed to
        the factory's C{startedConnecting} method as to the factory's
        C{clientConnectionLost} method.
        rr�cs��|���|�fSrQr��	connectorr�)�seenConnectors�seenFailuresrRrSrT-s�zATCPConnectorTestsBuilder.test_connectorIdentity.<locals>.<lambda>rcs���SrQr���_r�rRrSrT9rUN)rHr�r�r�r`r�rI�clientConnectionLostrm�startedConnectingr�r�r(r
ZgetDestinationr�typer_�whenStoppedrr�r�r)rfr��tcpPort�
portNumberr�r$�destrR)r�r%r&rS�test_connectorIdentitys.
�
�
z/TCPConnectorTestsBuilder.test_connectorIdentitycs�t�}�����jd|�jd�}|��j�g���fdd�}t��|�_�j�	�fdd����
����fdd�������r����d�
���j�t����jd�d	S)
z�
        Calling L{IConnector.stopConnecting} in C{Factory.startedConnecting}
        results in C{Factory.clientConnectionFailed} being called with
        L{error.UserError} as the reason.
        rr�cs:z|��Wn(tk
r4��t�����YnXdSrQ)ZstopConnectingr�rmr
r�)r$)�fatalErrorsr�rRrSr*Ns
zATCPConnectorTestsBuilder.test_userFail.<locals>.startedConnectingcs���SrQr�r'r�rRrSrTXrUz8TCPConnectorTestsBuilder.test_userFail.<locals>.<lambda>cs���j���SrQ)r�r�rR)r�r.r�rfrRrSrTZs�rwN)rGr�r�r�r�r`rIr*r,r�callWhenRunningr�r5rr�r�rrZfailed)rfr�r-r*rR)r�r1r.r�rfrS�
test_userFailAs

z&TCPConnectorTestsBuilder.test_userFailcs�t�}|����jd||jd�}||_|��j}t��dd�}|�_��|j|��g����fdd�}�j	�
|�|����j�
t�|��dg�dS)	z�
        Calling L{IConnector.connect} in C{Factory.clientConnectionLost} causes
        a new connection attempt to be made.
        rr�cSs|��dSrQ)r]r#rRrRrSr)sszETCPConnectorTestsBuilder.test_reconnect.<locals>.clientConnectionLostcs$�j}��|j|jf����dSrQ)r�rmZmade�closedr�)r��p�r�ZprotocolMadeAndClosedr�rRrS�reconnectFailedysz@TCPConnectorTestsBuilder.test_reconnect.<locals>.reconnectFailed)rwrwN)rHr�r�r�r`r�rFr)r��failDeferredr�r�r�r�rr)rfr�r-r.r)r7rRr6rS�test_reconnectfs

z'TCPConnectorTestsBuilder.test_reconnectN)	ryrzr{r|r+rr0r3r9rRrRrRrSr"s
'%r"c@seZdZdZejZeZdS)�TCP4ConnectorTestsBuilderr�N)	ryrzr{r�r[rr�r.r
rRrRrRrSr:�sr:c@s&eZdZejZeZereZ	dd�Z
dS)�TCP6ConnectorTestsBuildercCst�|_dSrQr�rsrRrRrSr��szTCP6ConnectorTestsBuilder.setUpN)ryrzr{r[r!r�r/r
r r�r�rRrRrRrSr;�s
r;cCst�||�}|�|j�|S)z�
    Create a socket for the duration of the given test.

    @param test: the test to add cleanup to.

    @param addressFamily: an C{AF_*} constant

    @param socketType: a C{SOCK_*} constant.

    @return: a socket object.
    )r[�
addCleanuprt)�test�
addressFamilyZ
socketTyper�rRrRrS�createTestSocket�sr?c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�_IExhaustsFileDescriptorsz%
    A way to trigger C{EMFILE}.
    cCsdS)z�
        Open file descriptors until C{EMFILE} is reached.

        This can raise any exception except an L{OSError} whose
        C{errno} is C{EMFILE}.  Any exception raised to the caller
        implies L{release}.
        NrRrRrRrRrS�exhaust�sz!_IExhaustsFileDescriptors.exhaustcCsdS�zD
        Release all file descriptors opened by L{exhaust}.
        NrRrRrRrRrS�release�sz!_IExhaustsFileDescriptors.releasecCsdS)��
        Return the number of opened file descriptors.

        @return: The number of opened file descriptors; this will be
            zero if this instance has not opened any.
        @rtype: L{int}
        NrRrRrRrRrSr��sz_IExhaustsFileDescriptors.countN�ryrzr{r|rArCr�rRrRrRrSr@�s
r@c@sfeZdZdZe�Zejdd�dd�Zeje	j
dd�Zeje�e
�ddd�Zdd�Zd	d
�Zdd�Zd
S)�_ExhaustsFileDescriptorsa_
    A class that triggers C{EMFILE} by creating as many file
    descriptors as necessary.

    @ivar fileDescriptorFactory: A factory that creates a new file
        descriptor.
    @type fileDescriptorFactory: A L{callable} that accepts no
        arguments and returns an integral file descriptor, suitable
        for passing to L{os.close}.
    cCs
t�d�S�Nr)�os�duprRrRrRrSrT�rUz!_ExhaustsFileDescriptors.<lambda>F)�defaultr)rJZinitrc
Cs�t��z\z|��}Wn<ttfk
rR}z|jtjkr@WY�qb�W5d}~XYq
X|j�|�q
Wnt	k
r�|�
��YnX|jjd|�
�d�dS)zC
        Open file descriptors until C{EMFILE} is reached.
        NzCEMFILE reached by opening {openedFileDescriptors} file descriptors.)ZopenedFileDescriptors)�gcZcollect�_fileDescriptorFactory�IOError�OSError�errno�EMFILE�_fileDescriptorsrmr�rC�_log�infor��rf�fd�erRrRrSrA�s �z _ExhaustsFileDescriptors.exhaustc
Cs^|jrZ|j��}z|�|�Wqtk
rV}z|jtjkrDWY�q�W5d}~XYqXqdSrB)rQ�pop�_closerNrO�EBADFrTrRrRrSrC�s
z _ExhaustsFileDescriptors.releasecCs
t|j�S)rD)rnrQrsrRrRrSr�sz_ExhaustsFileDescriptors.countN)ryrzr{r|r
rR�attrZibrLrHrtrXZFactoryr�rQrArCr�rRrRrRrSrF�s
�rFc@sdeZdZdZeZdd�Zdd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dd�Zdd�ZdS)�ExhaustsFileDescriptorsTestsz0
    Tests for L{_ExhaustsFileDescriptors}.
    cCst�|_|�|jj�dSrQ)rF�	exhausterr<rCrsrRrRrSr�sz"ExhaustsFileDescriptorsTests.setUpcCsttj���dS)z`
        Attempt to open a file; if successful, the file is immediately
        closed.
        N)�openrH�devnullrtrsrRrRrS�	openAFile!sz&ExhaustsFileDescriptorsTests.openAFilecCstt|j�dS)ze
        L{_ExhaustsFileDescriptors} instances provide
        L{_IExhaustsFileDescriptors}.
        N)r	r@r\rsrRrRrS�test_providesInterface)sz3ExhaustsFileDescriptorsTests.test_providesInterfacecCsN|�|j��d�|j��|�|j��d�|j��|�|j��d�dS)zh
        L{_ExhaustsFileDescriptors.count} returns the number of open
        file descriptors.
        rN)rr\r�rA�
assertGreaterrCrsrRrRrS�
test_count1s


z'ExhaustsFileDescriptorsTests.test_countcCs:|�|jj�|j��|�t|j�}|�|jtj	�dS)z{
        L{_ExhaustsFileDescriptors.exhaust} causes the process to
        exhaust its available file descriptors.
        N)
r<r\rCrArrMr_rrOrP)rf�	exceptionrRrRrS�test_exhaustTriggersEMFILE=s
z7ExhaustsFileDescriptorsTests.test_exhaustTriggersEMFILEcCs"dd�}t|�}|�t|j�dS)z�
        An L{OSError} raised within
        L{_ExhaustsFileDescriptors.exhaust} with an C{errno} other
        than C{EMFILE} is reraised to the caller.
        cSsttjdd��dS)Nrwz
Not EMFILE)rNrOrPrRrRrRrS�raiseOSErrorNszLExhaustsFileDescriptorsTests.test_exhaustRaisesOSError.<locals>.raiseOSErrorN)rFrrNrA)rfrer\rRrRrS�test_exhaustRaisesOSErrorHsz6ExhaustsFileDescriptorsTests.test_exhaustRaisesOSErrorcCs |j��|j��|��dS)zc
        L{_ExhaustsFileDescriptors.release} releases all opened
        file descriptors.
        N)r\rArCr_rsrRrRrS�test_releaseUs

z)ExhaustsFileDescriptorsTests.test_releasecs�g��fdd�}t|�}|�|j�|�t|j�|�t��d�|�|��d��D]$}|�t	t
j|�}|�|jtj
�qVdS)z�
        L{_ExhaustsFileDescriptors.exhaust} closes any opened file
        descriptors if an exception occurs during its exhaustion loop.
        cs2t��dkrtd��nt�d�}��|�|SdS)Nr�z9test_fileDescriptorsReleasedOnFailure fake open exceptionr)rnrrHrIrm�rU�ZfileDescriptorsrRrS�failsAfterThreegs�

z[ExhaustsFileDescriptorsTests.test_fileDescriptorsReleasedOnFailure.<locals>.failsAfterThreer�rN)rFr<rCrrrArrnr�rNrH�fstatrOrY)rfrjr\rUrcrRrirS�%test_fileDescriptorsReleasedOnFailure`s
zBExhaustsFileDescriptorsTests.test_fileDescriptorsReleasedOnFailurecsfg��fdd�}t|�}|�|j�|��|�|��d�t��d�|��|�|��d�dS)z�
        L{_ExhaustsFileDescriptors.release} continues to close opened
        file descriptors even when closing one fails with C{EBADF}.
        cst�d�}��|�|SrG)rHrIrmrhrirRrS�recordFileDescriptors�s

zTExhaustsFileDescriptorsTests.test_releaseIgnoresEBADF.<locals>.recordFileDescriptorsrN)	rFr<rCrArar�rHrtr)rfrmr\rRrirS�test_releaseIgnoresEBADF}sz5ExhaustsFileDescriptorsTests.test_releaseIgnoresEBADFcs^g��fdd�}dd�}t||d�}|�|��d�|��|�|��d�|�t|j�dS)z�
        An L{OSError} raised within
        L{_ExhaustsFileDescriptors.release} with an C{errno} other than
        C{EBADF} is reraised to the caller.
        cs*t��dkrttjd����d��dS)Nr�zToo many filesr)rnrNrOrPrmrR�ZfakeFileDescriptorsrRrS�
opensThree�s
zJExhaustsFileDescriptorsTests.test_releaseRaisesOSError.<locals>.opensThreecSstdd��dS)N�z&test_releaseRaisesOSError fake OSError)rNrhrRrRrS�failingClose�szLExhaustsFileDescriptorsTests.test_releaseRaisesOSError.<locals>.failingClose)rtrN)rFrr�rArarrNrC)rfrprrr\rRrorS�test_releaseRaisesOSError�s�z6ExhaustsFileDescriptorsTests.test_releaseRaisesOSErrorN)ryrzr{r|�SKIP_EMFILEr�r�r_r`rbrdrfrgrlrnrsrRrRrRrSr[s
r[cs�|��j�t�}t�}||_dg���fdd�}|�|�|�|�}	|	��}
t�}|�|
|����j	���fdd�}|j
�|�|j�|�|��g}
|�|
j
�|�|
d�|�|j�|�|j
�|�t|jj�dS)a#
    Assert that an L{IListeningPort} immediately closes an accepted
    peer socket when the number of open file descriptors exceeds the
    soft resource limit.

    @param testCase: The test case under which to run this assertion.
    @type testCase: L{trial.unittest.SynchronousTestCase}

    @param exhauster: The file descriptor exhauster.
    @type exhauster: L{_ExhaustsFileDescriptors}

    @param reactor: The reactor under test.

    @param runReactor: A callable that will synchronously run the
        provided reactor.

    @param listen: A callback to bind to a port.
    @type listen: A L{callable} that accepts two arguments: the
        provided C{reactor}; and a L{ServerFactory}.  It must return
        an L{IListeningPort} provider.

    @param connect: A callback to connect a client to the listening
        port.
    @type connect: A L{callable} that accepts three arguments: the
        provided C{reactor}; the address returned by
        L{IListeningPort.getHost}; and a L{ClientFactory}.  Its return
        value is ignored.
    Fcs���d�d<dS)NTrr�r')r��serverConnectionCompletedrRrS�stopReactorIfServerAccepted�sz=assertPeerClosedOnEMFILE.<locals>.stopReactorIfServerAcceptedcs������|SrQ)rCr��r�)r\r�rRrS�"stopReactorAndCloseFileDescriptors�szDassertPeerClosedOnEMFILE.<locals>.stopReactorAndCloseFileDescriptorsz1Server accepted connection; EMFILE not triggered.N)r<rCrGr0�protocolConnectionMader�r�rFr2rA�deferredrr8rmr�ZassertNoResultZsuccessResultOfrrZ
lostReasonr)�testCaser\r�r�r�r]r�ZserverConnectionMadervr`Z
listeningHostr�rxZnoResultrR)r\r�rurS�assertPeerClosedOnEMFILE�s<$�
��r|c@sDeZdZdZeZee�Gdd�de��Z	dd�Z
dd�Zdd	�Zd
S)�AssertPeerClosedOnEMFILETestsz0
    Tests for L{assertPeerClosedOnEMFILE}.
    c@s(eZdZdZdd�Zdd�Zdd�ZdS)	z+AssertPeerClosedOnEMFILETests.NullExhausterz1
        An exhauster that does nothing.
        cCsdS)zB
            See L{_IExhaustsFileDescriptors.exhaust}
            NrRrsrRrRrSrAsz3AssertPeerClosedOnEMFILETests.NullExhauster.exhaustcCsdS)zB
            See L{_IExhaustsFileDescriptors.release}
            NrRrsrRrRrSrCsz3AssertPeerClosedOnEMFILETests.NullExhauster.releasecCsdS)z@
            See L{_IExhaustsFileDescriptors.count}
            NrRrsrRrRrSr�sz1AssertPeerClosedOnEMFILETests.NullExhauster.countNrErRrRrRrS�
NullExhaustersr~cCst�|_t�|_dSrQ)rJr�rr{rsrRrRrSr�sz#AssertPeerClosedOnEMFILETests.setUpcCstt|���dS)zZ
        L{NullExhauster} instances provide
        L{_IExhaustsFileDescriptors}.
        N)r	r@r~rsrRrRrS�#test_nullExhausterProvidesInterface"szAAssertPeerClosedOnEMFILETests.test_nullExhausterProvidesInterfacec
sr|��}dg��fdd�}�fdd�}dd�}|j|jjt|j||j|||d�}|�d	t|��|�|jj	�dS)
z�
        If the exhauster fails to trigger C{EMFILE} and a connection
        reaches the server, the reactor is stopped and the test fails.
        Ncs.|���d�tddd��}|�t��dS)Nrrr�i�)�runr�r.r�rK)r��proto�r�rRrSr�2s

�z[AssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnection.<locals>.runReactorcs"|�dd|�}|��|�d<|S)Nr�i�r)r�ZdoStart)r�r�r`r�rRrSr�8szWAssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnection.<locals>.listencSs|�dd|�dS)Nr�r)r�)r�rar�rRrRrSr]>szXAssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnection.<locals>.connect�r{r\r�r�r�r]rP)
r~rr{ZfailureExceptionr|r��assertInrr��running)rfr\r�r�r]rcrRr�rS�)test_reactorStoppedOnSuccessfulConnection*s"�zGAssertPeerClosedOnEMFILETests.test_reactorStoppedOnSuccessfulConnectionN)
ryrzr{r|rtr�rr@r�r~r�rr�rRrRrRrSr}sr}c@s:eZdZdZdd�Zdd�Zdd�Zdd	�Zer6ee_	d
S)�StreamTransportTestsMixinzR
    Mixin defining tests which apply to any port/connection based transport.
    cCs`|��}|��}tt�Gdd�dt��}|�}|�||�}|�|d�}|�|f|dd�dS)zt
        When a port starts, a message including a description of the associated
        factory is logged.
        c@seZdZdd�ZdS)zNStreamTransportTestsMixin.test_startedListeningLogMessage.<locals>.SomeFactorycSsdS)N�
Crazy FactoryrRrsrRrRrS�	logPrefix`szXStreamTransportTestsMixin.test_startedListeningLogMessage.<locals>.SomeFactory.logPrefixN)ryrzr{r�rRrRrRrS�SomeFactory^sr�r�rr�N)Zobserver�rr'r8�getListeningPort�#getExpectedStartListeningLogMessager)rf�loggedMessagesr�r�r�r5�expectedMessagerRrRrS�test_startedListeningLogMessageVs�z9StreamTransportTestsMixin.test_startedListeningLogMessagecszg��fdd��|���|��t���|���}t�����fdd�����fdd�}��|����|�|��dS)z�
        When a connection is lost, an informative message should be logged
        (see L{getExpectedConnectionLostLogMsg}): an address identifying
        the port and the fact that it was closed.
        cs��t�|��dSrQ)rmrZtextFromEventDict)Z	eventDict)r�rRrS�logConnectionLostMsgrszQStreamTransportTestsMixin.test_connectionLostLogMsg.<locals>.logConnectionLostMsgcst������dSrQ)rZremoveObserverr�r�)r�r�rRrS�stopReactorzs
zHStreamTransportTestsMixin.test_connectionLostLogMsg.<locals>.stopReactorcst���t�j����dSrQ)r�addObserverr2�
stopListeningr�rR)r�r5r�rRrS�doStopListening~s
zLStreamTransportTestsMixin.test_connectionLostLogMsg.<locals>.doStopListeningN)	r�r�r8�getExpectedConnectionLostLogMsgrr�r2r�r�)rfr�r�rR)r�r�r5r�r�rS�test_connectionLostLogMsgjs


z3StreamTransportTestsMixin.test_connectionLostLogMsgcCs$|��}|�|t��}|�|�dS)zz
        The L{IListeningPort} object is an instance of a class with no
        classic classes in its hierarchy.
        N)r�r�r8ZassertFullyNewStyle)rfr�r`rRrRrS�test_allNewStyle�sz*StreamTransportTestsMixin.test_allNewStylecCs$t|t�|��|j|j|jd�dS)z2
        See L{assertPeerClosedOnEMFILE}.
        r�N)r|rFr�r�r��connectToListenerrsrRrRrS�test_closePeerOnEMFILE�s�z0StreamTransportTestsMixin.test_closePeerOnEMFILEN)
ryrzr{r|r�r�r�r�rtr�rRrRrRrSr�Qs

r�c@seZdZdZdZdd�ZdS)�ConnectToTCPListenerMixina^
    Provides L{connectToListener} for TCP transports.

    @ivar LISTENER_HOST: The host on which the port is expected to be
        listening.  This is specific to avoid compatibility issues
        with Windows, which cannot connect to the wildcard host.
    @type LISTENER_HOST: L{str}

    @see: U{http://twistedmatrix.com/trac/ticket/1472}
    r�cCs|�|j|j|�S)a�
        Connect to the given listening TCP port.

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

        @param address: The listening port's address.  Only the
            C{port} component is used; see L{LISTENER_HOST}.
        @type address: L{IPv4Address} or L{IPv6Address}

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

        @return: The connector
        )r��
LISTENER_HOSTr`)rfr�rar�rRrRrSr��sz+ConnectToTCPListenerMixin.connectToListenerN)ryrzr{r|r�r�rRrRrRrSr��s
r�c@seZdZdZddd�ZdS)�ListenTCPMixinzT
    Mixin which uses L{IReactorTCP.listenTCP} to hand out listening TCP ports.
    rr�cCs|j|||d�S)z0
        Get a TCP port from a reactor.
        r�)r�)rfr�r�r`r�rRrRrSr��szListenTCPMixin.getListeningPortN)rr��ryrzr{r|r�rRrRrRrSr��sr�c@seZdZdZddd�ZdS)�SocketTCPMixinza
    Mixin which uses L{IReactorSocket.adoptStreamPort} to hand out
    listening TCP ports.
    rr�cCs�t�|�r�d|kr.tj}t�||�dd}ntj}||f}t�|�}|�|�|�d�|�d�z|�|�	�|j|�W�S|�	�|�
�Xnt
d��dS)zi
        Get a TCP port from a reactor, wrapping an already-initialized file
        descriptor.
        rYrrZr�Fz'Reactor does not provide IReactorSocketN)r*r
r[r!r\r�bindr�rirxrtZadoptStreamPortr�r)rfr�r�r`r�ZdomainraZportSockrRrRrSr��s&




�zSocketTCPMixin.getListeningPortN)rr�r�rRrRrRrSr��sr�c@s�eZdZdZefZdd�Zdd�Zdd�Zdd	�Z	e
r<e
e	_d
d�Ze
rNe
e_dd
�Z
dd�Zdd�Ze
rpe
e_dd�Ze
r�e
e_dd�Zdd�Zdd�Ze
r�e
e_dd�Ze
r�e
e_dd�Zdd�Ze
r�e
e_d d!�Ze
r�e
e_d"S)#�TCPPortTestsMixinz,
    Tests for L{IReactorTCP.listenTCP}
    cCsd||��jfS)zY
        Get the message expected to be logged when a TCP port starts listening.
        z%s starting on %d�r�r`)rfr`r�rRrRrSr��s�z5TCPPortTestsMixin.getExpectedStartListeningLogMessagecCsd|��jfS)zJ
        Get the expected connection lost message for a TCP port.
        z(TCP Port %s Closed)r�)rfr`rRrRrSr�sz1TCPPortTestsMixin.getExpectedConnectionLostLogMsgcCs.|��}|�|t��}|��}|�|t�dS)z�
        When no interface is passed to L{IReactorTCP.listenTCP}, the returned
        listening port listens on an IPv4 address.
        N)r�r�r8r��assertIsInstancer.)rfr�r`rarRrRrS�test_portGetHostOnIPv4sz(TCPPortTestsMixin.test_portGetHostOnIPv4cCsh|��}ttjdd�dd�\}}|�|t�||�}|��}|�|t�|�	d|j
�|�	||j�dS)z�
        When listening on an IPv6 address, L{IListeningPort.getHost} returns
        an L{IPv6Address} with C{host} and C{port} attributes reflecting the
        address the port is bound to.
        rN)r�r�Nr�)r�rr[r!r�r8r�r�r/rr_r`)rfr�r_r.r`rarRrRrS�test_portGetHostOnIPv6s"��
�z(TCPPortTestsMixin.test_portGetHostOnIPv6cCsFt�}|��}|�|t�d|�}|��}|�|t�|�||j�dS)a(
        When a link-local IPv6 address including a scope identifier is passed as
        the C{interface} argument to L{IReactorTCP.listenTCP}, the resulting
        L{IListeningPort} reports its address as an L{IPv6Address} with a host
        value that includes the scope identifier.
        rN)	rWr�r�r8r�r�r/rr_)rfZ	linkLocalr�r`rarRrRrS�test_portGetHostOnIPv6ScopeID)sz/TCPPortTestsMixin.test_portGetHostOnIPv6ScopeIDc
s�G�fdd�dt�}|�}|���|��|d|�}|�d�zt||��j|��jf�Wn:tj	k
r�}z|�
|jtjtj
f�W5d}~XYnX|���|jS)a
        Connect C{client} to a server listening on C{interface} started with
        L{IReactorTCP.listenTCP} and return the address passed to the factory's
        C{buildProtocol} method.

        @param client: A C{SOCK_STREAM} L{socket.socket} created with an address
            family such that it will be able to connect to a server listening on
            C{interface}.

        @param interface: A C{str} giving an address for a server to listen on.
            This should almost certainly be the loopback address for some
            address family supported by L{IReactorTCP.listenTCP}.

        @return: Whatever object, probably an L{IAddress} provider, is passed to
            a server factory's C{buildProtocol} method when C{client}
            establishes a connection.
        cseZdZ�fdd�ZdS)zCTCPPortTestsMixin._buildProtocolAddressTest.<locals>.ObserveAddresscs���||_t�SrQ)r��observedAddressr:r�r�rRrSr�MszQTCPPortTestsMixin._buildProtocolAddressTest.<locals>.ObserveAddress.buildProtocolNr�rRr�rRrS�ObserveAddressLsr�rFN)r8r�r�rir]r�r_r`r[�errorr�rO�EINPROGRESS�EWOULDBLOCKr�r�)rfr^r�r�r�r`rVrRr�rS�_buildProtocolAddressTest:s
(
z+TCPPortTestsMixin._buildProtocolAddressTestcCs<d}t|tjtj�}|�||�}|�td|����|�dS)z�
        When a connection is accepted over IPv4, an L{IPv4Address} is passed
        to the factory's C{buildProtocol} method giving the peer's address.
        r�rN)r)r?r[r�SOCK_STREAMr�rr.�getsockname)rfr�r^r�rRrRrS�test_buildProtocolIPv4Address`s�z/TCPPortTestsMixin.test_buildProtocolIPv4AddresscCsVd}t|tjtj�}|�||�}|��}t�|tj�d}|�t	d||d�|�dS)z�
        When a connection is accepted to an IPv6 address, an L{IPv6Address} is
        passed to the factory's C{buildProtocol} method giving the peer's
        address.
        rNrrrwN)
r?r[r!r�r�r��getnameinfo�NI_NUMERICHOSTrr/�rfr�r^r�r��hostnamerRrRrS�test_buildProtocolIPv6Addressls�z/TCPPortTestsMixin.test_buildProtocolIPv6AddresscCs`t�}t|tjtj�}|�||�}|��}t�|tj�d}|�	t
d|f|dd���|�dS)z�
        When a connection is accepted to a link-local IPv6 address, an
        L{IPv6Address} is passed to the factory's C{buildProtocol} method
        giving the peer's address, including a scope identifier.
        rrrwN)rWr?r[r!r�r�r�r�r�rr/r�rRrRrS�$test_buildProtocolIPv6AddressScopeIDs�z6TCPPortTestsMixin.test_buildProtocolIPv6AddressScopeIDc
s�G��fdd�dt�}|���t�}||_|��|d|�}|�d�zt||��j|��j	f�Wn:t
jk
r�}z|�|j
t
jt
jf�W5d}~XYnX|���|jS)a�
        Connect C{client} to a server listening on C{interface} started with
        L{IReactorTCP.listenTCP} and return the address returned by one of the
        server transport's address lookup methods, C{getHost} or C{getPeer}.

        @param client: A C{SOCK_STREAM} L{socket.socket} created with an address
            family such that it will be able to connect to a server listening on
            C{interface}.

        @param interface: A C{str} giving an address for a server to listen on.
            This should almost certainly be the loopback address for some
            address family supported by L{IReactorTCP.listenTCP}.

        @param which: A C{str} equal to either C{"getHost"} or C{"getPeer"}
            determining which address will be returned.

        @return: Whatever object, probably an L{IAddress} provider, is returned
            from the method indicated by C{which}.
        cseZdZ��fdd�ZdS)zITCPPortTestsMixin._serverGetConnectionAddressTest.<locals>.ObserveAddresscs���t|���|j_dSrQ)r��getattrr�rar��r��whichrRrSr��szXTCPPortTestsMixin._serverGetConnectionAddressTest.<locals>.ObserveAddress.makeConnectionNr�rRr�rRrSr��sr�rFN)r:r�r8r�r�rir]r�r_r`r[r�r�rOr�r�r�ra)rfr^r�r�r�r�r`rVrRr�rS�_serverGetConnectionAddressTest�s
(
z1TCPPortTestsMixin._serverGetConnectionAddressTestcCs>d}t|tjtj�}|�||d�}|�td|����|�dS)z�
        When a connection is accepted over IPv4, the server
        L{ITransport.getHost} method returns an L{IPv4Address} giving the
        address on which the server accepted the connection.
        r�r�rN)r)r?r[rr�r�rr.�getpeername)rfr�r^�hostAddressrRrRrS�test_serverGetHostOnIPv4�s��z*TCPPortTestsMixin.test_serverGetHostOnIPv4cCs`d}t|tjtj�}|�||d�}|��}t�|tj�d}|�t	d|f|dd���|�dS)z�
        When a connection is accepted over IPv6, the server
        L{ITransport.getHost} method returns an L{IPv6Address} giving the
        address on which the server accepted the connection.
        rNr�rrrwN)
r?r[r!r�r�r�r�r�rr/�rfr�r^r�r�r�rRrRrS�test_serverGetHostOnIPv6�s��z*TCPPortTestsMixin.test_serverGetHostOnIPv6cCsbt�}t|tjtj�}|�||d�}|��}t�|tj�d}|�	t
d|f|dd���|�dS)z�
        When a connection is accepted over IPv6, the server
        L{ITransport.getHost} method returns an L{IPv6Address} giving the
        address on which the server accepted the connection, including the scope
        identifier.
        r�rrrwN)rWr?r[r!r�r�r�r�r�rr/r�rRrRrS�test_serverGetHostOnIPv6ScopeID�s��z1TCPPortTestsMixin.test_serverGetHostOnIPv6ScopeIDcCs>d}t|tjtj�}|�||d�}|�td|����|�dS)z�
        When a connection is accepted over IPv4, the server
        L{ITransport.getPeer} method returns an L{IPv4Address} giving the
        address of the remote end of the connection.
        r�r�rN)r)r?r[rr�r�rr.r�)rfr�r^�peerAddressrRrRrS�test_serverGetPeerOnIPv4�s��z*TCPPortTestsMixin.test_serverGetPeerOnIPv4cCs`d}t|tjtj�}|�||d�}|��}t�|tj�d}|�t	d|f|dd���|�dS)z�
        When a connection is accepted over IPv6, the server
        L{ITransport.getPeer} method returns an L{IPv6Address} giving the
        address on the remote end of the connection.
        rNr�rrrwN)
r?r[r!r�r�r�r�r�rr/�rfr�r^r�r�r�rRrRrS�test_serverGetPeerOnIPv6�s��z*TCPPortTestsMixin.test_serverGetPeerOnIPv6cCsbt�}t|tjtj�}|�||d�}|��}t�|tj�d}|�	t
d|f|dd���|�dS)z�
        When a connection is accepted over IPv6, the server
        L{ITransport.getPeer} method returns an L{IPv6Address} giving the
        address on the remote end of the connection, including the scope
        identifier.
        r�rrrwN)rWr?r[r!r�r�r�r�r�rr/r�rRrRrS�test_serverGetPeerOnIPv6ScopeIDs��z1TCPPortTestsMixin.test_serverGetPeerOnIPv6ScopeIDN)ryrzr{r|r+rr�r�r�r�r r�r�r�r�r�r�r�r�r�r�r�r�r�rRrRrRrSr��sD
&&r�c@seZdZdS)�TCPPortTestsBuilderN�ryrzr{rRrRrRrSr�'sr�c@seZdZdS)�TCPFDPortTestsBuilderNr�rRrRrRrSr�.sr�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�StopStartReadingProtocolzD
    Protocol that pauses and resumes the transport a few times
    cCsd|_|�d�dS)NrUr�)rc�pauseResumeProducingrsrRrRrS�connectionMade:sz'StopStartReadingProtocol.connectionMadecCsN|j��|j��|r2|jj�d|j|d�n|jj�d|jjj|�dS)z?
        Toggle transport read state, then count down.
        rrwN)	r��pauseProducing�resumeProducingr�r��	callLaterr��ready�callback)rfZcounterrRrRrSr�?s


�
�z-StopStartReadingProtocol.pauseResumeProducingcCs@t�dt|��|j|7_t|j�dkr<|jj�|j�dS)Nzgot datai@)rr�rnrcr�r�r�rerRrRrSr�Msz%StopStartReadingProtocol.dataReceivedN)ryrzr{r|r�r�r�rRrRrRrSr�5sr�cst���fdd��}|S)aG
    Decorate a L{ReactorBuilder} test function which tests one reactor and one
    connected transport.  Run that test method in the context of
    C{connectionMade}, and immediately drop the connection (and end the test)
    when that completes.

    @param testMethod: A unit test method on a L{ReactorBuilder} test suite;
        taking two additional parameters; a C{reactor} as built by the
        L{ReactorBuilder}, and an L{ITCPTransport} provider.
    @type testMethod: 3-argument C{function}

    @return: a no-argument test method.
    @rtype: 1-argument C{function}
    cs8t��G���fdd�dt�}|�}t�|�t��dS)NcseZdZ���fdd�ZdS)zBoneTransportTest.<locals>.actualTestMethod.<locals>.ServerProtocolcsDz��|j|j�W5|jdk	r*|j���jdk	r>�j��XdSrQ)r��loseConnectionr�rs��builder�other�
testMethodrRrSr�hs


zQoneTransportTest.<locals>.actualTestMethod.<locals>.ServerProtocol.connectionMadeN�ryrzr{r�rRr�rRrS�ServerProtocolgsr�)rr!r�)r�r�ZserverProtocol�r�)r�r�rS�actualTestMethodds	z*oneTransportTest.<locals>.actualTestMethodr)r�r�rRr�rS�oneTransportTestUs
r�cCs:t�|�r|�||���n|�||j�|�|j�dS)a^
    Use the given test to assert that the given transport is actively reading
    in the given reactor.

    @note: Maintainers; for more information on why this is a function rather
        than a method on a test case, see U{this document on how we structure
        test tools
        <http://twistedmatrix.com/trac/wiki/Design/KeepTestToolsOutOfFixtures>}

    @param testCase: a test case to perform the assertion upon.
    @type testCase: L{TestCase}

    @param reactor: A reactor, possibly one providing L{IReactorFDSet}, or an
        IOCP reactor.

    @param transport: An L{ITCPTransport}
    N)r)r
r�r�Zhandlesr��reading�r{r�r�rRrRrS�
assertReadingvs
r�cCs,t�|�r|�||���n|�|j�dS)ae
    Use the given test to assert that the given transport is I{not} actively
    reading in the given reactor.

    @note: Maintainers; for more information on why this is a function rather
        than a method on a test case, see U{this document on how we structure
        test tools
        <http://twistedmatrix.com/trac/wiki/Design/KeepTestToolsOutOfFixtures>}

    @param testCase: a test case to perform the assertion upon.
    @type testCase: L{TestCase}

    @param reactor: A reactor, possibly one providing L{IReactorFDSet}, or an
        IOCP reactor.

    @param transport: An L{ITCPTransport}
    N)r)r
ZassertNotInr�r�r�r�rRrRrS�assertNotReading�s
r�c@sReZdZdZefZdd�Zedd��Zedd��Z	edd	��Z
d
d�Zdd
�ZdS)�TCPConnectionTestsBuilderzP
    Builder defining tests relating to L{twisted.internet.tcp.Connection}.
    c	s�t�������_ddg}�jj}||kr<t��r<td��t�_	t
��_t
��_��
d��}|��j}����fdd�}�fdd��t�d	|�}t�}t|_	t|�|��jg��||�}|�tj�����d
S)zt
        This test verifies transport socket read state after multiple
        pause/resumeProducing calls.
        ZGlib2ReactorZGtk2Reactorz.This test is broken on gtk/glib under Windows.rcsn��|d���|d�|dd|ddf}|dj�dddd��j��||���fdd��S)zL
            Send several IOCPReactor's buffers' worth of data.
            rrw�x� �ycs���SrQr�rr�rRrSrT�rUzRTCPConnectionTestsBuilder.test_stopStartReading.<locals>.proceed.<locals>.<lambda>)r�r�r�r�r�)�protosr`��cleanupr�rfZsfrRrS�proceed�s
�z@TCPConnectionTestsBuilder.test_stopStartReading.<locals>.proceedcsF��|ddddd�tt|djj�t|djj�t|j�g�S)z�
            Make sure IOCPReactor didn't start several WSARecv operations
            that clobbered each other's results.
            r�r�r�zdid not get the right datarrw)rr1r2r�r�r�)rcr�r`rsrRrSr��s��z@TCPConnectionTestsBuilder.test_stopStartReading.<locals>.cleanupr�N)r8r�r�rryr�	isWindowsrr�r�r0r�r�r�r�r`r7r9r:r1r]r�r�rr�r�)	rfZskippedReactorsZreactorClassNamer5r`r�ZccZcf�drRr�rS�test_stopStartReading�s*�
z/TCPConnectionTestsBuilder.test_stopStartReadingcCs,|��t|||�|��t|||�dS)zz
        When a L{Server} is connected, its C{resumeProducing} method adds it as
        a reader to the reactor.
        N)r�r�r�r��rfr�r�rRrRrS�test_resumeProducing�sz.TCPConnectionTestsBuilder.test_resumeProducingcCs |��|��t|||�dS)z�
        When a L{Server} has already started disconnecting via
        C{loseConnection}, its C{resumeProducing} method does not add it as a
        reader to its reactor.
        N)r�r�r�r�rRrRrS�&test_resumeProducingWhileDisconnecting�sz@TCPConnectionTestsBuilder.test_resumeProducingWhileDisconnectingcCs6|�ttd���t|||�|��t|||�dS)z�
        When a L{Server} has already lost its connection, its
        C{resumeProducing} method does not add it as a reader to its reactor.
        ZdummyN)r�r
r�r�r�r�rRrRrS�%test_resumeProducingWhileDisconnected�sz?TCPConnectionTestsBuilder.test_resumeProducingWhileDisconnectedcCsPGdd�dt�}Gdd�dt�}|�}t|||�t��|�|jdddg�dS)	a�
        Alice connects to Bob.  Alice writes some bytes and then shuts down the
        connection.  Bob receives the bytes from the connection and then pauses
        the transport object.  Shortly afterwards Bob resumes the transport
        object.  At that point, Bob is notified that the connection has been
        closed.

        This is no problem for most reactors.  The underlying event notification
        API will probably just remind them that the connection has been closed.
        It is a little tricky for win32eventreactor (MsgWaitForMultipleObjects).
        MsgWaitForMultipleObjects will only deliver the close notification once.
        The reactor needs to remember that notification until Bob resumes the
        transport.
        c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
zQTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.PausercSs
g|_dSrQ)�eventsrsrRrRrSrgszZTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.__init__cSs*|j�d�|j��|j�d|j�dS)N�pausedr)r�rmr�r�r�r��resumerorRrRrSr�s
z^TCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.dataReceivedcSs|j�d�|j��dS)N�resumed)r�rmr�r�rsrRrRrSr�szXTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.resumecSs|j�d�t�||�dS)N�lost)r�rmrr��rfr�rRrRrSr�#sz`TCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Pauser.connectionLostN)ryrzr{rgr�r�r�rRrRrRrS�Pausersr�c@seZdZdd�ZdS)zQTCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.ClientcSs|j�d�|j��dS)Nssome bytes for you)r�r�r�rsrRrRrSr�)sz`TCPConnectionTestsBuilder.test_connectionLostAfterPausedTransport.<locals>.Client.connectionMadeNr�rRrRrRrS�Client(sr�r�r�r�N)rr!r�rr�)rfr�r�ZpauserrRrRrS�'test_connectionLostAfterPausedTransports
zATCPConnectionTestsBuilder.test_connectionLostAfterPausedTransportcCs@tt�Gdd�dt��}Gdd�dt�}t||�|�t��dS)a-
        If one side half-closes its connection, and then the other side of the
        connection calls C{loseWriteConnection}, and then C{loseConnection} in
        {writeConnectionLost}, the connection is closed correctly.

        This rather obscure case used to fail (see ticket #3037).
        c@seZdZdd�Zdd�ZdS)zHTCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.ListenerProtocolcSs|j��dSrQ)r�ZloseWriteConnectionrsrRrRrS�readConnectionLost=sz[TCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.ListenerProtocol.readConnectionLostcSs|j��dSrQ�r�r�rsrRrRrS�writeConnectionLost@sz\TCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.ListenerProtocol.writeConnectionLostN)ryrzr{r�r�rRrRrRrS�ListenerProtocol:sr�c@seZdZdd�ZdS)z>TCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.ClientcSs|j��dSrQr�rsrRrRrSr�DszMTCPConnectionTestsBuilder.test_doubleHalfClose.<locals>.Client.connectionMadeNr�rRrRrRrSr�Csr�N)rr=rr!r�)rfr�r�rRrRrS�test_doubleHalfClose2s�z.TCPConnectionTestsBuilder.test_doubleHalfCloseN)
ryrzr{r|r+rr�r�r�r�r�r�r�rRrRrRrSr��s2


+r�c@s>eZdZdZefZdd�Zdd�Zdd�Zdd	�Z	d
d�Z
dS)
�WriteSequenceTestsMixinzM
    Test for L{twisted.internet.abstract.FileDescriptor.writeSequence}.
    cCs"t|dd�dk	r||_n||_dS)z�
        Set the write buffer size for the given transport, mananing possible
        differences (ie, IOCP). Bug #4322 should remove the need of that hack.
        �writeBufferSizeN)r�r�Z
bufferSize)rfr��valuerRrRrS�setWriteBufferSizeSsz*WriteSequenceTestsMixin.setWriteBufferSizecsH�fdd�}���}��|dtj�}|�|�|�tj���|�dS)zV
        C{writeSequence} sends the data even if C{write} hasn't been called.
        cs4|\�}}��fdd�}||_�j�dddg�dS)Ncs(t�d|���|d��j��dS)Nzdata received: %rsSome sequence splitted)rr�rr�r�rj)r^rfrRrSr�fsz^WriteSequenceTestsMixin.test_writeSequeceWithoutWrite.<locals>.connected.<locals>.dataReceivedsSome s	sequence ssplitted)r�r�r�)�	protocolsr�r`r�rs)r^rSr�cs
zHWriteSequenceTestsMixin.test_writeSequeceWithoutWrite.<locals>.connectedr�N�	r��getConnectedClientAndServerr[rr�r�rr�r��rfr�r�r�rRrsrS�test_writeSequeceWithoutWrite^s�
z5WriteSequenceTestsMixin.test_writeSequeceWithoutWritecsH�fdd�}���}��|dtj�}|�|�|�tj���|�dS)zo
        C{writeSequence} with an element in the sequence of type unicode raises
        C{TypeError}.
        cs<|\}}}��t|jjdg�}��t|�d�|j��dS)NzUnicode is not kosherzData must not be unicode)r�	TypeErrorr�r�rrr�)r�r^r�r`�excrsrRrSr�}s
�zWWriteSequenceTestsMixin.test_writeSequenceWithUnicodeRaisesException.<locals>.connectedr�Nr�rrRrsrS�,test_writeSequenceWithUnicodeRaisesExceptionws�
zDWriteSequenceTestsMixin.test_writeSequenceWithUnicodeRaisesExceptioncsztt�Gdd�dt��}|����fdd�}���}��|dtj�}|�|�|�t	j
���|����j
ddg�dS)	z{
        C{writeSequence} pauses its streaming producer if too much data is
        buffered, and then resumes it.
        c@s4eZdZdZdZdd�Zdd�Zdd�Zdd	�ZdS)
zJWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducerNcSs
g|_dSrQ��actionsrsrRrRrSrg�szSWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.__init__cSs|j�d�dS)N�pause�rrmrsrRrRrSr��szYWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.pauseProducingcSs(|j�d�|jj��|jj��dS)Nr�)rrmr^r�ZunregisterProducerr�r�rsrRrRrSr��szZWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.resumeProducingcSs|j�d�dS�Nr�r	rsrRrRrS�
stopProducing�szXWriteSequenceTestsMixin.test_streamingProducer.<locals>.SaveActionProducer.stopProducing)	ryrzr{r^r�rgr�r�rrRrRrRrS�SaveActionProducer�s
rcsl|dd�\}}|�_|�_|j��d����jg���|jd�|j�dgd����jdg�dS)Nr�T���2xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx�r)r^r�r��registerProducerrrr�r��r�r^r���producerrfrRrSr��szAWriteSequenceTestsMixin.test_streamingProducer.<locals>.connectedr�rr�N)rr;r�r�rr[rr�r�rr�r�rr�rfrr�r�r�rRrrS�test_streamingProducer�s�

z.WriteSequenceTestsMixin.test_streamingProducercs���tt�G�fdd�dt��}|����fdd�}���}��|dtj�}|�|�|�t	j
���|����j
ddg�dS)z�
        C{writeSequence} pauses its producer if too much data is buffered only
        if this is a streaming producer.
        cs,eZdZdZdd�Z�fdd�Zdd�ZdS)zMWriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducerNcSs
g|_dSrQrrsrRrRrSrg�szVWriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducer.__init__csR|j�d�|j�d�dkr*|jj��n$��|jjd�|jj�dgd�dS)Nr�r�r
rr)rrmr�r^r�Z
stopConsumingr�r�rs�r=rRrSr��s
z]WriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducer.resumeProducingcSs|j�d�dSr
r	rsrRrRrSr�sz[WriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.SaveActionProducer.stopProducing)ryrzr{r^rgr�rrRrrRrSr�srcs0|d}|�_|j��d����jdg�dS)NrFr�)r^r�rrr)r�r^rrRrSr��szDWriteSequenceTestsMixin.test_nonStreamingProducer.<locals>.connectedr�r�N)rr<r�r�rr[rr�r�rr�r�rrrrR)rrfr=rS�test_nonStreamingProducer�s�

z1WriteSequenceTestsMixin.test_nonStreamingProducerN)ryrzr{r|r+rr�rrrrrRrRrRrSr�Ms6r�c@s:eZdZdZdd�Zdd�Zdd�Zdd	�Zer6ee_	d
S)�"TCPTransportServerAddressTestMixinzE
    Test mixing for TCP server address building and log prefix.
    cCs
t��dS)z�
        Helper method returnine a L{Deferred} firing with a tuple of a client
        protocol, a server protocol, and a running TCP port.
        N)�NotImplementedError)rfr�r�r>rRrRrSr�sz>TCPTransportServerAddressTestMixin.getConnectedClientAndServercsJ���fdd�}���}��|�|�}|�|�|�tj���|�dS)zT
        Helper method to test TCP server addresses on either IPv4 or IPv6.
        cs�|\}}}zv��d|jj|��jft|j����d|jj�f|jj�|jj	\}��
|����d|j����|j�W5|j��XdS)Nz <AccumulatingProtocol #%s on %s>zAccumulatingProtocol,%s,%sr)
r�r�rZ	sessionnor�r`rZlogstrr�Z
peerAddressesr�r+r_)r�r^r�r`r���adressClassr�rfrRrSr�	s&
��
��
zHTCPTransportServerAddressTestMixin._testServerAddress.<locals>.connectedN)r�rr�r�rr�r�)rfr�r>rr�r�r�rRrrS�_testServerAddress	s
z5TCPTransportServerAddressTestMixin._testServerAddresscCs|�dtjt�S)z�
        L{Server} instances have a string representation indicating on which
        port they're running, and the connected address is stored on the
        C{peerAddresses} attribute of the factory.
        r�)rr[rr.rsrRrRrS�test_serverAddressTCP4$	s
�z9TCPTransportServerAddressTestMixin.test_serverAddressTCP4cCs|�t�tjt�S)z�
        IPv6 L{Server} instances have a string representation indicating on
        which port they're running, and the connected address is stored on the
        C{peerAddresses} attribute of the factory.
        )rrWr[r!r/rsrRrRrS�test_serverAddressTCP6.	s�z9TCPTransportServerAddressTestMixin.test_serverAddressTCP6N)
ryrzr{r|rrrrr r�rRrRrRrSr�s!
	rc@seZdZdZdd�ZdS)�TCPTransportTestsBuilderzT
    Test standard L{ITCPTransport}s built with C{listenTCP} and C{connectTCP}.
    c
s�t�}t�|_t�|_t�}t�|_t�|_�jd||d��t|j|jg�}�fdd�}|�|�t|j|jg�}t����fdd�}	|�|	���	|��
�j|��S)z�
        Return a L{Deferred} firing with a L{MyClientFactory} and
        L{MyServerFactory} connected pair, and the listening C{Port}.
        rr�cs���|SrQr�rwr�rRrSr�S	szBTCPTransportTestsBuilder.getConnectedClientAndServer.<locals>.stopcs8|\}}t�d|�t�d|���||�f�dS�Nzclient connected %szserver connected %s�rr�r�r�rzr`rRrS�start^	szCTCPTransportTestsBuilder.getConnectedClientAndServer.<locals>.start)rGr0ryr�rFr�r3rr�r�r�r`)
rfr�r�r>r�r^�lostDeferredr��
startDeferredr#rR)rzr`r�rSrB	s(�
�
z4TCPTransportTestsBuilder.getConnectedClientAndServerN)ryrzr{r|rrRrRrRrSr<	src@s eZdZdZeefZdd�ZdS)�!AdoptStreamConnectionTestsBuilderzF
    Test server transports built using C{adoptStreamConnection}.
    cs�t�}t�|_t��t��_t��_t�}t�|_t�|_�jd||d�����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.
        rr�cs0��|j���|j���|j�����dSrQ)r�r�r�ZadoptStreamConnectionrx)r�)r>r�r�rRrS�firtServerConnected�	s�zZAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.firtServerConnectedcs�jr���|SrQ)r�r�rwr�rRrSr��	szKAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.stopcs8|\}}t�d|�t�d|���||�f�dSr r!rr"rRrSr#�	szLAdoptStreamConnectionTestsBuilder.getConnectedClientAndServer.<locals>.start)
rGr0ryr�rFr�r�r3rr�r�r�r`)rfr�r�r>ZfirstServerr^r'r$r�r%r#rR)r>rzr`r�r�rSrt	s2�

�
z=AdoptStreamConnectionTestsBuilder.getConnectedClientAndServerN)ryrzr{r|r)r*rrrRrRrRrSr&l	sr&c@seZdZdZdd�ZdS)�ServerAbortsTwicez'
    Call abortConnection() twice.
    cCs|j��|j��dSrQ)r��abortConnectionrerRrRrSr��	s
zServerAbortsTwice.dataReceivedNr�rRrRrRrSr(�	sr(c@seZdZdZdd�ZdS)�ServerAbortsThenLosesz>
    Call abortConnection() followed by loseConnection().
    cCs|j��|j��dSrQ)r�r)r�rerRrRrSr��	s
z"ServerAbortsThenLoses.dataReceivedNr�rRrRrRrSr*�	sr*c@seZdZdZdd�ZdS)�AbortServerWritingProtocolz4
    Protocol that writes data upon connection.
    cCs|j�d�dS)zW
        Tell the client that the connection is set up and it's time to abort.
        sreadyN�r�r�rsrRrRrSr��	sz)AbortServerWritingProtocol.connectionMadeN�ryrzr{r|r�rRrRrRrSr+�	sr+c@seZdZdZdd�ZdS)�ReadAbortServerProtocolz�
    Server that should never receive any data, except 'X's which are written
    by the other side of the connection before abortConnection, and so might
    possibly arrive.
    cCs|�dd�rtd��dS)N�XrUzUnexpectedly received data.)�replacer�rerRrRrSr��	sz$ReadAbortServerProtocol.dataReceivedNr�rRrRrRrSr.�	sr.c@seZdZdZdd�ZdS)�NoReadServerz�
    Stop reading immediately on connection.

    This simulates a lost connection that will cause the other side to time
    out, and therefore call abortConnection().
    cCs|j��dSrQ)r��stopReadingrsrRrRrSr��	szNoReadServer.connectionMadeNr-rRrRrRrSr1�	sr1c@s8eZdZdZdZdZdd�Zdd�Zdd�Zd	d
�Z	dS)�EventualNoReadServerz�
    Like NoReadServer, except we Wait until some bytes have been delivered
    before stopping reading. This means TLS handshake has finished, where
    applicable.
    FcCs*|js&d|_|j�|d�|j�d�dS)NTF�hello)�gotDatar�rr�rerRrRrSr��	sz!EventualNoReadServer.dataReceivedcCs|jr
dSd|_|j��dS�NT)�stoppedReadingr�r2rsrRrRrSr�
sz$EventualNoReadServer.resumeProducingcCsdSrQrRrsrRrRrSr�
sz#EventualNoReadServer.pauseProducingcCsdSrQrRrsrRrRrSr
sz"EventualNoReadServer.stopProducingN)
ryrzr{r|r5r7r�r�r�rrRrRrRrSr3�	sr3c@seZdZdZdZdd�ZdS)�BaseAbortingClientz/
    Base class for abort-testing clients.
    FcCs|jrtd��t�||�dS)Nz,BUG: connectionLost was called re-entrantly!)�inReactorMethod�RuntimeErrorrr�r�rRrRrSr�
sz!BaseAbortingClient.connectionLostN)ryrzr{r|r9r�rRrRrRrSr8
sr8c@seZdZdZdd�ZdS)�WritingButNotAbortingClientz&
    Write data, but don't abort.
    cCs|j�d�dS)Nr4r,rsrRrRrSr�)
sz*WritingButNotAbortingClient.connectionMadeNr-rRrRrRrSr;$
sr;c@s eZdZdZdd�Zdd�ZdS)�AbortingClientz9
    Call abortConnection() after writing some data.
    cCsd|_|��d|_dS)zF
        Some data was received, so the connection is set up.
        TFN)r9�
writeAndAbortrerRrRrSr�3
szAbortingClient.dataReceivedcCs.|j�dd�|j��|j�dd�dS)Nr/i'�Y)r�r�r)rsrRrRrSr=<
s
zAbortingClient.writeAndAbortN)ryrzr{r|r�r=rRrRrRrSr<.
s	r<c@seZdZdZdd�ZdS)�AbortingTwiceClientz@
    Call abortConnection() twice, after writing some data.
    cCst�|�|j��dSrQ)r<r=r�r)rsrRrRrSr=K
s
z!AbortingTwiceClient.writeAndAbortN�ryrzr{r|r=rRrRrRrSr?F
sr?c@seZdZdZdd�ZdS)�AbortingThenLosingClientz;
    Call abortConnection() and then loseConnection().
    cCst�|�|j��dSrQ)r<r=r�r�rsrRrRrSr=V
s
z&AbortingThenLosingClient.writeAndAbortNr@rRrRrRrSrAQ
srAc@s@eZdZdZdZdZdd�Zdd�Zdd	�Zd
d�Z	dd
�Z
dS)�ProducerAbortingClientzA
    Call abortConnection from doWrite, via resumeProducing.
    TFcCs.|j�dd�d|_|j�|d�d|_dS)Nslalalai�TF)r�r��inRegisterProducerrrsrRrRrSr�d
szProducerAbortingClient.writecCs|��dSrQ�r�rsrRrRrSr�k
sz%ProducerAbortingClient.connectionMadecCs d|_|js|j��d|_dS)NTF)r9rCr�r)rsrRrRrSr�o
s
z&ProducerAbortingClient.resumeProducingcCs
d|_dSr6)�producerStoppedrsrRrRrSrv
sz$ProducerAbortingClient.stopProducingcCs,|jstd��|jrtd��t�||�dS)Nz&BUG: stopProducing() was never called.z(BUG: connectionLost called re-entrantly!)rEr:r9rr�r�rRrRrSr�z
s
z%ProducerAbortingClient.connectionLostN)ryrzr{r|r9rEr�r�r�rr�rRrRrRrSrB\
srBc@sTeZdZdZdZdZdZdd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dS)�StreamingProducerClienta�
    Call abortConnection() when the other side has stopped reading.

    In particular, we want to call abortConnection() only once our local
    socket hits a state where it is no longer writeable. This helps emulate
    the most common use case for abortConnection(), closing a connection after
    a timeout, with write buffers being full.

    Since it's very difficult to know when this actually happens, we just
    write a lot of data, and assume at that point no more writes will happen.
    FrcCs|��dSrQrDrsrRrRrSr��
sz&StreamingProducerClient.connectionMadecCs0|j�|d�td�D]}|j�dd�qdS)zh
        Write large amount to transport, then wait for a while for buffers to
        fill up.
        T�ds
1234567890i}N)r�r�ranger�)rf�irRrRrSr��
szStreamingProducerClient.writecCs
d|_dS)NF)r�rsrRrRrSr��
sz'StreamingProducerClient.resumeProducingcCsdSrQrRrsrRrRrSr�
sz%StreamingProducerClient.stopProducingcCs$|jr
dSd|_|j�d|j�dS)a&
        Called when local buffer fills up.

        The goal is to hit the point where the local file descriptor is not
        writeable (or the moral equivalent). The fact that pauseProducing has
        been called is not sufficient, since that can happen when Twisted's
        buffers fill up but OS hasn't gotten any writes yet. We want to be as
        close as possible to every buffer (including OS buffers) being full.

        So, we wait a bit more after this for Twisted to write out a few
        chunks, then abortConnection.
        NTg{�G�z�?)r�r�r��doAbortrsrRrRrSr��
s
z&StreamingProducerClient.pauseProducingcCs.|jst�td��d|_|j��d|_dS)Nz&BUG: We should be paused a this point.TF)r�rr�r:r9r�r)rsrRrRrSrJ�
s

zStreamingProducerClient.doAbortcCs|jj��t�||�dSrQ)�
otherProtocolr�ZstartReadingrr�r�rRrRrSr��
sz&StreamingProducerClient.connectionLostN)ryrzr{r|r�ZextraWritesr9r�r�r�rr�rJr�rRrRrRrSrF�
s
rFc@s eZdZdZdd�Zdd�ZdS)�StreamingProducerClientLaterzX
    Call abortConnection() from dataReceived, after bytes have been
    exchanged.
    cCs|j�d�d|_dS)Nr4F)r�r�r5rsrRrRrSr��
sz+StreamingProducerClientLater.connectionMadecCs|jsd|_|��dSr6)r5r�rerRrRrSr��
sz)StreamingProducerClientLater.dataReceivedN�ryrzr{r|r�r�rRrRrRrSrL�
srLc@s eZdZdZdd�Zdd�ZdS)�ProducerAbortingClientLaterz�
    Call abortConnection from doWrite, via resumeProducing.

    Try to do so after some bytes have already been exchanged, so we
    don't interrupt SSL handshake.
    cCsdSrQrRrsrRrRrSr��
sz*ProducerAbortingClientLater.connectionMadecCs|��dSrQrDrerRrRrSr��
sz(ProducerAbortingClientLater.dataReceivedNrMrRrRrRrSrN�
srNc@seZdZdZdd�ZdS)�DataReceivedRaisingClientzN
    Call abortConnection(), and then throw exception, from dataReceived.
    cCs|j��td��dS)NZONO)r�r)�ZeroDivisionErrorrerRrRrSr��
s
z&DataReceivedRaisingClient.dataReceivedNr�rRrRrRrSrO�
srOc@s eZdZdZdd�Zdd�ZdS)�ResumeThrowsClientzL
    Call abortConnection() and throw exception from resumeProducing().
    cCs|js|j��td��dS)Nzono!)rCr�r)rPrsrRrRrSr�s
z"ResumeThrowsClient.resumeProducingcCst�||�dSrQ)rr�r�rRrRrSr�sz!ResumeThrowsClient.connectionLostN)ryrzr{r|r�r�rRrRrRrSrQ�
srQc@sveZdZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�ZdS)�AbortConnectionMixinz7
    Unit tests for L{ITransport.abortConnection}.
    Nc	Cs�ttf}ttf}tr,|tjf}|tjf}|�}|�}||_||_t||||j�}|�	|�
�g�|�	|��g�|dk	r�|�|j
j|f|�n|�|j
j|�|�|j
j|�dS)z�
        A test runner utility function, which hooks up a matched pair of client
        and server protocols.

        We then run the reactor until both sides have disconnected, and then
        verify that the right exception resulted.
        N)rrrr�rL�ErrorrKr!r�rr�ZgetDelayedCallsr�ZdisconnectReasonr�)	rfZclientClassZserverClass�clientConnectionLostReasonZclientExpectedExceptionsZserverExpectedExceptionsr^r�r�rRrRrS�runAbortTests*	�
�z!AbortConnectionMixin.runAbortTestcCs|�tt�S)z�
        abortConnection() is called in dataReceived. The protocol should be
        disconnected, but connectionLost should not be called re-entrantly.
        )rUr<r.rsrRrRrS�test_dataReceivedAbort;sz+AbortConnectionMixin.test_dataReceivedAbortcCs|�tt�S)z�
        abortConnection() is called twice by client.

        No exception should be thrown, and the connection will be closed.
        )rUr?r.rsrRrRrS� test_clientAbortsConnectionTwiceCsz5AbortConnectionMixin.test_clientAbortsConnectionTwicecCs|�tt�S)z�
        Client calls abortConnection(), followed by loseConnection().

        No exception should be thrown, and the connection will be closed.
        )rUrAr.rsrRrRrS�.test_clientAbortsConnectionThenLosesConnectionLs�zCAbortConnectionMixin.test_clientAbortsConnectionThenLosesConnectioncCs|jtttd�S)z�
        abortConnection() is called twice by server.

        No exception should be thrown, and the connection will be closed.
        �rT)rUr;r(rrsrRrRrS� test_serverAbortsConnectionTwiceVs�z5AbortConnectionMixin.test_serverAbortsConnectionTwicecCs|jtttd�S)z�
        Server calls abortConnection(), followed by loseConnection().

        No exception should be thrown, and the connection will be closed.
        rY)rUr;r*rrsrRrRrS�.test_serverAbortsConnectionThenLosesConnection`s�zCAbortConnectionMixin.test_serverAbortsConnectionThenLosesConnectioncCs|�tt�dS)z�
        abortConnection() is called in resumeProducing, before any bytes have
        been exchanged. The protocol should be disconnected, but
        connectionLost should not be called re-entrantly.
        N)rUrBrrsrRrRrS�test_resumeProducingAbortks�z.AbortConnectionMixin.test_resumeProducingAbortcCs|�tt�S)z�
        abortConnection() is called in resumeProducing, after some
        bytes have been exchanged. The protocol should be disconnected.
        )rUrNr+rsrRrRrS�test_resumeProducingAbortLaterus�z3AbortConnectionMixin.test_resumeProducingAbortLatercCs|�tt�dS)a{
        abortConnection() triggered by the write buffer being full.

        In particular, the server side stops reading. This is supposed
        to simulate a realistic timeout scenario where the client
        notices the server is no longer accepting data.

        The protocol should be disconnected, but connectionLost should not be
        called re-entrantly.
        N)rUrFr1rsrRrRrS�test_fullWriteBuffer~s�z)AbortConnectionMixin.test_fullWriteBuffercCs|�tt�S)z�
        abortConnection() is triggered by a write buffer being full.

        However, this buffer is filled after some bytes have been exchanged,
        allowing a TLS handshake if we're testing TLS. The connection will
        then be lost.
        )rUrLr3rsrRrRrS�%test_fullWriteBufferAfterByteExchange�s�z:AbortConnectionMixin.test_fullWriteBufferAfterByteExchangecCs.|jtttd�|�t�}|�t|�d�dS)aJ
        dataReceived calls abortConnection(), and then raises an exception.

        The connection will be lost, with the thrown exception
        (C{ZeroDivisionError}) as the reason on the client. The idea here is
        that bugs should not be masked by abortConnection, in particular
        unexpected exceptions.
        rYrwN)rUrOr+rP�flushLoggedErrorsrrn�rf�errorsrRrRrS�test_dataReceivedThrows�s	�
z,AbortConnectionMixin.test_dataReceivedThrowscCs.|jtttd�|�t�}|�t|�d�dS)aM
        resumeProducing calls abortConnection(), and then raises an exception.

        The connection will be lost, with the thrown exception
        (C{ZeroDivisionError}) as the reason on the client. The idea here is
        that bugs should not be masked by abortConnection, in particular
        unexpected exceptions.
        rYrwN)rUrQrrPr`rrnrarRrRrS�test_resumeProducingThrows�s	�
z/AbortConnectionMixin.test_resumeProducingThrows)N)ryrzr{r|r�rUrVrWrXrZr[r\r]r^r_rcrdrRrRrRrSrRs�
%	


	rRc@seZdZdZefZe�ZdS)�AbortConnectionTestsz5
    TCP-specific L{AbortConnectionMixin} tests.
    N)ryrzr{r|r+rr�r�rRrRrRrSre�srec@s>eZdZdZereZdd�Zdd�Ze�	�r2de_dd�Z
d	S)
�SimpleUtilityTestszJ
    Simple, direct tests for helpers within L{twisted.internet.tcp}.
    cCs*|�tjtdd�}|�|jdtj�dS)a
        L{_resolveIPv6} raises a L{socket.gaierror} (L{socket.EAI_NONAME}) when
        invoked with a non-numeric host.  (In other words, it is passing
        L{socket.AI_NUMERICHOST} to L{socket.getaddrinfo} and will not
        accidentally block if it receives bad input.)
        Z	localhostrwrN�rr[ZgaierrorrDrruZ
EAI_NONAME�rfr�rRrRrS�test_resolveNumericHost�sz*SimpleUtilityTests.test_resolveNumericHostcCs*|�tjtdd�}|�|jdtj�dS)a
        L{_resolveIPv6} raises a L{socket.gaierror} (L{socket.EAI_NONAME}) when
        invoked with a non-numeric port.  (In other words, it is passing
        L{socket.AI_NUMERICSERV} to L{socket.getaddrinfo} and will not
        accidentally block if it receives bad input.)
        rNZhttprNrgrhrRrRrS�test_resolveNumericService�sz-SimpleUtilityTests.test_resolveNumericServicez@The AI_NUMERICSERV flag is not supported by Microsoft providers.cCsZtdd�}|�t|�d�|�|dttf�|�|dttf�|�|dd�d�dS)zb
        L{_resolveIPv6} discovers the flow info and scope ID of an IPv6
        address.
        rNr�rZr�N)rNr�)rDrrnr��intrr�rRrRrS�test_resolveIPv6�s

z#SimpleUtilityTests.test_resolveIPv6N)ryrzr{r|r r�rirjrr�rlrRrRrRrSrf�s
rfc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�BuffersLogsTestsz$
    Tests for L{_BuffersLogs}.
    cCs"d|_g|_t|j|jj�|_dS)Nz
name.space)�	namespacer�r>rm�	logBufferrsrRrRrSr�szBuffersLogsTests.setUpc	Cs,|j�}|�d�|�|j�W5QRXdS)zj
        The context manager's logger does not log to provided observer
        inside the block.
        �An eventN)rorSr�r�)rf�loggerrRrRrS�test_buffersInBlocks
z$BuffersLogsTests.test_buffersInBlockc	Csh|j�}|�d�|�|j�W5QRX|�dt|j��|j\}|�|dd�|�|d|j�dS)zw
        The context manager flushes its buffered logs when the block
        terminates without an exception.
        rprw�
log_format�
log_namespaceN)rorSr�r�rrnrn)rfrq�eventrRrRrS�test_flushesOnExits
z#BuffersLogsTests.test_flushesOnExitc
Cs�Gdd�dt�}|�|��4|j�"}|�d�|�|j�|��W5QRXW5QRX|�dt|j��|j\}|�|dd�|�|d|j�dS)zz
        The context manager flushes its buffered logs when the block
        terminates because of an exception.
        c@seZdZdZdS)zGBuffersLogsTests.test_flushesOnExitWithException.<locals>.TestExceptionz@
            An exception only raised by this test.
            N�ryrzr{r|rRrRrRrS�
TestException#srxrprwrsrtN)	r�rrorSr�r�rrnrn)rfrxrqrurRrRrS�test_flushesOnExitWithExceptions
z0BuffersLogsTests.test_flushesOnExitWithExceptionN)ryrzr{r|r�rrrvryrRrRrRrSrm�s

rmc@sdeZdZdZeZdd�Zdd�Zdd�Zdd	�Z	d
d�Z
dd
�Zdd�Zdd�Z
dd�Zdd�ZdS)�FileDescriptorReservationTestsz2
    Tests for L{_FileDescriptorReservation}.
    cs*g�_����_�fdd�}t|��_dS)Ncs�j�t�jd���jdS)N�wr)�reservedFileObjectsrmr]�tempfilerRrsrRrS�fakeFileFactory?sz=FileDescriptorReservationTests.setUp.<locals>.fakeFileFactory)r|Zmktempr}r@�
reservedFD)rfr~rRrsrSr�;s
z$FileDescriptorReservationTests.setUpcCstt|j�dS)zi
        L{_FileDescriptorReservation} instances provide
        L{_IFileDescriptorReservation}.
        N)r	rArrsrRrRrSr`Fsz5FileDescriptorReservationTests.test_providesInterfacecCsR|�t|j�d�td�D]2}|j��|�t|j�d�|�|jdj�qdS)zh
        Multiple acquisitions without releases open the reservation
        file exactly once.
        rr�rwN)rrnr|rHr�reserver�r4)rfr(rRrRrS�test_reserveOpensFileOnceNs

z8FileDescriptorReservationTests.test_reserveOpensFileOncecCszt�}|�|j�|��|�|j���|j��|�|j���|�t	t
�}|�t|�d�|�|dj
jtj�dS)z�
        If reserving the file descriptor fails because of C{EMFILE},
        the exception is suppressed but logged and the reservation
        remains unavailable.
        rwrN)rFr<rCrAr�r�	availabler�r`rNrMrrnr�rOrP)rfr\rbrRrRrS�test_reserveEMFILELogged[s
z7FileDescriptorReservationTests.test_reserveEMFILELoggedcCs6tttfD]&}|fdd�}t|�}|�||j�q
dS)z�
        Any exception raised while opening the reserve file that is
        not an L{OSError} or L{IOError} whose errno is C{EMFILE} is
        allowed through to the caller.
        cSs|tjdd��dS)Nrwr�)rOrP)�
errorClassrRrRrS�	failsWithwszWFileDescriptorReservationTests.test_reserveRaisesNonEMFILEExceptions.<locals>.failsWithN)rNrMrr@rr�)rfr�r�Z	reserveFDrRrRrS�%test_reserveRaisesNonEMFILEExceptionsnszDFileDescriptorReservationTests.test_reserveRaisesNonEMFILEExceptionscCs.|�|j���|j��|�|j���dS)z]
        The reservation is available after the file descriptor is
        reserved.
        N)r�rr�r�r�rsrRrRrS�test_available~s
z-FileDescriptorReservationTests.test_availablec
Cs,|�t��|j�W5QRXW5QRXdS)zp
        A reservation without an open file used as a context manager
        raises a L{RuntimeError}.
        N)rr:rrsrRrRrS�test_enterFailsWithoutFile�sz9FileDescriptorReservationTests.test_enterFailsWithoutFilec	CsP|j��|�|j���|j�|�|j���W5QRX|�|j���dS)zq
        Entering a reservation closes its file for the duration of the
        context manager's block.
        N)rr�r�r�r�rsrRrRrS�!test_enterClosesFileExitOpensFile�s

z@FileDescriptorReservationTests.test_enterClosesFileExitOpensFilec
CsLGdd�dt�}|j��|�|��|j�|��W5QRXW5QRXdS)z�
        An exception raised within a reservation context manager's
        block does not prevent the file from being reopened.
        c@seZdZdZdS)zSFileDescriptorReservationTests.test_exitOpensFileOnException.<locals>.TestExceptionz>
            An exception only used by this test.
            NrwrRrRrRrSrx�srxN)r�rr�r)rfrxrRrRrS�test_exitOpensFileOnException�s

z<FileDescriptorReservationTests.test_exitOpensFileOnExceptionc
s�Gdd�dt�}Gdd�dt��dg���fdd�}t|�}|��|�|���|�|��|�|��W5QRXW5QRX|���}|�t|�d�d	S)
z�
        An exception raised while re-opening the reserve file exiting
        a reservation's context manager block is suppressed but
        logged, allowing an exception raised within the block through.
        c@seZdZdZdS)z`FileDescriptorReservationTests.test_exitSuppressesReservationException.<locals>.AllowedExceptionzA
            The exception allowed out of the block.
            NrwrRrRrRrS�AllowedException�sr�c@seZdZdZdS)zcFileDescriptorReservationTests.test_exitSuppressesReservationException.<locals>.SuppressedExceptionzM
            An exception raised by the file descriptor factory.
            NrwrRrRrRrS�SuppressedException�sr�Fcs$�dr���nd�d<t��SdS)NrT)�io�BytesIOrR�r�ZcalledrRrS�+failsWithSuppressedExceptionAfterSecondOpen�sz{FileDescriptorReservationTests.test_exitSuppressesReservationException.<locals>.failsWithSuppressedExceptionAfterSecondOpenrwN)	r�r@r�r�r�rr`rrn)rfr�r�rrbrRr�rS�'test_exitSuppressesReservationException�s�
zFFileDescriptorReservationTests.test_exitSuppressesReservationExceptionN)ryrzr{r|rtr�r�r`r�r�r�r�r�r�r�r�rRrRrRrSrz5s

	rzc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�"NullFileDescriptorReservationTestsz6
    Tests for L{_NullFileDescriptorReservation}.
    cCst�|_dSrQ)rB�nullReservedFDrsrRrRrSr��sz(NullFileDescriptorReservationTests.setUpcCstt|j�dS)zd
        L{_NullFileDescriptorReservation} provides
        L{_IFileDescriptorReservation}.
        N)r	rAr�rsrRrRrSr`�sz9NullFileDescriptorReservationTests.test_providesInterfacecCs|�|j���dS)zG
        The null reserved file descriptor is never available.
        N�r�r�r�rsrRrRrSr��sz1NullFileDescriptorReservationTests.test_availablec	CsF|�|j���|j�|�|j���W5QRX|�|j���dS)zN
        The null reserved file descriptor is a null context manager.
        Nr�rsrRrRrS�test_contextManager�sz6NullFileDescriptorReservationTests.test_contextManagerN)ryrzr{r|r�r`r�r�rRrRrRrSr��s
r�)�r|Z
__future__rrr+Z
__metaclass__rOrKr�rHr[�	functoolsrrZZzope.interfacerrZzope.interface.verifyrr	Ztwisted.loggerr
Ztwisted.python.compatrZtwisted.python.runtimerZtwisted.python.failurer
Ztwisted.pythonrZtwisted.trial.unittestrrrZtwisted.internet.errorrrrrrrrrrZ&twisted.internet.test.connectionmixinsrrrrrr r!r"r#Z#twisted.internet.test.reactormixinsr$r%r&Ztwisted.internet.interfacesr'r(r)r*r+r,r-Ztwisted.internet.addressr.r/Ztwisted.internet.deferr0r1r2r3r4r5Ztwisted.internet.endpointsr6r7Ztwisted.internet.protocolr8r9r:r;r<r=Ztwisted.internet.tcpr>r?r@rArBrCrDZtwisted.internet.test.test_corerEZtwisted.test.test_tcprFrGrHrIZtwisted.test.proto_helpersrJrKZOpenSSLrL�ImportErrorr�Ztwisted.internet.sslrM�sr!r�r�r�rVrr rtr�Ztwisted.internet.testrOZwin32GetLinkLocalIPv6AddressesrVrtrPZposixGetLinkLocalIPv6AddressesrWr]r�rbr}r�r�r�r�r�r�r�r�rrr"r:r;r?r@rFr[r|r}r�r�r�r�r�r�r�r�r�r�r�r�r�rrr&�globals�updateZmakeTestCaseClassesr(r*r+r.r1r3r8r;r<r?rArBrFrLrNrOrQrRrerfrmrzr�rRrRrRrS�<module>s8,,$ $	


@
2
72�
s FPQS"$3�� !#*F�0�?


#

'K,5:!