AnonSec Shell

Server IP : 209.38.156.173 / Your IP : 216.73.216.122 [ Reverse IP ]
Web Server : Apache/2.4.52 (Ubuntu)
System : Linux lakekumayuhotel 5.15.0-136-generic #147-Ubuntu SMP Sat Mar 15 15:53:30 UTC 2025 x86_64
User : root ( 0)
PHP Version : 8.1.2-1ubuntu2.22
Disable Function : NONE
Domains : 2 Domains
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON
Directory : /usr/lib/python3/dist-packages/twisted/internet/test/__pycache__/
Upload File :
[ HOME ] [ BACKUP SHELL ] [ JUMPING ] [ MASS DEFACE ] [ SCAN ROOT ] [ SYMLINK ]
Current File : /usr/lib/python3/dist-packages/twisted/internet/test/__pycache__/test_endpoints.cpython-310.pyc
o

�b�D�
@sRdZddlmZddlmZmZmZmZmZddl	m
Z
ddlmZddl
mZddlmZmZmZddlmZdd	lmZmZdd
lmZddlmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$dd
l%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4ddl5m6Z6m7Z7m8Z8ddl9m:Z:ddl;m<Z<ddl=m>Z?m@Z@mAZAmBZBddlCmDZDmEZEddlFmGZGddlHmIZImJZJddlKmLZLddlMmNZNddlOmPZPddlQmRZRddlSmTZTddlUmVZVddlWmXZXddlYmZZZm[Z[dd l\m
Z
eVd!�j]�^d"�Z_eVd!�j]�^d#�Z`eVd!�j]�^d$�ZaeVeb�j]�^d%�Zcec�dd&�Zee�fe_jg�Zhe�fe`jg�Zie�feajg�Zje�fecjg�Zke�feejg�Zlz:dd'lmmnZompZpmqZqmrZrdd(lsmtZtmuZumvZvmwZwmxZxdd)lymzZzdd*l{m|Z|et�}e_�~��Zex�}e_�~��Z�d+Z�d,Z�Wne��y�Z�zd-Z�e�e��Z�WYd.Z�[�nd.Z�[�wwGd/d0�d0e8�Z�eej��Gd1d2�d2e���Z�eej��Gd3d4�d4e���Z�eej��Gd5d6�d6e���Z�Gd7d8�d8e6�Z�Gd9d:�d:e6�Z�Gd;d<�d<e
j��Z�Gd=d>�d>�Z�Gd?d@�d@�Z�GdAdB�dBe�e��Z�GdCdD�dDe7�Z�GdEdF�dF�Z�GdGdH�dHe
j��Z�GdIdJ�dJej8�Z�eej��GdKdL�dLeB��Z�eej0e��eej2e��eej�e��eej��GdMdN�dN��Z�GdOdP�dPe
j��Z�GdQdR�dRe
j��Z�GdSdT�dTe
j��Z�GdUdV�dVe�e
j��Z�GdWdX�dXe�e
j��Z�GdYdZ�dZe�e
j��Z�Gd[d\�d\e@e<�Z�d�d^d_�Z�Gd`da�dae
j��Z�Gdbdc�dce
j��Z�Gddde�dee��Z�Gdfdg�dge�e
j��Z�Gdhdi�die�e
j��Z�Gdjdk�dke�e
j��Z�Gdldm�dme�e
j��Z�Gdndo�doe
j��Z�Gdpdq�dqe
j��Z�Gdrds�dse
j��Z�Gdtdu�due
j��Z�ee�e��Gdvdw�dwe�e
j���Z�Gdxdy�dye�e
j��Z�Gdzd{�d{e
j��Z�Gd|d}�d}e
j��Z�d�dd��Z�Gd�d��d�e
j��Z�ee�e��Gd�d��d�e
j���Z�Gd�d��d�e�e
j��Z�Gd�d��d�e
j��Z�Gd�d��d�e
j��Z�Gd�d��d�e
j��Z�Gd�d��d�e
j��Z�Gd�d��d�eJj��Z�Gd�d��d�eJj��Z�Gd�d��d�eIj��Z�Gd�d��d�eZ�Gd�d��d�e
j��Z�d�d��Z�ee�e��Gd�d��d�e
j���Z�d�d��Z�Gd�d��d�e
j��Z�d.S)�z�
Test the C{I...Endpoint} implementations that wrap the L{IReactorTCP},
L{IReactorSSL}, and L{IReactorUNIX} interfaces found in
L{twisted.internet.endpoints}.
�)�EPERM)�AF_INET�AF_INET6�IPPROTO_TCP�SOCK_STREAM�gaierror)�FunctionType)�	normalize)�skipIf)�implementer�
providedBy�provider)�InterfaceClass)�verifyClass�verifyObject)�plugins)�defer�	endpoints�error�
interfaces�protocol�reactor�stdio�threads)�
isIPv6Address)�HostnameAddress�IPv4Address�IPv6Address�UNIXAddress�_ProcessAddress)�StandardErrorBehavior)�ConnectingCancelledError)�	IConsumer�IHostnameResolver�
IPushProducer�IReactorPluggableNameResolver�
ITransport)�
ClientFactory�Factory�Protocol)�PipeAddress)�Clock)�MemoryReactorClock�RaisingMemoryReactor�StringTransport� StringTransportWithDisconnection)�ILogObserver�globalLogPublisher)�
getPlugins)�basic�policies)�log)�nativeString)�proxyForInterface)�Failure)�FilePath)�	getModule)�	ListenFDs)�connectableEndpoint�connectedServerAndClient)�unittestztwisted.testz
server.pemzkey.pem.no_trailing_newlinezcert.pem.no_trailing_newline�fake_CAsz	chain.pem)�Context�OP_NO_SSLv3�
SSLv23_METHOD�TLSv1_METHOD)�Certificate�CertificateOptions�DiffieHellmanParameters�KeyPair�PrivateCertificate��TLSMemoryBIOFactory)�makeCertificateF�TNc@�8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�TestProtocolzx
    Protocol whose only function is to callback deferreds on the
    factory when it is connected or disconnected.
    cCsg|_g|_d|_dS�Nr)�data�connectionsLost�connectionMadeCalls��self�rU�F/usr/lib/python3/dist-packages/twisted/internet/test/test_endpoints.py�__init__|s
zTestProtocol.__init__cCsdS)N�A Test ProtocolrUrSrUrUrV�	logPrefix��zTestProtocol.logPrefixcCs|jd7_dS�N�)rRrSrUrUrV�connectionMade��zTestProtocol.connectionMadecC�|j�|�dS�N)rP�append�rTrPrUrUrV�dataReceived��zTestProtocol.dataReceivedcCr_r`)rQra�rT�reasonrUrUrV�connectionLost�rdzTestProtocol.connectionLostN)	�__name__�
__module__�__qualname__�__doc__rWrYr]rcrgrUrUrUrVrNvsrNc@�(eZdZdZdd�Zdd�Zdd�ZdS)	�TestHalfCloseableProtocolab
    A Protocol that implements L{IHalfCloseableProtocol} and records whether
    its C{readConnectionLost} and {writeConnectionLost} methods are called.

    @ivar readLost: A C{bool} indicating whether C{readConnectionLost} has been
        called.

    @ivar writeLost: A C{bool} indicating whether C{writeConnectionLost} has
        been called.
    cCst�|�d|_d|_dS)NF)rNrW�readLost�	writeLostrSrUrUrVrW�s

z"TestHalfCloseableProtocol.__init__cC�
d|_dS�NT)rnrSrUrUrV�readConnectionLost��
z,TestHalfCloseableProtocol.readConnectionLostcCrprq)rorSrUrUrV�writeConnectionLost�rsz-TestHalfCloseableProtocol.writeConnectionLostN)rhrirjrkrWrrrtrUrUrUrVrm�s
rmc@� eZdZdZdd�Zdd�ZdS)�"TestFileDescriptorReceiverProtocola
    A Protocol that implements L{IFileDescriptorReceiver} and records how its
    C{fileDescriptorReceived} method is called.

    @ivar receivedDescriptors: A C{list} containing all of the file descriptors
        passed to C{fileDescriptorReceived} calls made on this instance.
    cCst�|�g|_dSr`)rNr]�receivedDescriptorsrSrUrUrVr]��

z1TestFileDescriptorReceiverProtocol.connectionMadecCr_r`)rwra)rT�
descriptorrUrUrV�fileDescriptorReceived�rdz9TestFileDescriptorReceiverProtocol.fileDescriptorReceivedN)rhrirjrkr]rzrUrUrUrVrv�srvc@ru)�TestHandshakeListenera
    A Protocol that implements L{IHandshakeListener} and records the
    number of times its C{handshakeCompleted} method has been called.

    @ivar handshakeCompletedCalls: The number of times
        C{handshakeCompleted}
    @type handshakeCompletedCalls: L{int}
    cCst�|�d|_dSrO)rNrW�handshakeCompletedCallsrSrUrUrVrW�rxzTestHandshakeListener.__init__cCs|jd7_dS)zk
        Called when a TLS handshake has completed.  Implemented per
        L{IHandshakeListener}
        r\N)r|rSrUrUrV�handshakeCompleted��z(TestHandshakeListener.handshakeCompletedN)rhrirjrkrWr}rUrUrUrVr{�s	r{c@�eZdZdZeZdS)�TestFactoryz�
    Simple factory to be used both when connecting and listening. It contains
    two deferreds which are called back when my protocol connects and
    disconnects.
    N)rhrirjrkrNrrUrUrUrVr��sr�c@�eZdZdZdd�ZdS)�NoneFactoryzC
    A one off factory whose C{buildProtocol} returns L{None}.
    cC�dSr`rU�rT�addrrUrUrV�
buildProtocol�rZzNoneFactory.buildProtocolN�rhrirjrkr�rUrUrUrVr���r�c@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,S)-�WrappingFactoryTestszS
    Test the behaviour of our ugly implementation detail C{_WrappingFactory}.
    cCs*t�}t�|�}|��|�d|j�dS)z�
        L{_WrappingFactory.doStart} passes through to the wrapped factory's
        C{doStart} method, allowing application-specific setup and logging.
        r\N)r'r�_WrappingFactory�doStart�assertEqual�numPorts�rT�factory�wfrUrUrV�test_doStart�s
z!WrappingFactoryTests.test_doStartcCs0t�}d|_t�|�}|��|�d|j�dS)z�
        L{_WrappingFactory.doStop} passes through to the wrapped factory's
        C{doStop} method, allowing application-specific cleanup and logging.
        ��N)r'r�rr��doStopr�r�rUrUrV�test_doStop�s

z WrappingFactoryTests.test_doStopcsJGdd�dt�}t�|��}|�d���|jt�}|��fdd��|S)z�
        An exception raised in C{buildProtocol} of our wrappedFactory
        results in our C{onConnection} errback being fired.
        c@r�)zCWrappingFactoryTests.test_failedBuildProtocol.<locals>.BogusFactoryzZ
            A one off factory whose C{buildProtocol} raises an C{Exception}.
            cSstd��)N�My protocol is poorly defined.)�
ValueErrorr�rUrUrVr�szQWrappingFactoryTests.test_failedBuildProtocol.<locals>.BogusFactory.buildProtocolNr�rUrUrUrV�BogusFactoryr�r�Ncs��|jd�S)N)r�)r��args)�erSrUrV�<lambda>sz?WrappingFactoryTests.test_failedBuildProtocol.<locals>.<lambda>)r'rr�r��
assertFailure�
_onConnectionr��addCallback)rTr�r��drUrSrV�test_failedBuildProtocol�s

�z-WrappingFactoryTests.test_failedBuildProtocolcCs*t�t��}|�d�|�|jtj�dS)z�
        If the wrapped factory's C{buildProtocol} returns L{None} the
        C{onConnection} errback fires with L{error.NoProtocol}.
        N)rr�r�r��failureResultOfr�r�
NoProtocol�rT�wrappingFactoryrUrUrV�test_buildNoneProtocols
z+WrappingFactoryTests.test_buildNoneProtocolcCs0t�t��}|j�dd��|�|�d��dS)z�
        If the wrapped factory's C{buildProtocol} returns L{None} then
        L{endpoints._WrappingFactory.buildProtocol} returns L{None}.
        cSr�r`rU�rfrUrUrVr�&�zDWrappingFactoryTests.test_buildProtocolReturnsNone.<locals>.<lambda>N)rr�r�r��
addErrback�assertIsNoner�r�rUrUrV�test_buildProtocolReturnsNonesz2WrappingFactoryTests.test_buildProtocolReturnsNonecCs*t�t��}|�d�}|�|��d�dS)z�
        If the wrapped protocol provides L{ILoggingContext}, whatever is
        returned from the wrapped C{logPrefix} method is returned from
        L{_WrappingProtocol.logPrefix}.
        NrX)rr�r�r�r�rY)rTr��wprUrUrV�test_logPrefixPassthrough*s
z.WrappingFactoryTests.test_logPrefixPassthroughcCsBGdd�d�}t�}||_t�|�}|�d�}|�|��d�dS)z�
        If the wrapped protocol does not provide L{ILoggingContext}, the
        wrapped protocol's class name is returned from
        L{_WrappingProtocol.logPrefix}.
        c@�eZdZdS)z>WrappingFactoryTests.test_logPrefixDefault.<locals>.NoProtocolN�rhrirjrUrUrUrVr�;sr�N)r�rrr�r�r�rY)rTr�r�r�r�rUrUrV�test_logPrefixDefault4s

z*WrappingFactoryTests.test_logPrefixDefaultcCs^t�t��}|�d�}|�d�|�d�|�|jjdg�|�d�|�|jjddg�dS)z�
        The wrapped C{Protocol}'s C{dataReceived} will get called when our
        C{_WrappingProtocol}'s C{dataReceived} gets called.
        Nsfoosbar)	rr�r�r��makeConnectionrcr��_wrappedProtocolrP)rTr��prUrUrV� test_wrappedProtocolDataReceivedDs



z5WrappingFactoryTests.test_wrappedProtocolDataReceivedcCsHt�t��}|�d�}t�}|�|�|�|j|�|�|jj|�dS)zo
        Our transport is properly hooked up to the wrappedProtocol when a
        connection is made.
        N)	rr�r�r��objectr�r��	transportr�)rTr�r��dummyTransportrUrUrV�test_wrappedProtocolTransportSs

z2WrappingFactoryTests.test_wrappedProtocolTransportcCs:t�}t�|�}|�d�}|�d�|�|jjdg�dS)z�
        Our wrappedProtocol's connectionLost method is called when
        L{_WrappingProtocol.connectionLost} is called.
        N�fail)r�rr�r�rgr�r�rQ)rT�tfr�r�rUrUrV�"test_wrappedProtocolConnectionLostcs



z7WrappingFactoryTests.test_wrappedProtocolConnectionLostcsVt�t��}ttjdd��}|�d|�g��fdd�}|j�|�|�	�|g�dS)z�
        Calls to L{_WrappingFactory.clientConnectionLost} should errback the
        L{_WrappingFactory._onConnection} L{Deferred}
        r���stringNc���|�dSr`�ra��f��errorsrUrV�gotError|�zBWrappingFactoryTests.test_clientConnectionFailed.<locals>.gotError)
rr�r�r8r�ConnectError�clientConnectionFailedr�r�r�)rTr��expectedFailurer�rUr�rV�test_clientConnectionFailedpsz0WrappingFactoryTests.test_clientConnectionFailedcCs>d}t�}t�||�}|�tj�|��|�ttj|��dS)zv
        Our L{_WrappingProtocol} should be an L{IFileDescriptorReceiver} if the
        wrapped protocol is.
        N)rvr�_WrappingProtocol�
assertTruer�IFileDescriptorReceiverrr)rT�connectedDeferred�applicationProtocol�wrapperrUrUrV�+test_wrappingProtocolFileDescriptorReceiver�s
z@WrappingFactoryTests.test_wrappingProtocolFileDescriptorReceivercC�(t�}t�d|�}|�tj�|��dS)z~
        Our L{_WrappingProtocol} does not provide L{IHalfCloseableProtocol} if
        the wrapped protocol doesn't.
        N)rNrr��assertFalserr�r�rT�tpr�rUrUrV�.test_wrappingProtocolNotFileDescriptorReceiver��zCWrappingFactoryTests.test_wrappingProtocolNotFileDescriptorReceivercCs@t�}t�t��|�}|�t��|�d�|�|j	dg�dS)z�
        L{_WrappingProtocol.fileDescriptorReceived} calls the wrapped
        protocol's C{fileDescriptorReceived} method.
        �*N)
rvrr�r�Deferredr�r.rzr�rw)rT�wrappedProtocolr�rUrUrV�*test_wrappedProtocolFileDescriptorReceived�s

z?WrappingFactoryTests.test_wrappedProtocolFileDescriptorReceivedcCs0t�}t�}t�||�}|�tj�|�d�dS)zw
        Our L{_WrappingProtocol} should be an L{IHalfCloseableProtocol} if the
        C{wrappedProtocol} is.
        TN)r�rmrr�r�r�IHalfCloseableProtocolr)rT�cd�hcpr�rUrUrV�"test_wrappingProtocolHalfCloseable�sz7WrappingFactoryTests.test_wrappingProtocolHalfCloseablecCs*t�}t�d|�}|�tj�|�d�dS)z�
        Our L{_WrappingProtocol} should not provide L{IHalfCloseableProtocol}
        if the C{WrappedProtocol} doesn't.
        NF)rNrr�r�rr�rr�rUrUrV�%test_wrappingProtocolNotHalfCloseable�sz:WrappingFactoryTests.test_wrappingProtocolNotHalfCloseablecCr�)zs
        Our L{_WrappingProtocol} should be an L{IHandshakeListener} if
        the C{wrappedProtocol} is.
        N)r{rr�r�r�IHandshakeListenerr)rT�handshakeListener�wrappedrUrUrV�&test_wrappingProtocolHandshakeListener�r�z;WrappingFactoryTests.test_wrappingProtocolHandshakeListenercCr�)z~
        Our L{_WrappingProtocol} should not provide L{IHandshakeListener}
        if the C{wrappedProtocol} doesn't.
        N)rNrr�r�rr�rr�rUrUrV�)test_wrappingProtocolNotHandshakeListener�r�z>WrappingFactoryTests.test_wrappingProtocolNotHandshakeListenercC�*t�}t�d|�}|��|�|j�dS)z~
        L{_WrappingProtocol.readConnectionLost} should proxy to the wrapped
        protocol's C{readConnectionLost}
        N)rmrr�rrr�rn�rTr�r�rUrUrV�&test_wrappedProtocolReadConnectionLost��z;WrappingFactoryTests.test_wrappedProtocolReadConnectionLostcCr�)z�
        L{_WrappingProtocol.writeConnectionLost} should proxy to the wrapped
        protocol's C{writeConnectionLost}
        N)rmrr�rtr�ror�rUrUrV�'test_wrappedProtocolWriteConnectionLost�r�z<WrappingFactoryTests.test_wrappedProtocolWriteConnectionLostcCs,t�}t�d|�}|��|�|jd�dS)z~
        L{_WrappingProtocol.handshakeCompleted} should proxy to the
        wrapped protocol's C{handshakeCompleted}
        Nr\)r{rr�r}r�r|)rT�listenerr�rUrUrV�&test_wrappedProtocolHandshakeCompleted�sz;WrappingFactoryTests.test_wrappedProtocolHandshakeCompletedN)rhrirjrkr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rUrUrUrVr��s.
	

	
			

r�c@�@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�ClientEndpointTestCaseMixin�Q
    Generic test methods to be mixed into all client endpoint test classes.
    cC�0t�}|�t�|�\}}}|�ttj|��dS)zK
        The endpoint provides L{interfaces.IStreamClientEndpoint}
        N)r��createClientEndpoint�
MemoryReactorr�rr�IStreamClientEndpoint)rT�
clientFactory�ep�ignoredArgs�addressrUrUrV�test_interface��

�z*ClientEndpointTestCaseMixin.test_interfacecC�|�|�ddS)z�
        Retrieve a single factory that has connected using the given reactor.
        (This behavior is valid for TCP and SSL but needs to be overridden for
        UNIX.)

        @param reactor: a L{MemoryReactor}
        rr���expectedClients�rTrrUrUrV�retrieveConnectedFactory�sz4ClientEndpointTestCaseMixin.retrieveConnectedFactorycs�t�}t�}t�}|�||�\}}}|�|�}g��fdd�}|�|�|�|�}	|	j�|�|��|g�|�	|�}
|�t
|
�d�|�|
d|�dS)z}
        A client endpoint can connect and returns a deferred who gets called
        back with a protocol instance.
        cr�r`r��r���receivedProtosrUrV�
checkProtor�zKClientEndpointTestCaseMixin.test_endpointConnectSuccess.<locals>.checkProtor\rN)r�r�r��connectr�r�r��callbackr�r��len�assertConnectArgs�rT�proto�mreactorr�r��expectedArgs�ignoredDestr�rr�r�rUr�rV�test_endpointConnectSuccess�s 
�



z7ClientEndpointTestCaseMixin.test_endpointConnectSuccessc	sdtjdd�}t|d�}t�}|�||�\}}}|�|�}g��fdd�}|�|�|��|g�dS)�t
        If an endpoint tries to connect to a non-listening port it gets
        a C{ConnectError} failure.
        �Connection Failedr���connectExceptionc���|j�dSr`�ra�valuer���receivedExceptionsrUrV�checkFailure2rdzMClientEndpointTestCaseMixin.test_endpointConnectFailure.<locals>.checkFailureN)rr�r-r�r�rr�r�)	rT�
expectedErrorrr�r�r�r	r�rrUrrV�test_endpointConnectFailures

�

z7ClientEndpointTestCaseMixin.test_endpointConnectFailurec
s�t�}t�}|�||�\}}}|�|�}g��fdd�}|�|�|��|�|�}|�dtt	�
���|�t��d��d}	|�
|	jt	j�|�|	jj|�dS)��
        Calling L{Deferred.cancel} on the L{Deferred} returned from
        L{IStreamClientEndpoint.connect} is errbacked with an expected
        L{ConnectingCancelledError} exception.
        cr�r`r�r���receivedFailuresrUrVrIr�zRClientEndpointTestCaseMixin.test_endpointConnectingCancelled.<locals>.checkFailureNr\r)r�r�r�rr��cancelr�r�r8r�	UserErrorr�r�assertIsInstancerr!r�)
rTrr�r�r�r�r�r�attemptFactory�failurerUrrV� test_endpointConnectingCancelled9s


z<ClientEndpointTestCaseMixin.test_endpointConnectingCancelledcCsbt�}t�}|j||fi|����\}}}|�|�|�|�}|�t|�d�|�|d|�dS)zn
        The endpoint should pass it's connectArgs parameter to the reactor's
        listen methods.
        r\rN)	r�r�r��connectArgsrr�r�rr)rTr�rr�r�ignoredHostr�rUrUrV�"test_endpointConnectNonDefaultArgs\s��

z>ClientEndpointTestCaseMixin.test_endpointConnectNonDefaultArgsN)
rhrirjrkr�r�r
rrr"rUrUrUrVr��s

 #r�c@�0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�ServerEndpointTestCaseMixinr�cCr�)zL
        The endpoint provides L{interfaces.IStreamServerEndpoint}.
        N)r��createServerEndpointr�r�rr�IStreamServerEndpoint)rTr�r�r�r	rUrUrVr�vr�z*ServerEndpointTestCaseMixin.test_interfacecsht�}t�}|�||�\}}}|�|�}g��fdd�}|�|�|��|g�|�|�|�|g�dS)zs
        An endpoint can listen and returns a deferred that gets called back
        with a port instance.
        cs��|���dSr`)ra�getHost)�port��
receivedHostsrUrV�checkPortAndServer�r^zRServerEndpointTestCaseMixin.test_endpointListenSuccess.<locals>.checkPortAndServerN)r�r�r%�listenr�r��expectedServers)rTrr�r�r�expectedHostr�r+rUr)rV�test_endpointListenSuccess�s

z6ServerEndpointTestCaseMixin.test_endpointListenSuccessc	sht�}t�dd|�}t|d�}|�||�\}}}|�t��}g��fdd�}|�|�|��|g�dS)z�
        When an endpoint tries to listen on an already listening port, a
        C{CannotListenError} failure is errbacked.
        rL�P)�listenExceptioncrr`rr�rrUrVr�rdzLServerEndpointTestCaseMixin.test_endpointListenFailure.<locals>.checkFailureN)r�r�CannotListenErrorr-r%r,r�r�)	rTr��	exceptionrr�r�r	r�rrUrrV�test_endpointListenFailure�s

z6ServerEndpointTestCaseMixin.test_endpointListenFailurecCsPt�}t�}|j||fi|����\}}}|�|�|�|�}|�||g�dS)zm
        The endpoint should pass it's listenArgs parameter to the reactor's
        listen methods.
        N)r�r�r%�
listenArgsr,r-r�)rTr�rr�rr!r-rUrUrV�!test_endpointListenNonDefaultArgs�s��

z=ServerEndpointTestCaseMixin.test_endpointListenNonDefaultArgsN)rhrirjrkr�r/r4r6rUrUrUrVr$qs
r$c@�eZdZdZdS)�EndpointTestCaseMixinzJ
    Generic test methods to be mixed into all endpoint test classes.
    N�rhrirjrkrUrUrUrVr8��r8c@ru)�SpecificFactoryz�
    An L{IProtocolFactory} whose C{buildProtocol} always returns its
    C{specificProtocol} and sets C{passedAddress}.

    Raising an exception if C{specificProtocol} has already been used.
    cCs
||_dSr`)�specificProtocol)rTr<rUrUrVrW�rszSpecificFactory.__init__cCs"t|jd�r
td��||j_|jS)N�
passedAddresszspecificProtocol already used.)�hasattrr<r�r=r�rUrUrVr��szSpecificFactory.buildProtocolN)rhrirjrkrWr�rUrUrUrVr;�sr;c@�eZdZdZddd�ZdS)�	FakeStdioz_
    A L{stdio.StandardIO} like object that simply captures its constructor
    arguments.
    NcCs||_||_dS)z�
        @param protocolInstance: like the first argument of L{stdio.StandardIO}

        @param reactor: like the reactor keyword argument of
            L{stdio.StandardIO}
        N)�protocolInstancer)rTrArrUrUrVrW�s
zFakeStdio.__init__r`�rhrirjrkrWrUrUrUrVr@�sr@c@rl)	�StandardIOEndpointsTestsz*
    Tests for Standard I/O Endpoints
    cCsNt�|_t�|j�}|�|jtj�t|_t	�|_
|�|�t
|j
���|_dS)z�
        Construct a L{StandardIOEndpoint} with a dummy reactor and a fake
        L{stdio.StandardIO} like object.  Listening on it with a
        L{SpecificFactory}.
        N)r�rr�StandardIOEndpoint�assertIs�_stdior�
StandardIOr@r)r<�successResultOfr,r;�	fakeStdio�rT�endpointrUrUrV�setUp�s
�zStandardIOEndpointsTests.setUpcCs(|�|jj|j�|�|jjjt�dS)z�
        L{StandardIOEndpoint} returns a L{Deferred} that fires with an instance
        of a L{stdio.StandardIO} like object that was passed the result of
        L{SpecificFactory.buildProtocol} which was passed a L{PipeAddress}.
        N)rErIrAr<rr=r*rSrUrUrV�test_protocolCreations
�z.StandardIOEndpointsTests.test_protocolCreationcCs|�|jj|j�dS)z�
        L{StandardIOEndpoint} passes its C{reactor} argument to the constructor
        of its L{stdio.StandardIO} like object.
        N)rErIrrSrUrUrV�test_passedReactor�z+StandardIOEndpointsTests.test_passedReactorN)rhrirjrkrLrMrNrUrUrUrVrC�s
rCc@ru)�StubApplicationProtocolz#
    An L{IProtocol} provider.
    cC�
||_dS)zY
        @param data: The data received by the protocol.
        @type data: str
        N)rPrbrUrUrVrc�
z$StubApplicationProtocol.dataReceivedcCrQ)zA
        @type reason: L{twisted.python.failure.Failure}
        Nr�rerUrUrVrg�
z&StubApplicationProtocol.connectionLostN)rhrirjrkrcrgrUrUrUrVrPsrPcsZeZdZdZd�fdd�	Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Z�ZS)�MemoryProcessTransportzC
    A fake L{IProcessTransport} provider to be used in tests.
    Ncs.t�jt�t�d�g|_t�|_t�|_dS)N)�hostAddress�peerAddress)�superrWr�signals�set�closedChildFDsr)r�rTr��	__class__rUrVrW,szMemoryProcessTransport.__init__cCs|dkr|�|�dSdSrO��write)rT�childFDrPrUrUrV�writeToChild2s�z#MemoryProcessTransport.writeToChildcC�|�d�dSrO��closeChildFDrSrUrUrV�
closeStdin6r�z!MemoryProcessTransport.closeStdincCrbr[rcrSrUrUrV�closeStdout9r�z"MemoryProcessTransport.closeStdoutcCrb)Nr�rcrSrUrUrV�closeStderr<r�z"MemoryProcessTransport.closeStderrcCr_r`)rZ�add)rT�fdrUrUrVrd?rdz#MemoryProcessTransport.closeChildFDcCr_r`)rXra)rT�signalrUrUrV�
signalProcessBrdz$MemoryProcessTransport.signalProcesscCr�r`rUrSrUrUrV�pidEszMemoryProcessTransport.pidr`)
rhrirjrkrWrarerfrgrdrkrl�
__classcell__rUrUr\rVrT&srTc@s(eZdZdZdidddddfdd�ZdS)�MemoryProcessReactorzA
    A fake L{IReactorProcess} provider to be used in tests.
    rUNrc

CsR||_||_||_||_||_||_||_||_|	|_t	�|_
|j�|j
�|j
S)z�
        @ivar processProtocol: Stores the protocol passed to the reactor.
        @return: An L{IProcessTransport} provider.
        )�processProtocol�
executabler��env�path�uid�gid�usePTY�childFDsrT�processTransportr�)
rTrorpr�rqrrrsrtrurvrUrUrV�spawnProcessUsz!MemoryProcessReactor.spawnProcess)rhrirjrkrxrUrUrUrVrnOs�rnc@�PeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�ProcessEndpointsTestsz,
    Tests for child process endpoints.
    cCs.t�|_t�|jd�|_t��|_t|j_dS�N�/bin/executable)	rnrr�ProcessEndpointr�rr(r�rPrSrUrUrVrLys
zProcessEndpointsTests.setUpcCs�|�|jjt�|�|jjd�|�|jjd�|�|jji�|�|jj	�|�|jj
�|�|jj�|�|jjd�|�|jj
�|�|jjtj�dS)zU
        Default values are set for the optional parameters in the endpoint.
        r|rUrN)rr��_reactorrnr��_executable�_args�_envr��_path�_uid�_gid�_usePTY�	_childFDs�_errFlagr �LOGrSrUrUrV�test_constructorDefaultssz.ProcessEndpointsTests.test_constructorDefaultscCs�ddi}t�t�ddgd|didddddd	d	d
�tj�
}|�|jt�|�|jd�|�|j	dg�|�|j
d|di�|�|jd�|�|jd�|�|j
d�|�|j�|�|jdd	d	d
��|�|jtj�dS)zI
        The parameters passed to the endpoint are stored in it.
        �HOMENr|�/runProcessHere/r\r�T�w�r�r���)rr}rnr �DROPrr~r�rr�r�r�r�r�r�r�r�r�)rT�environr�rUrUrV�test_constructorNonDefaults�s.

�
z1ProcessEndpointsTests.test_constructorNonDefaultscCs2|j�|j�}|�|�|jj}|�|tj�dS)z�
        The wrapper function _WrapIProtocol gives an IProcessProtocol
        implementation that wraps over an IProtocol.
        N)	r�rr�rHrrorr�_WrapIProtocol�rTr��wpprUrUrV�test_wrappedProtocol�s
z*ProcessEndpointsTests.test_wrappedProtocolcCs�ddi}t�}t�|ddgd|didddddd	d	d
��	}|�|j�}|�|�|�|jtj�|�	|j
|j�|�	|j|j
�|�	|j|j�|�	|j|j�|�	|j|j�|�	|j|j�|�	|j|j�|�	|j|j�dS)z�
        The parameters for spawnProcess stored in the endpoint are passed when
        the endpoint's connect method is invoked.
        r�Nr|r�r\r�Tr�r�r�)rnrr}rr�rHrror�r�rprr�r�rqr�rrr�rsr�rtr�rur�rvr�)rTr��
memoryReactorr�r�rUrUrV�test_spawnProcess�s0

�
z'ProcessEndpointsTests.test_spawnProcesscCs@Gdd�dtj�}|�}|j�|�}|�|�|�|jt�dS)zz
        The address passed to the factory's buildProtocol in the endpoint is a
        _ProcessAddress instance.
        c@seZdZeZdZdd�ZdS)zBProcessEndpointsTests.test_processAddress.<locals>.TestAddrFactoryNcSs||_|��}||_|Sr`)r�rr�)rTr�r�rUrUrVr��szPProcessEndpointsTests.test_processAddress.<locals>.TestAddrFactory.buildProtocol)rhrirjrPrr�r�rUrUrUrV�TestAddrFactory�sr�N)rr(r�rrHrr�r)rTr��	myFactoryr�rUrUrV�test_processAddress�s


z)ProcessEndpointsTests.test_processAddresscCs$|�|j�|j��}|�|t�dS)zd
        L{ProcessEndpoint.connect} returns a Deferred with the connected
        protocol.
        N)rHr�rr�rrP)rTrrUrUrV�test_connect�sz"ProcessEndpointsTests.test_connectcCs6dd�}||j_|j�|j�}|�|�}|�t�dS)zg
        In case of failure, L{ProcessEndpoint.connect} returns a Deferred that
        fails.
        c		Sst��r`)�	Exception)	�pprpr�rqrrrsrtrurvrUrUrV�testSpawnProcess�szCProcessEndpointsTests.test_connectFailure.<locals>.testSpawnProcessN)r��
_spawnProcessrr�r��trapr�)rTr�r�rrUrUrV�test_connectFailure�s

z)ProcessEndpointsTests.test_connectFailureN)rhrirjrkrLr�r�r�r�r�r�r�rUrUrUrVrzts
 rzc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"S)#�ProcessEndpointTransportTestsze
    Test the behaviour of the implementation detail
    L{endpoints._ProcessEndpointTransport}.
    cCsFt�|_t�|jd�|_|�|j�t�t	���}|jj
|_|j|_
dSr{)rnrrr}rKrHrr(�forProtocolr)rw�processr��endpointTransportr[rUrUrVrL	s�
z#ProcessEndpointTransportTests.setUpcC�tt|j�dS)zE
        L{_ProcessEndpointTransport}s provide L{IConsumer}.
        N)rr"r�rSrUrUrV�test_verifyConsumer�z1ProcessEndpointTransportTests.test_verifyConsumercCr�)zI
        L{_ProcessEndpointTransport}s provide L{IPushProducer}.
        N)rr$r�rSrUrUrV�test_verifyProducerr�z1ProcessEndpointTransportTests.test_verifyProducercCr�)zF
        L{_ProcessEndpointTransport}s provide L{ITransport}.
        N)rr&r�rSrUrUrV�test_verifyTransportr�z2ProcessEndpointTransportTests.test_verifyTransportcCs|�|jj|j�dS)zd
        The L{_ProcessEndpointTransport} instance stores the process passed to
        it.
        N)rEr��_processr�rSrUrUrV�test_constructor$rOz.ProcessEndpointTransportTests.test_constructorcCs>tt�Gdd�d��}|�}|j�|d�|�|jj|�dS)z�
        Registering a producer with the endpoint transport registers it with
        the underlying process transport.
        c@r�)zFProcessEndpointTransportTests.test_registerProducer.<locals>.AProducerNr�rUrUrUrV�	AProducer1sr�FN)rr$r��registerProducerrEr��producer)rTr��	aProducerrUrUrV�test_registerProducer+s
z3ProcessEndpointTransportTests.test_registerProducercC�|j��|�|jjd�dS)zY
        Pausing the endpoint transport pauses the underlying process transport.
        �pausedN)r��pauseProducingr�r��
producerStaterSrUrUrV�test_pauseProducing9s
z1ProcessEndpointTransportTests.test_pauseProducingcCs&|��|j��|�|jjd�dS)zc
        Resuming the endpoint transport resumes the underlying process
        transport.
        �	producingN)r�r��resumeProducingr�r�r�rSrUrUrV�test_resumeProducing@s
z2ProcessEndpointTransportTests.test_resumeProducingcCr�)zo
        Stopping the endpoint transport as a producer stops the underlying
        process transport.
        �stoppedN)r��
stopProducingr�r�r�rSrUrUrV�test_stopProducingIs
z0ProcessEndpointTransportTests.test_stopProducingcCs$|��|j��|�|jj�dS)z�
        Unregistring the endpoint transport's producer unregisters the
        underlying process transport's producer.
        N)r�r��unregisterProducerr�r�r�rSrUrUrV�test_unregisterProducerQs
z5ProcessEndpointTransportTests.test_unregisterProducercCsg|j_|�tt|jd�dS)z�
        L{endpoints._ProcessEndpointTransport} filters out extraneous
        attributes of its underlying transport, to present a more consistent
        cross-platform view of subprocesses and prevent accidental
        dependencies.
        �pipesN)r�r��assertRaises�AttributeError�getattrr�rSrUrUrV�test_extraneousAttributesZsz7ProcessEndpointTransportTests.test_extraneousAttributescCs(|j�gd��|�|jj��d�dS)z�
        The writeSequence method of L{_ProcessEndpointTransport} writes a list
        of string passed to it to the transport's stdin.
        )stest1stest2stest3stest1test2test3N)r��
writeSequencer�r��io�getvaluerSrUrUrV�test_writeSequencedsz0ProcessEndpointTransportTests.test_writeSequencecCs$|j�d�|�|jj��d�dS)z�
        The write method of L{_ProcessEndpointTransport} writes a string of
        data passed to it to the child process's stdin.
        stestN)r�r_r�r�r�r�rSrUrUrV�
test_writelsz(ProcessEndpointTransportTests.test_writecCs|j��|�|jj�dS)z�
        A call to the loseConnection method of a L{_ProcessEndpointTransport}
        instance returns a call to the process transport's loseConnection.
        N)r��loseConnectionr�r��	connectedrSrUrUrV�test_loseConnectionts
z1ProcessEndpointTransportTests.test_loseConnectioncC�,|j��}|�|t�|�||j���dS)z�
        L{_ProcessEndpointTransport.getHost} returns a L{_ProcessAddress}
        instance matching the process C{getHost}.
        N)r�r'rrrEr�)rT�hostrUrUrV�test_getHost|�
z*ProcessEndpointTransportTests.test_getHostcCr�)z�
        L{_ProcessEndpointTransport.getPeer} returns a L{_ProcessAddress}
        instance matching the process C{getPeer}.
        N)r��getPeerrrrEr�)rT�peerrUrUrV�test_getPeer�r�z*ProcessEndpointTransportTests.test_getPeerN)rhrirjrkrLr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rUrUrUrVr�s$			
	r�c@sXeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�ZdS)�WrappedIProtocolTestszL
    Test the behaviour of the implementation detail C{_WrapIProtocol}.
    cCs4t�|_t�|jd�|_d|_t��|_t	|j_dSr{)
rnrrr}r��eventLogrr(r�rPrSrUrUrVrL�s

zWrappedIProtocolTests.setUpcCsD|j�|j�}|�|�|jj}|�|jt�|�	|j
|jj�dS)zQ
        Stores an L{IProtocol} provider and the flag to log/drop stderr
        N)r�rr�rHrrorrrPr��errFlagr�r�rUrUrVr��s

z&WrappedIProtocolTests.test_constructorcCs6|j�|j�}|�|�|jj}|�|jj|j�dS)zx
        Our process transport is properly hooked up to the wrappedIProtocol
        when a connection is made.
        N)	r�rr�rHrror�rr�r�rUrUrV�test_makeConnection�s
z)WrappedIProtocolTests.test_makeConnectioncCrQ)z!
        A log observer.
        N)r�)rT�	eventDictrUrUrV�_stdLog�rSzWrappedIProtocolTests._stdLogcCs�|j�|j�}|�|�|jj}t�|j�|�	tj
|j�|�dd�|�|j
d|j�|�|j
dd�|�|j
d|j�|�dt�|j
��dS)z�
        When the _errFlag is set to L{StandardErrorBehavior.LOG},
        L{endpoints._WrapIProtocol} logs stderr (in childDataReceived).
        r�sstderr1rprPrzwrote stderr unhandled byN)r�rr�rHrror5�addObserverr��
addCleanup�removeObserver�childDataReceivedr�r�rpr�assertIn�textFromEventDictr�rUrUrV�test_logStderr�s
z$WrappedIProtocolTests.test_logStderrcCsbtj|j_|j�|j�}|�|�|jj}t	�
|j�|�t	j
|j�|�dd�|�|j�dS)z�
        When the _errFlag is set to L{StandardErrorBehavior.DROP},
        L{endpoints._WrapIProtocol} ignores stderr.
        r�sstderr2N)r r�r�r�rr�rHrror5r�r�r�r�r�r�r�r�rUrUrV�test_stderrSkip�s

z%WrappedIProtocolTests.test_stderrSkipcCs@|j�|j�}|�|�|jj}|�dd�|�|jj	d�dS)z�
        In childDataReceived of L{_WrappedIProtocol} instance, the protocol's
        dataReceived is called when stdout is generated.
        r\sstdoutN)
r�rr�rHrror�r�rrPr�rUrUrV�test_stdout�s

z!WrappedIProtocolTests.test_stdoutcCsR|j�|j�}|�|�|jj}|�tt�	d���|�
|jj�
tj�tj�dS)z�
        L{error.ProcessDone} with status=0 is turned into a clean disconnect
        type, i.e. L{error.ConnectionDone}.
        rN)r�rr�rHrro�processEndedr8r�ProcessDoner�rrf�check�ConnectionDoner�rUrUrV�test_processDone�s
�z&WrappedIProtocolTests.test_processDonecCsP|j�|j�}|�|�|jj}|�tt�	���|�
|jj�
tj�tj�dS)z{
        Exceptions other than L{error.ProcessDone} with status=0 are turned
        into L{error.ConnectionLost}.
        N)r�rr�rHrror�r8r�ProcessTerminatedr�rrfr��ConnectionLostr�rUrUrV�test_processEnded�s
�z'WrappedIProtocolTests.test_processEndedN)
rhrirjrkrLr�r�r�r�r�r�r�r�rUrUrUrVr��s

r�c@�HeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dS)�TCP4EndpointsTestsz'
    Tests for TCP IPv4 Endpoints.
    cC�|jS�zD
        @return: List of calls to L{IReactorTCP.listenTCP}
        ��
tcpServersr�rUrUrVr-�z"TCP4EndpointsTests.expectedServerscCr��zE
        @return: List of calls to L{IReactorTCP.connectTCP}
        ��
tcpClientsr�rUrUrVr�	r�z"TCP4EndpointsTests.expectedClientsc
C�P|\}}}}}|\}}	}
}}|�||�|�||	�|�||�|�||�dS�a]
        Compare host, port, timeout, and bindAddress in C{receivedArgs}
        to C{expectedArgs}.  We ignore the factory because we don't
        only care what protocol comes out of the
        C{IStreamClientEndpoint.connect} call.

        @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory},
            C{timeout}, C{bindAddress}) that was passed to
            L{IReactorTCP.connectTCP}.
        @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory},
            C{timeout}, C{bindAddress}) that we expect to have been passed
            to L{IReactorTCP.connectTCP}.
        N�r��
rT�receivedArgsrr�r(�ignoredFactory�timeout�bindAddressr.�expectedPort�_ignoredFactory�expectedTimeout�expectedBindAddressrUrUrVr��z$TCP4EndpointsTests.assertConnectArgscC�
ddd�S��K
        @return: C{dict} of keyword arguments to pass to connect.
        �
��	localhosti���r�r�rUrSrUrUrVr +rSzTCP4EndpointsTests.connectArgscCr��I
        @return: C{dict} of keyword arguments to pass to listen
        �d�	127.0.0.1��backlog�	interfacerUrSrUrUrVr51rSzTCP4EndpointsTests.listenArgscKsBtddd�}tj||jfi|��|j||�dd�|�dd�f|fS)a�
        Create an L{TCP4ServerEndpoint} and return the values needed to verify
        its behaviour.

        @param reactor: A fake L{IReactorTCP} that L{TCP4ServerEndpoint} can
            call L{IReactorTCP.listenTCP} on.
        @param factory: The thing that we expect to be passed to our
            L{IStreamServerEndpoint.listen} implementation.
        @param listenArgs: Optional dictionary of arguments to
            L{IReactorTCP.listenTCP}.
        �TCP�0.0.0.0rr�2rrL)rr�TCP4ServerEndpointr(�get�rTrr�r5r�rUrUrVr%7�

��z'TCP4EndpointsTests.createServerEndpointc	K�Jtddd�}tj||j|jfi|��|j|j||�dd�|�dd�f|fS)a�
        Create an L{TCP4ClientEndpoint} and return the values needed to verify
        its behavior.

        @param reactor: A fake L{IReactorTCP} that L{TCP4ClientEndpoint} can
            call L{IReactorTCP.connectTCP} on.
        @param clientFactory: The thing that we expect to be passed to our
            L{IStreamClientEndpoint.connect} implementation.
        @param connectArgs: Optional dictionary of arguments to
            L{IReactorTCP.connectTCP}
        rrr0r��r�N)rr�TCP4ClientEndpointr�r(r�rTrr�r r�rUrUrVr�P�
��

��z'TCP4EndpointsTests.createClientEndpointN�rhrirjrkr-r�rr r5r%r�rUrUrUrVr��sr�c@r�)�TCP6EndpointsTestsz'
    Tests for TCP IPv6 Endpoints.
    cCr�r�r�r�rUrUrVr-rr�z"TCP6EndpointsTests.expectedServerscCr�r�r�r�rUrUrVr�xr�z"TCP6EndpointsTests.expectedClientsc
Cr�r�r�r�rUrUrVr~rz$TCP6EndpointsTests.assertConnectArgscCrrrUrSrUrUrVr �rSzTCP6EndpointsTests.connectArgscCr)rr�::1rrUrSrUrUrVr5�rSzTCP6EndpointsTests.listenArgscKsF|�dd�}td|d�}tj||jfi|��|j||�dd�|f|fS)a�
        Create a L{TCP6ServerEndpoint} and return the values needed to verify
        its behaviour.

        @param reactor: A fake L{IReactorTCP} that L{TCP6ServerEndpoint} can
            call L{IReactorTCP.listenTCP} on.
        @param factory: The thing that we expect to be passed to our
            L{IStreamServerEndpoint.listen} implementation.
        @param listenArgs: Optional dictionary of arguments to
            L{IReactorTCP.listenTCP}.
        rz::rrrr)rrr�TCP6ServerEndpointr()rTrr�r5rr�rUrUrVr%�s�z'TCP6EndpointsTests.createServerEndpointc	Kr)��
        Create a L{TCP6ClientEndpoint} and return the values needed to verify
        its behavior.

        @param reactor: A fake L{IReactorTCP} that L{TCP6ClientEndpoint} can
            call L{IReactorTCP.connectTCP} on.
        @param clientFactory: The thing that we expect to be passed to our
            L{IStreamClientEndpoint.connect} implementation.
        @param connectArgs: Optional dictionary of arguments to
            L{IReactorTCP.connectTCP}
        rrr0r�rr�N)rr�TCP6ClientEndpointr�r(rrrUrUrVr��rz'TCP6EndpointsTests.createClientEndpointNrrUrUrUrVrmsrc@r�)�TCP6EndpointNameResolutionTestszl
    Tests for a TCP IPv6 Client Endpoint pointed at a hostname instead
    of an IPv6 address literal.
    c	sdtddd�}tj|d|jfi|���_�fdd�}|�j_�j|j|j||�dd�|�d	d
�f|fS)r!r�::2r0�ipv6.example.comcs>��d|�tttddftttddftttddfg}t�|�S)Nr%rL)r$rrr)z::3rrr)z::4rrr)r�rrrr�succeed)r�rPrSrUrV�testNameResolution�s�
zPTCP6EndpointNameResolutionTests.createClientEndpoint.<locals>.testNameResolutionr�rr�N)rrr"r(r��_nameResolutionr�r)rTrr�r r�r'rUrSrVr��s"��	

��z4TCP6EndpointNameResolutionTests.createClientEndpointcCrrrUrSrUrUrVr rSz+TCP6EndpointNameResolutionTests.connectArgscCr�r�r�r�rUrUrVr�r�z/TCP6EndpointNameResolutionTests.expectedClientsc
Cr�r�r�r�rUrUrVrrz1TCP6EndpointNameResolutionTests.assertConnectArgscCs"t�ddd�}|�|jtj�dS)zg
        By default, L{TCP6ClientEndpoint._deferToThread} is
        L{threads.deferToThread}.
        Nzwww.example.com��)rr"r��_deferToThreadr�
deferToThread�rTr�rUrUrV�test_freeFunctionDeferToThread.sz>TCP6EndpointNameResolutionTests.test_freeFunctionDeferToThreadcsZg��fdd�}t�tdd�}t�}||_||_|�t��|�|ddt	fifg��dS)zl
        While resolving hostnames, _nameResolution calls
        _deferToThread with _getaddrinfo.
        cs��|||f�t��Sr`)rarr�)r�r��kwargs��callsrUrV�fakeDeferToThread=szNTCP6EndpointNameResolutionTests.test_nameResolution.<locals>.fakeDeferToThreadr%r)rN)
rr"rr��_getaddrinfor*rr�r�r)rTr1rK�fakegetaddrinforUr/rV�test_nameResolution6s�z3TCP6EndpointNameResolutionTests.test_nameResolutionN)
rhrirjrkr�r r�rr-r4rUrUrUrVr#�s(r#c@r?)�RaisingMemoryReactorWithClockzE
    An extension of L{RaisingMemoryReactor} with L{task.Clock}.
    NcCst�|�t�|||�dSr`)r+rWr-)rTr1rrUrUrVrWPs
z&RaisingMemoryReactorWithClock.__init__)NNrBrUrUrUrVr5Ksr5rUc
sf�duri�����tt�G��fdd�d���tt�G�fdd�dttdtt|������}||�S)ap
    Create a reactor that will deterministically resolve all hostnames it is
    passed to the list of addresses given.

    @param reactor: An object that we wish to add an
        L{IReactorPluggableNameResolver} to.
    @type reactor: Any object with some formally-declared interfaces (i.e. one
        where C{list(providedBy(reactor))} is not empty); usually C{IReactor*}
        interfaces.

    @param expectedAddresses: (optional); the addresses expected to be returned
        for every address.  If these are strings, they should be IPv4 or IPv6
        literals, and they will be wrapped in L{IPv4Address} and L{IPv6Address}
        objects in the resolution result.
    @type expectedAddresses: iterable of C{object} or C{str}

    @param hostMap: (optional); the names (unicode) mapped to lists of
        addresses (str or L{IAddress}); in the same format as expectedAddress,
        which map the results for I{specific} hostnames to addresses.

    @return: A new reactor which provides all the interfaces previously
        provided by C{reactor} as well as L{IReactorPluggableNameResolver}.
        All name resolutions performed with its C{nameResolver} attribute will
        resolve reentrantly and synchronously with the given
        C{expectedAddresses}.  However, it is not a complete implementation as
        it does not have an C{installNameResolver} method.
    Ncs&eZdZe			d��fdd�	�ZdS)z9deterministicResolvingReactor.<locals>.SimpleNameResolverrNrcsT|�d���|��D]}t|t�rttgt|�d||�}|�|�q|��dS)Nr)	�resolutionBeganr�
isinstance�strrrr�addressResolved�resolutionComplete)�resolutionReceiver�hostName�
portNumber�addressTypes�transportSemantics�expectedAddress��expectedAddresses�hostMaprUrV�resolveHostNamews

��zIdeterministicResolvingReactor.<locals>.SimpleNameResolver.resolveHostName)rNr)rhrirj�staticmethodrDrUrArUrV�SimpleNameResolverus�rFcseZdZ��ZdS)z3deterministicResolvingReactor.<locals>.WithResolverN)rhrirj�nameResolverrU)rFrUrV�WithResolver�s
rH�*)�copyrr#r%r7r�tupler)rrBrCrHrU)rFrBrCrV�deterministicResolvingReactorUs�rLc@rM)
�SimpleHostnameResolverTestsa�
    Tests for L{endpoints._SimpleHostnameResolver}.

    @ivar fakeResolverCalls: Arguments with which L{fakeResolver} was
        called.
    @type fakeResolverCalls: L{list} of C{(hostName, port)} L{tuple}s.

    @ivar fakeResolverReturns: The return value of L{fakeResolver}.
    @type fakeResolverReturns: L{Deferred}

    @ivar resolver: The instance to test.
    @type resolver: L{endpoints._SimpleHostnameResolver}

    @ivar resolutionBeganCalls: Arguments with which receiver's
        C{resolutionBegan} method was called.
    @type resolutionBeganCalls: L{list}

    @ivar addressResolved: Arguments with which C{addressResolved} was
        called.
    @type addressResolved: L{list}

    @ivar resolutionCompleteCallCount: The number of calls to the
        receiver's C{resolutionComplete} method.
    @type resolutionCompleteCallCount: L{int}

    @ivar receiver: A L{interfaces.IResolutionReceiver} provider.
    csVg�_t���_t��j��_g�_g�_	d�_
ttj
�G�fdd�d��}|�_dS)Nrcs<eZdZe�fdd��Ze�fdd��Ze�fdd��ZdS)z4SimpleHostnameResolverTests.setUp.<locals>._Receiverc��j�|�dSr`)�resolutionBeganCallsra)�resolutionInProgressrSrUrVr6��zDSimpleHostnameResolverTests.setUp.<locals>._Receiver.resolutionBegancrNr`)�addressResolvedCallsra)r�rSrUrVr9�rQzDSimpleHostnameResolverTests.setUp.<locals>._Receiver.addressResolvedcs�jd7_dSr[)�resolutionCompleteCallCountrUrSrUrVr:�szGSimpleHostnameResolverTests.setUp.<locals>._Receiver.resolutionCompleteN)rhrirjrEr6r9r:rUrSrUrV�	_Receiver�srT)�fakeResolverCallsrr��fakeResolverReturnsr�_SimpleHostnameResolver�fakeResolver�resolverrOrRrSr
r�IResolutionReceiver�receiver)rTrTrUrSrVrL�s


z!SimpleHostnameResolverTests.setUpcCs|j�||f�|jS)z�
        A fake resolver callable.

        @param hostName: The hostname to resolve.

        @param portNumber: The port number the returned address should
            include.

        @return: L{fakeResolverCalls}
        @rtype: L{Deferred}
        )rUrarV)rTr<r=rUrUrVrX�sz(SimpleHostnameResolverTests.fakeResolvercCs|�ttj|j��dS)zs
        A L{endpoints._SimpleHostnameResolver} instance provides
        L{interfaces.IHostnameResolver}.
        N)r�rrr#rYrSrUrUrVr���z*SimpleHostnameResolverTests.test_interfacecs
g�tt��fdd���t���|��fdd��|j�|jd�}|�||j�|j	�
t��|�dt
���|�dt
|�t����\}|�|�d��|�|�dd��|�|�d	t|j���|�dt
|j��|�|jd
jd�|�|j�|�d|j�dS)z�
        A resolution failure is logged with the name that failed to
        resolve and the callable that tried to resolve it.  The
        resolution receiver begins, receives no addresses, and
        completes.
        cr�r`r�)�event)�logsrUrV�captureLogs�szHSimpleHostnameResolverTests.test_resolveNameFailure.<locals>.captureLogscs
t���Sr`)r1r�rU)r_rUrVr��s
zESimpleHostnameResolverTests.test_resolveNameFailure.<locals>.<lambda>�example.comr\�isError�name�callablerN)r
r0r1r�r�rYrDr[rErV�errbackr�r�r�flushLoggedErrorsr�r�reprrXrOrbr�rRrS)rTr[r]rU)r_r^rV�test_resolveNameFailure�s$
z3SimpleHostnameResolverTests.test_resolveNameFailurec	Cs�d}d}d}|j�|jd�}|�||j�|j�tttd||fft	ttd||ffg�|�
dt|j��|�
|jdj
d�|�
|jtd||�td||�g�|�
|jd�d	S)
zs
        The resolution receiver begins, and resolved hostnames are
        delivered before it completes.
        r0�1.2.3.4z
1::2::3::4r`rLr\rrN)rYrDr[rErVrrrrrr�rrOrbrRrrrS)rTr(�ipv4Host�ipv6Hostr[rUrUrV�test_resolveNameDeliverss"���z4SimpleHostnameResolverTests.test_resolveNameDeliversN)	rhrirjrkrLrXr�rgrkrUrUrUrVrM�s#rMc@r�)�+HostnameEndpointFallbackNameResolutionTestszd
    L{HostnameEndpoint._fallbackNameResolution} defers a name
    resolution call to a thread.
    csJddlm}tj|ddd�}d\��|����}���fdd�}|�|�S)z�
        L{_fallbackNameResolution} returns a L{Deferred} that fires
        with the resoution of the the host and request port.
        r)r�ignored)r�r()rhr\csL��t|�d�|\\}}}}}��|t���|t���|��f�dSr[)r�rrr)�result�family�socktype�_�sockaddr�r�r(rTrUrV�assertHostPortFamilySockType0s
zmHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolution.<locals>.assertHostPortFamilySockType)�twisted.internetrr�HostnameEndpoint�_fallbackNameResolutionr�)rTrr��resolutionDeferredrtrUrsrV�test_fallbackNameResolution#s
zGHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolutionN)rhrirjrkryrUrUrUrVrl�rlc@r�)�#_HostnameEndpointMemoryReactorMixinz�
    Common methods for testing L{HostnameEndpoint} against
    L{MemoryReactor} instances that do not provide
    L{IReactorPluggableNameResolver}.
    cOs8z	||i|��}Wn
tyt��YSwt�|�S)a�
        A synchronous version of L{deferToThread}.

        @param f: The callable to invoke.
        @type f: L{callable}

        @param args: Positional arguments to the callable.

        @param kwargs: Keyword arguments to the callable.

        @return: A L{Deferred} that fires with the result of applying
            C{f} to C{args} and C{kwargs} or the exception raised.
        )�
BaseExceptionrr�r&)rTr�r�r.rnrUrUrV�synchronousDeferredToThreadAs�
z?_HostnameEndpointMemoryReactorMixin.synchronousDeferredToThreadcCr�)z�
        Extract expected clients from the reactor.

        @param reactor: The L{MemoryReactor} under test.

        @return: List of calls to L{IReactorTCP.connectTCP}
        r�r�rUrUrVr�Vsz3_HostnameEndpointMemoryReactorMixin.expectedClientscCr)zL

        @return: C{dict} of keyword arguments to pass to connect.
        g$@rr	rUrSrUrUrVr `rRz/_HostnameEndpointMemoryReactorMixin.connectArgsc
Cr�r�r�r�rUrUrVrgrz5_HostnameEndpointMemoryReactorMixin.assertConnectArgscC�ntjdd�}t|d�}t�}|�||�\}}}|�|�}|�tjj	�|�
|�|�j|�|�
g|�
��dS)z�
        When L{HostnameEndpoint.connect} cannot connect to its
        destination, the returned L{Deferred} will fail with
        C{ConnectError}.
        rr�r
N�rr�r5r�r�r�advancerrv�_DEFAULT_ATTEMPT_DELAYr�r�r�getDelayedCalls�rTrrr�r�r�r	r�rUrUrVr��

�
z?_HostnameEndpointMemoryReactorMixin.test_endpointConnectFailurecCs`t�}t�}|�||�|��}|�dt|��|�t|dd�|�|dd�	d��dS)z�
        Instantiating L{HostnameEndpoint} with a reactor that does not
        provide L{IReactorPluggableResolver} emits a deprecation warning.
        r\r�category�messagez�Passing HostnameEndpoint a reactor that does not provide IReactorPluggableNameResolver (twisted.internet.testing.MemoryReactorClock) was deprecated in Twisted 17.5.0; please use a reactor that provides IReactorPluggableNameResolver insteadN)
r�r�r��
flushWarningsr�rrE�DeprecationWarningr��
startswith)rTrr��warningsrUrUrV�test_deprecation�s��z4_HostnameEndpointMemoryReactorMixin.test_deprecationcCsft�}t�}|�||�\}}}dd�}||_|�|�}|�|�|�jtj	�|�
dt|�t
���dS)z8
        Hostname resolution errors are logged.
        c_s
tdd��)N���z#No address associated with hostname)r)r�r.rUrUrV�getaddrinfoThatFails�rszS_HostnameEndpointMemoryReactorMixin.test_errorsLogged.<locals>.getaddrinfoThatFailsr\N)r�r�r�r2rrr�rr�DNSLookupErrorr�rrer)rTrr�r�r�r	r�r�rUrUrV�test_errorsLogged�s
�
z5_HostnameEndpointMemoryReactorMixin.test_errorsLoggedN)rhrirjrkr}r�r rrr�r�rUrUrUrVr{:s
r{c@r�)�&HostnameEndpointMemoryIPv4ReactorTestsz�
    IPv4 resolution tests for L{HostnameEndpoint} with
    L{MemoryReactor} subclasses that do not provide
    L{IReactorPluggableNameResolver}.
    c	�fd�tdd�}tj|d|jfi|��}�fdd�}||_|j|_|�|j||�dd�|�dd	�f|fS)
a�
        Creates a L{HostnameEndpoint} instance where the hostname is
        resolved into a single IPv4 address.

        @param reactor: The L{MemoryReactor}

        @param clientFactory: The client L{IProtocolFactory}

        @param connectArgs: Additional arguments to
            L{HostnameEndpoint.connect}

        @return: A L{tuple} of the form C{(endpoint, (expectedAddress,
            expectedPort, clientFactory, timeout, localBindAddress,
            hostnameAddress))}
        rh�example.comr0c�tttd�dffgS�NrLr0)rrr�r�r(rorp�r@rUrVr3���zTHostnameEndpointMemoryIPv4ReactorTests.createClientEndpoint.<locals>.fakegetaddrinfor�rr�N�rrrvr(r2r}r*r�rTrr�r r�rKr3rUr�rVr���&
��

��z;HostnameEndpointMemoryIPv4ReactorTests.createClientEndpointN�rhrirjrkr�rUrUrUrVr���r�c@r�)�&HostnameEndpointMemoryIPv6ReactorTestsz�
    IPv6 resolution tests for L{HostnameEndpoint} with
    L{MemoryReactor} subclasses that do not provide
    L{IReactorPluggableNameResolver}.
    c	r�)
a�
        Creates a L{HostnameEndpoint} instance where the hostname is
        resolved into a single IPv6 address.

        @param reactor: The L{MemoryReactor}

        @param clientFactory: The client L{IProtocolFactory}

        @param connectArgs: Additional arguments to
            L{HostnameEndpoint.connect}

        @return: A L{tuple} of the form C{(endpoint, (expectedAddress,
            expectedPort, clientFactory, timeout, localBindAddress,
            hostnameAddress))}
        �1:2::3:4�ipv6.example.comr0cr�r�)rrrr�r�rUrVr3r�zTHostnameEndpointMemoryIPv6ReactorTests.createClientEndpoint.<locals>.fakegetaddrinfor�rr�Nr�r�rUr�rVr�r�z;HostnameEndpointMemoryIPv6ReactorTests.createClientEndpointNr�rUrUrUrVr��r�r�c@sZeZdZdZdd�Zdd�Zdd�Zdd	�Zddd�Zd
d�Z	dd�Z
dd�Zdd�Zd
S)�HostnameEndpointsOneIPv4Testsz^
    Tests for the hostname based endpoints when GAI returns only one
    (IPv4) address.
    c	KsTd}tdd�}tjt||g�d|jfi|��}|||j||�dd�|�dd�f|fS)z{
        Creates a L{HostnameEndpoint} instance where the hostname is resolved
        into a single IPv4 address.
        rhr�r0r�rr�N�rrrvrLr(r)rTrr�r r@r�rKrUrUrVr�7s$

��

��z2HostnameEndpointsOneIPv4Tests.createClientEndpointcCr�r�r�r�rUrUrVr�Qr�z-HostnameEndpointsOneIPv4Tests.expectedClientsc
Cr�r�r�r�rUrUrVrWrz/HostnameEndpointsOneIPv4Tests.assertConnectArgscCrrrUrSrUrUrVr srSz)HostnameEndpointsOneIPv4Tests.connectArgsNc
Cs�t�}t��}tj|_|�||�\}}}|�|�}|dur"|�|�|��|�|�}|�	dt
t����|�
|�}	|�|	jtj�|�|	jj|�|�|jddjj�|�g|���dS)z�
        Calling L{Deferred.cancel} on the L{Deferred} returned from
        L{IStreamClientEndpoint.connect} will cause it to be errbacked with a
        L{ConnectingCancelledError} exception.
        Nrr�)r�rr(r)r�rr�rr�r�r8rrr�rrr!r�r�r�r��
_connector�stoppedConnectingr�)
rTr�rr�r�r�r�r�rrrUrUrVrys



z>HostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelledcCs$tjj}||d}|j|d�dS)a 
        Calling L{Deferred.cancel} on the L{Deferred} returned from
        L{IStreamClientEndpoint.connect} after enough time has passed that all
        connection attempts have been initiated will cause it to be errbacked
        with a L{ConnectingCancelledError} exception.
        g@)r�N)rrvr�r)rT�
oneBetweenr�rUrUrV�7test_endpointConnectingCancelledAfterAllAttemptsStarted�szUHostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelledAfterAllAttemptsStartedcCr~)z�
        If L{HostnameEndpoint.connect} is invoked and there is no server
        listening for connections, the returned L{Deferred} will fail with
        C{ConnectError}.
        rr�r
Nrr�rUrUrVr�r�z9HostnameEndpointsOneIPv4Tests.test_endpointConnectFailurec
Cs�tjdd�}t�}t�}|�||�\}}}|�|�}|�d�|jd\}}	}
}}|
�|j	d|�|�
|�|�j|�|�
g|�
��dS)a
        If a connection attempt initiated by
        L{HostnameEndpoint.connect} fails only after
        L{HostnameEndpoint} has exhausted the list of possible server
        addresses, the returned L{Deferred} will fail with
        C{ConnectError}.
        rr��333333�?rN)rr�r�r�r�rr�r�r��
connectorsr�r�rr�)
rTrrr�r�r�r	r�r�r(r�r�r�rUrUrV�)test_endpointConnectFailureAfterIteration�s
�

zGHostnameEndpointsOneIPv4Tests.test_endpointConnectFailureAfterIterationcs�t�}t�}t�}|�||�\}}}|�|�}g��fdd�}|�|�|�|�}	|�d�|	j�|�|�	�|g�|�
|�}
|�	t|
�d�|�|
d|�|�	g|�
��dS)a\
        If a connection attempt initiated by
        L{HostnameEndpoint.connect} succeeds only after
        L{HostnameEndpoint} has exhausted the list of possible server
        addresses, the returned L{Deferred} will fire with the
        connected protocol instance and the endpoint will leave no
        delayed calls in the reactor.
        cr�r`r�r�r�rUrVr�r�z[HostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIteration.<locals>.checkProtor�r\rN)r�r�r�rr�r�r�r�rr�r�rrr�rrUr�rV�)test_endpointConnectSuccessAfterIteration�s$	
�




zGHostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIterationr`)
rhrirjrkr�r�rr rr�rr�r�rUrUrUrVr�1s
r�c@r�)�HostnameEndpointsOneIPv6Testsz^
    Tests for the hostname based endpoints when GAI returns only one
    (IPv6) address.
    c	KsPtdd�}tjt|dg�d|jfi|��}|d|j||�dd�|�dd�f|fS)z{
        Creates a L{HostnameEndpoint} instance where the hostname is resolved
        into a single IPv6 address.
        r�r0r�r�rr�Nr�)rTrr�r r�rKrUrUrVr��s"

��

��z2HostnameEndpointsOneIPv6Tests.createClientEndpointcCr�r�r�r�rUrUrVr�	r�z-HostnameEndpointsOneIPv6Tests.expectedClientsc
Cr�r�r�r�rUrUrVr	rz/HostnameEndpointsOneIPv6Tests.assertConnectArgscCrrrUrSrUrUrVr 9	rSz)HostnameEndpointsOneIPv6Tests.connectArgsc	Cs�t�}t��}tj|_|�t|dg�|�\}}}|�|�}|��|�|�}|�	dt
t����|�
|�}|�|jtj�|�|jj|�|�|jddjj�|�g|���dS)rr
Nrr�)r�rr(r)r�rLrrr�r�r8rrr�rrr!r�r�r�r�r�r�r�)	rTrr�r�r�r�r�rrrUrUrVr?	s
�


z>HostnameEndpointsOneIPv6Tests.test_endpointConnectingCancelledcCsjtjdd�}t|d�}t�}|�||�\}}}|�|�}|�d�|�|�|�j	|�|�g|�
��dS)rrr�r
r�N)rr�r5r�r�rr�r�r�rr�r�rUrUrVr\	s

�

z9HostnameEndpointsOneIPv6Tests.test_endpointConnectFailureN)
rhrirjrkr�r�rr rrrUrUrUrVr��sr�c@s8eZdZdZdZdZdd�Zdd�Zdd	�Zd
d�Z	dS)
�HostnameEndpointIDNATestszJ
    Tests for L{HostnameEndpoint}'s constructor's encoding behavior.
    �
bücher.chsxn--bcher-kva.chcC�>t�tt�dg�|jd�}|�|j|j�|�|j|j�dS)z�
        A L{HostnameEndpoint} constructed with text will contain an
        IDNA-encoded bytes representation of that text.
        r
r0N�	rrvrLr��sampleIDNATextr��
_hostBytes�sampleIDNABytes�	_hostTextrJrUrUrV�test_idnaHostnameTextw	��z/HostnameEndpointIDNATests.test_idnaHostnameTextcCr�)z�
        A L{HostnameEndpoint} constructed with bytes will contain an
        IDNA-decoded textual representation of those bytes.
        r
r0Nr�rJrUrUrV�test_idnaHostnameBytes�	r�z0HostnameEndpointIDNATests.test_idnaHostnameBytescCsDt�tt�dg�td|j�d�}|�|j|j�|�|j	|j�dS)z�
        A L{HostnameEndpoint} constructed with NFD-normalized text will store
        the NFC-normalized version of that text.
        r
�NFDr0N)
rrvrLr�r	r�r�r�r�r�rJrUrUrV�test_nonNormalizedText�	s
�z0HostnameEndpointIDNATests.test_nonNormalizedTextcCs�t�tt�dg�dd�}|�t�t��}|�|t	�}|�
dt|��t�tt�dg�dd�}|�t��}|�|t	�}|�
dt|��dS)a&
        Since any client of L{IStreamClientEndpoint} needs to handle Deferred
        failures from C{connect}, L{HostnameEndpoint}'s constructor will not
        raise exceptions when given bad host names, instead deferring to
        returning a failing L{Deferred} from C{connect}.
        r
��-garbage-�r0z\xff-garbage-\xffu⿰-garbage-⿰z\u2ff0-garbage-\u2ff0N)rrvrLr�rr(r�r)r�r�r�r8)rTrK�deferred�errrUrUrV�test_deferBadEncodingToConnect�	s ��z8HostnameEndpointIDNATests.test_deferBadEncodingToConnectN)
rhrirjrkr�r�r�r�r�r�rUrUrUrVr�o	s


r�c@r#)�HostnameEndpointReprTestsz@
    Tests for L{HostnameEndpoint}'s string representation.
    cC�>t�tt�g�dd�}t|�}|�d|�|�tt|��dS)z�
        The string representation of L{HostnameEndpoint} includes the host and
        port passed to the constructor.
        r`r0z!<HostnameEndpoint example.com:80>N�	rrvrLr+rfr�rEr8�type�rTrK�reprUrUrV�
test_allASCII�	�
�z'HostnameEndpointReprTests.test_allASCIIcCr�)z�
        When IDN is passed to the L{HostnameEndpoint} constructor the string
        representation includes the punycode version of the host.
        r��z'<HostnameEndpoint xn--bcher-kva.ch:443>Nr�r�rUrUrV�test_idnaHostname�	r�z+HostnameEndpointReprTests.test_idnaHostnamecCr�)z�
        When the host passed to L{HostnameEndpoint} is an IPv6 address it is
        wrapped in brackets in the string representation, like in a URI. This
        prevents the colon separating the host from the port from being
        ambiguous.
        s::1�z<HostnameEndpoint [::1]:22>Nr�r�rUrUrV�test_hostIPv6Address�	s
�z.HostnameEndpointReprTests.test_hostIPv6AddresscCs*t�tt�g�dd�}|�dt|��dS)z�
        When a bad hostname is passed to L{HostnameEndpoint}, the string
        representation displays invalid characters in backslash-escaped form.
        r�r0z'<HostnameEndpoint \xff-garbage-\xff:80>N)rrvrLr+r�rfrJrUrUrV�test_badEncoding�	s��z*HostnameEndpointReprTests.test_badEncodingN)rhrirjrkr�r�r�r�rUrUrUrVr��	sr�c@r�)� HostnameEndpointsGAIFailureTestszM
    Tests for the hostname based endpoints when GAI returns no address.
    cCsHt�tt�g�dd�}t�}|�|�}|�|tj�}|�	dt
|��dS)z�
        If no address is returned by GAI for a hostname, the connection attempt
        fails with L{error.DNSLookupError}.
        r�r0r`N)rrvrLr+r�rr�rr�r�r8)rTrKr��dConnect�excrUrUrV�test_failure
s�
z-HostnameEndpointsGAIFailureTests.test_failureN)rhrirjrkr�rUrUrUrVr��	r�r�c@rM)
�&HostnameEndpointsFasterConnectionTestsz�
    Tests for the hostname based endpoints when gai returns an IPv4 and
    an IPv6 address, and one connection takes less time than the other.
    cCs(t�|_t�t|jddg�dd�|_dS)Nrhr��www.example.comr0)r�rrrvrLrKrSrUrUrVrL
s
�z,HostnameEndpointsFasterConnectionTests.setUpcCs�t�|_t�t|jdt�dg�dd�|_d}|j�|�|j�d�|jj	d\}}}}}|�
t|jj	�d�|�
|d�|�
|d�dS)	z�
        If an address type other than L{IPv4Address} and L{IPv6Address} is
        returned by on address resolution, the endpoint ignores that address.
        rhr�r�r0Nr�r\r�)r�rrrvrLr�rKrr�r�r�r)rTr�r�r(r�r�r�rUrUrV�test_ignoreUnknownAddressTypes
s��zEHostnameEndpointsFasterConnectionTests.test_ignoreUnknownAddressTypescCs�t��}tj|_|j�|�}g}|�|j�|jjd\}}}}}|�	|d�|�	|d�|�
||f�}	t�}
|�	|g�|	�|
�|�	t
|�d�|�	|dj|�|�	g|j���dS)a=
        The endpoint returns a connection to the IPv4 address.

        IPv4 ought to be the first attempt, since nameResolution (standing in
        for GAI here) returns it first. The IPv4 attempt succeeds, the
        connection is established, and a Deferred fires with the protocol
        constructed.
        rrhr0r\N)rr(r)rKrr�rarr�r�r�r�r�rr�r��rTr�r��resultsr�r(r�r�r�r�
fakeTransportrUrUrV�test_IPv4IsFaster5
s	
z8HostnameEndpointsFasterConnectionTests.test_IPv4IsFastercCs�t��}tj|_|j�|�}g}|�|j�|j�d�|jj	d\}}}}}|�
|d�|�
|d�|�||f�}	t�}
|�
|g�|	�
|
�|�
t|�d�|�
|dj|�|�
g|j���dS)a=
        The endpoint returns a connection to the IPv6 address.

        IPv6 ought to be the second attempt, since nameResolution (standing in
        for GAI here) returns it second. The IPv6 attempt succeeds, a
        connection is established, and a Deferred fires with the protocol
        constructed.
        r�r\r�r0rN)rr(r)rKrr�rarr�r�r�r�r�r�rr�r�r�rUrUrV�test_IPv6IsFasterT
s 	
z8HostnameEndpointsFasterConnectionTests.test_IPv6IsFastercCs�t��}tj|_|j�|�}g}|�|j�|j�d�|jj	d\}}}}}|�
||f�}	t�}
|	�|
�|�
d|jj	ddjj�|�
g|j���dS)a
        Once the endpoint returns a successful connection, all the other
        pending connections are cancelled.

        Here, the second connection attempt, i.e. IPv6, succeeds, and the
        pending first attempt, i.e. IPv4, is cancelled.
        r�r\Trr�N)rr(r)rKrr�rarr�r�r�r�r�r�r�r�r�r�rUrUrV�test_otherConnectionsCancelledu
s
�zEHostnameEndpointsFasterConnectionTests.test_otherConnectionsCancelledN)	rhrirjrkrLr�r�r�r�rUrUrUrVr�
s!r�c@ry)�SSL4EndpointsTestsz"
    Tests for SSL Endpoints.
    cCr�)zD
        @return: List of calls to L{IReactorSSL.listenSSL}
        )�
sslServersr�rUrUrVr-�
r�z"SSL4EndpointsTests.expectedServerscCr�)zE
        @return: List of calls to L{IReactorSSL.connectSSL}
        )�
sslClientsr�rUrUrVr��
r�z"SSL4EndpointsTests.expectedClientscCs`|\}}}}}}|\}	}
}}}
}|�||	�|�||
�|�||�|�||
�|�||�dS)a�
        Compare host, port, contextFactory, timeout, and bindAddress in
        C{receivedArgs} to C{expectedArgs}.  We ignore the factory because we
        don't only care what protocol comes out of the
        C{IStreamClientEndpoint.connect} call.

        @param receivedArgs: C{tuple} of (C{host}, C{port}, C{factory},
            C{contextFactory}, C{timeout}, C{bindAddress}) that was passed to
            L{IReactorSSL.connectSSL}.
        @param expectedArgs: C{tuple} of (C{host}, C{port}, C{factory},
            C{contextFactory}, C{timeout}, C{bindAddress}) that we expect to
            have been passed to L{IReactorSSL.connectSSL}.
        Nr�)rTr�rr�r(r��contextFactoryr�r�r.r�r��expectedContextFactoryrrrUrUrVr�
s*�
�z$SSL4EndpointsTests.assertConnectArgscCrrrUrSrUrUrVr �
rSzSSL4EndpointsTests.connectArgscCrr
rUrSrUrUrVr5�
rSzSSL4EndpointsTests.listenArgscCsLtddd�\|_|_tddd�\|_|_t|j|jdd�|_tdd�|_d	S)
zF
        Set up client and server SSL contexts for use later.
        zServer Test Certificate�server)�O�CNzClient Test Certificate�clientF)�
privateKey�certificate�requireCertificate)r�N)rK�sKey�sCert�cKey�cCertrE�serverSSLContext�clientSSLContextrSrUrUrVrL�
s��
�zSSL4EndpointsTests.setUpc	KsJtddd�}tj||j|jfi|��|j||j|�dd�|�dd�f|fS)a�
        Create an L{SSL4ServerEndpoint} and return the tools to verify its
        behaviour.

        @param factory: The thing that we expect to be passed to our
            L{IStreamServerEndpoint.listen} implementation.
        @param reactor: A fake L{IReactorSSL} that L{SSL4ServerEndpoint} can
            call L{IReactorSSL.listenSSL} on.
        @param listenArgs: Optional dictionary of arguments to
            L{IReactorSSL.listenSSL}.
        rrrrrrrL)rr�SSL4ServerEndpointr(r�rrrUrUrVr%�
s
��

��z'SSL4EndpointsTests.createServerEndpointc
KsRtddd�}tj||j|j|jfi|��|j|j||j|�dd�|�dd�f|fS)a�
        Create an L{SSL4ClientEndpoint} and return the values needed to verify
        its behaviour.

        @param reactor: A fake L{IReactorSSL} that L{SSL4ClientEndpoint} can
            call L{IReactorSSL.connectSSL} on.
        @param clientFactory: The thing that we expect to be passed to our
            L{IStreamClientEndpoint.connect} implementation.
        @param connectArgs: Optional dictionary of arguments to
            L{IReactorSSL.connectSSL}
        rrr0r�rr�N)rr�SSL4ClientEndpointr�r(r�rrrUrUrVr�s$��

��z'SSL4EndpointsTests.createClientEndpointN)rhrirjrkr-r�rr r5rLr%r�rUrUrUrVr��
s&r�c@ry)�UNIXEndpointsTestsz)
    Tests for UnixSocket Endpoints.
    cCr�)z�
        Override L{EndpointTestCaseMixin.retrieveConnectedFactory} to account
        for different index of 'factory' in C{connectUNIX} args.
        rr\r�r�rUrUrVr�(r~z+UNIXEndpointsTests.retrieveConnectedFactorycCr�)zF
        @return: List of calls to L{IReactorUNIX.listenUNIX}
        )�unixServersr�rUrUrVr-/r�z"UNIXEndpointsTests.expectedServerscCr�)zG
        @return: List of calls to L{IReactorUNIX.connectUNIX}
        )�unixClientsr�rUrUrVr�5r�z"UNIXEndpointsTests.expectedClientscCs@|\}}}}|\}}}	}
|�||�|�||	�|�||
�dS)a
        Compare path, timeout, checkPID in C{receivedArgs} to C{expectedArgs}.
        We ignore the factory because we don't only care what protocol comes
        out of the C{IStreamClientEndpoint.connect} call.

        @param receivedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID})
            that was passed to L{IReactorUNIX.connectUNIX}.
        @param expectedArgs: C{tuple} of (C{path}, C{timeout}, C{checkPID})
            that we expect to have been passed to L{IReactorUNIX.connectUNIX}.
        Nr�)rTr�rrrr�r��checkPID�expectedPathr�r�expectedCheckPIDrUrUrVr;s�z$UNIXEndpointsTests.assertConnectArgscCr)rrr\)r�r�rUrSrUrUrVr TrSzUNIXEndpointsTests.connectArgscCsdddd�S)rri�r\)r�mode�wantPIDrUrSrUrUrVr5ZszUNIXEndpointsTests.listenArgsc	KsLt|���}tj||jfi|��|j||�dd�|�dd�|�dd�f|fS)a�
        Create an L{UNIXServerEndpoint} and return the tools to verify its
        behaviour.

        @param reactor: A fake L{IReactorUNIX} that L{UNIXServerEndpoint} can
            call L{IReactorUNIX.listenUNIX} on.
        @param factory: The thing that we expect to be passed to our
            L{IStreamServerEndpoint.listen} implementation.
        @param listenArgs: Optional dictionary of arguments to
            L{IReactorUNIX.listenUNIX}.
        rrr��r�r)r�mktempr�UNIXServerEndpointrbrrrUrUrVr%`s


��z'UNIXEndpointsTests.createServerEndpointcKsBt|���}tj||jfi|��|j||�dd�|�dd�f|fS)a�
        Create an L{UNIXClientEndpoint} and return the values needed to verify
        its behaviour.

        @param reactor: A fake L{IReactorUNIX} that L{UNIXClientEndpoint} can
            call L{IReactorUNIX.connectUNIX} on.
        @param clientFactory: The thing that we expect to be passed to our
            L{IStreamClientEndpoint.connect} implementation.
        @param connectArgs: Optional dictionary of arguments to
            L{IReactorUNIX.connectUNIX}
        r�rr�r)rr�r�UNIXClientEndpointrbrrrUrUrVr�zrz'UNIXEndpointsTests.createClientEndpointN)rhrirjrkr�r-r�rr r5r%r�rUrUrUrVr�#sr�c@sleZdZdZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�ZdS)�ParserTestszK
    Tests for L{endpoints._parseServer}, the low-level parsing logic.
    r(cOstj|i|��S)zT
        Provide a hook for test_strports to substitute the deprecated API.
        )r�_parseServer)rT�a�kwrUrUrV�parse�r�zParserTests.parsecC�,|�|�d|j�dd|jfddd�f�dS)zN
        Simple strings with a 'tcp:' prefix should be parsed as TCP.
        ztcp:80rr0rLr�rrN�r�r�r�rSrUrUrV�test_simpleTCP���zParserTests.test_simpleTCPcCr�)zU
        TCP port descriptions parse their 'interface' argument as a string.
        ztcp:80:interface=127.0.0.1rr0r
rr�Nr�rSrUrUrV�test_interfaceTCP�r�zParserTests.test_interfaceTCPcCr�)zU
        TCP port descriptions parse their 'backlog' argument as an integer.
        ztcp:80:backlog=6rr0rL�r�Nr�rSrUrUrV�test_backlogTCP�r�zParserTests.test_backlogTCPc	C�.|�|�d|j�dd|jfdddd�f�dS)	z�
        L{endpoints._parseServer} returns a C{'UNIX'} port description with
        defaults for C{'mode'}, C{'backlog'}, and C{'wantPID'} when passed a
        string with the C{'unix:'} prefix and no other parameter values.
        zunix:/var/run/finger�UNIX�/var/run/fingerr�rT�r�rr�Nr�rSrUrUrV�test_simpleUNIX�s
��zParserTests.test_simpleUNIXc	Cr)	zK
        C{mode} can be set by including C{"mode=<some integer>"}.
        zunix:/var/run/finger:mode=0660rri�rTrNr�rSrUrUrV�
test_modeUNIX��
��zParserTests.test_modeUNIXc	Cr)	zM
        C{wantPID} can be set to false by included C{"lockfile=0"}.
        zunix:/var/run/finger:lockfile=0rrr�rFrNr�rSrUrUrV�test_wantPIDUNIX�r	zParserTests.test_wantPIDUNIXc	Cr)	zf
        Backslash can be used to escape colons and backslashes in port
        descriptions.
        zunix:foo\:bar\=baz\:qux\\rzfoo:bar=baz:qux\r�rTrNr�rSrUrUrV�test_escape��
��zParserTests.test_escapecCs|�t�d�d�dS)z�
        L{endpoints.quoteStringArgument} should quote backslashes and colons
        for interpolation into L{endpoints.serverFromString} and
        L{endpoints.clientFactory} arguments.
        zsome : stuff \zsome \: stuff \\N)r�r�quoteStringArgumentrSrUrUrV�test_quoteStringArgument�s�z$ParserTests.test_quoteStringArgumentc	Cr)	z�
        In strports descriptions, '=' in a parameter value does not need to be
        quoted; it will simply be parsed as part of the value.
        zunix:address=foo=barrzfoo=barr�rTrNr�rSrUrUrV�test_impliedEscape�rzParserTests.test_impliedEscapecCs|�t|jd|j�dS)ze
        L{strports.parse} raises C{ValueError} when given an unknown endpoint
        type.
        zbogus-type:nothingN)r�r�r�r�rSrUrUrV�test_unknownTyper\zParserTests.test_unknownTypeN)rhrirjrkr�r�r�rrrrr
rrrrrUrUrUrVr��s			

r�c@s�eZdZdZdd�Zeee�dd��Zeee�dd��Z	dZ
eee�d	d
��Zeee�dd��Zeee�d
d��Z
eee�dd��Zdd�Zdd�Zdd�ZdS)�ServerStringTestszC
    Tests for L{twisted.internet.endpoints.serverFromString}.
    cCs\t�}t�|d�}|�|tj�|�|j|�|�|jd�|�|j	d�|�|j
d�dS)z�
        When passed a TCP strports description, L{endpoints.serverFromString}
        returns a L{TCP4ServerEndpoint} instance initialized with the values
        from the string.
        z&tcp:1234:backlog=12:interface=10.0.0.1r)��10.0.0.1N)r�r�serverFromStringrrrEr~r��_port�_backlog�
_interface)rTrr�rUrUrV�test_tcps�zServerStringTests.test_tcpcCs�t�}t�|dttf�}|�|tj�|�|j|�|�|j	d�|�|j
d�|�|jd�|�|jj
t�|j��}|�|t�dS)z�
        When passed an SSL strports description, L{endpoints.serverFromString}
        returns a L{SSL4ServerEndpoint} instance initialized with the values
        from the string.
        �Vssl:1234:backlog=12:privateKey=%s:certKey=%s:sslmethod=TLSv1_METHOD:interface=10.0.0.1r)rrN)r�rr�escapedPEMPathNamerr�rEr~r�rrr�_sslContextFactory�methodrC�
getContext�ContextType�rTrr��ctxrUrUrV�test_ssl)s��
zServerStringTests.test_sslcCs�t�}t�|dt���}|�|tj�|�|j|�|�|j	d�|�|j
d�|�|jd�|�|jj
t�|�|jjt@�|j��}|�|t�dS)z�
        An SSL string endpoint description with minimal arguments returns
        a properly initialized L{SSL4ServerEndpoint} instance.
        zssl:4321:privateKey=��rrLN)r�rrrrr�rEr~r�rrrrrrBr��_optionsrArrrrUrUrV�test_sslWithDefaults@s
�
�
z&ServerStringTests.test_sslWithDefaultsz(ssl:1234:privateKey=%s:extraCertChain=%scCstt�t�|jttf�}dd�dD�}|j}|�|jd�	d�|d�	d��|�|jd�	d�|d�	d��dS)zf
        Specifying a chain file loads the contained certificates in the right
        order.
        cSs&g|]}t�t�d|f�����qS)zthing%d.pem)rD�loadPEM�casPath�child�
getContent)�.0�nrUrUrV�
<listcomp>ks��z8ServerStringTests.test_sslChainLoads.<locals>.<listcomp>)r\r�r�sha1r\N)
rrr��SSL_CHAIN_TEMPLATEr�escapedChainPathNamerr��extraCertChain�digest)rTr��expectedChainCerts�cfrUrUrV�test_sslChainLoadsZs$������z$ServerStringTests.test_sslChainLoadsc	Cs�t|���}|����|�t��}t�t�|j	t
t�|j�f�Wd�n1s,wY|�
t|j�d|jf�dS)zy
        If C{extraCertChain} is passed, it has to contain at least one valid
        certificate in PEM format.
        NzOSpecified chain file '%s' doesn't contain any valid certificates in PEM format.)r9r��create�closer�r�rrr�r-rr
rrr�r8r3)rT�fp�caughtrUrUrV� test_sslChainFileMustContainCertws$
������z2ServerStringTests.test_sslChainFileMustContainCertcCsLd}t�}t�|d�tt|��}|j}|�|jt�|�	t
|�|jj�dS)z�
        If C{dhParameters} are specified, they are passed as
        L{DiffieHellmanParameters} into L{CertificateOptions}.
        �someFilez1ssl:4321:privateKey={}:certKey={}:dhParameters={}N)r�rr�formatrrr�dhParametersrFr�r9�_dhFile)rT�fileNamerr�r2rUrUrV�test_sslDHparameters�s��z&ServerStringTests.test_sslDHparameterscCs�t�}t�|dttf�}|�|tj�|�|j|�|�	|j
d�|�	|jd�|�	|jd�|�	|j
jt�|j
��}|�|t�dS)zq
        Lack of a trailing newline in key and cert .pem files should not
        generate an exception.
        rr)rrN)r�rr�&escapedNoTrailingNewlineKeyPEMPathName�'escapedNoTrailingNewlineCertPEMPathNamerr�rEr~r�rrrrrrCrrrrUrUrV�test_sslNoTrailingNewlinePem�s"���	
z.ServerStringTests.test_sslNoTrailingNewlinePemcCsht�}t�|d�}|�|tj�|�|j|�|�|jd�|�|j	d�|�|j
d�|�|j�dS)z�
        When passed a UNIX strports description, L{endpoint.serverFromString}
        returns a L{UNIXServerEndpoint} instance initialized with the values
        from the string.
        z0unix:/var/foo/bar:backlog=7:mode=0123:lockfile=1�/var/foo/bar��SN)
r�rrrr�rEr~r��_addressr�_moder��_wantPID)rTrrKrUrUrV�	test_unix�s�zServerStringTests.test_unixcC�&|�ttjdd�}|�t|�d�dS)zq
        L{endpoints.serverFromString} raises C{ValueError} when given an
        unknown endpoint type.
        N�ftl:andromeda/carcosa/hali/2387�Unknown endpoint type: 'ftl')r�r�rrr�r8�rTrrUrUrVr���z"ServerStringTests.test_unknownTypecC�bt|�t�}t�|d�}ddlm}|�|j|�|�|j	|ddf�|�|j
tddd��d	S)
z�
        L{endpoints.serverFromString} looks up plugins of type
        L{IStreamServerEndpoint} and constructs endpoints from them.
        zfake:hello:world:yes=no:up=downr)�fake�hello�world�no�down)�yes�upN)�
addFakePluginr�rr�twisted.plugins.fakeendpointrOrE�parserr�r�r.�dict)rT�notAReactor�fakeEndpointrOrUrUrV�test_typeFromPlugin�s�z%ServerStringTests.test_typeFromPluginN)rhrirjrkrr
�skipSSL�
skipSSLReasonr!r$r-r3r8r>rArHrr\rUrUrUrVrs&





r�fakeendpoint.pycsxddl��j���ttj�����fdd�}|�|�t|���}|�	�t
t�j�
|��|�|��tj�|j�dS)z�
    For the duration of C{testCase}, add a fake plugin to twisted.plugins which
    contains some sample endpoint parsers.
    rNcs(�j���j����tjdd�<dSr`)�modules�clear�updater�__path__rU��savedModules�savedPluginPath�sysrUrV�cleanup�s
zaddFakePlugin.<locals>.cleanup)rgr`rJ�listrrcr�r9r��createDirectoryr:rh�filePath�sibling�copyTor'rarr)�testCase�dropinSourcerhr6rUrdrVrV�s


rVc@sheZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�ZdS)�ClientStringTestszC
    Tests for L{twisted.internet.endpoints.clientFromString}.
    cC�jt�}t�|d�}|�|tj�|�|j|�|�|jd�|�|j	d�|�|j
d�|�|jd�dS)z�
        When passed a TCP strports description, L{endpoints.clientFromString}
        returns a L{TCP4ClientEndpoint} instance initialized with the values
        from the string.
        z=tcp:host=example.com:port=1234:timeout=7:bindAddress=10.0.0.2r`r)rC�z10.0.0.2rN�r�r�clientFromStringrrrEr~r��_hostr�_timeout�_bindAddress�rTrr�rUrUrVr
��zClientStringTests.test_tcpcCrq)z�
        When passed a TCP strports description using positional arguments,
        L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint} instance
        initialized with the values from the string.
        z3tcp:example.com:1234:timeout=7:bindAddress=10.0.0.2r`r)rCrrNrsrxrUrUrV�test_tcpPositionalArgs!
ryz(ClientStringTests.test_tcpPositionalArgscC�2t�}t�|d�}|�|jd�|�|jd�dS)z�
        When passed a TCP strports description specifying host as a positional
        argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint}
        instance initialized with the values from the string.
        z8tcp:example.com:port=1234:timeout=7:bindAddress=10.0.0.2r`r)N�r�rrtr�rurrxrUrUrV�test_tcpHostPositionalArg2
s�z+ClientStringTests.test_tcpHostPositionalArgcCr{)z�
        When passed a TCP strports description specifying port as a positional
        argument, L{endpoints.clientFromString} returns a L{TCP4ClientEndpoint}
        instance initialized with the values from the string.
        z8tcp:host=example.com:1234:timeout=7:bindAddress=10.0.0.2r`r)Nr|rxrUrUrV�test_tcpPortPositionalArg@
s�z+ClientStringTests.test_tcpPortPositionalArgcCs0t�}t�|d�}|�|jd�|�|j�dS)z{
        A TCP strports description may omit I{timeout} or I{bindAddress} to
        allow the default to be used.
        ztcp:host=example.com:port=1234rN)r�rrtr�rvr�rwrxrUrUrV�test_tcpDefaultsM
sz"ClientStringTests.test_tcpDefaultscC�Zt�}t�|d�}|�|tj�|�|j|�|�|jd�|�|j	d�|�
|j�dS)z�
        When passed a UNIX strports description, L{endpoints.clientFromString}
        returns a L{UNIXClientEndpoint} instance initialized with the values
        from the string.
        z+unix:path=/var/foo/bar:lockfile=1:timeout=9rB�	N�r�rrtrr�rEr~r�r�rvr��	_checkPIDrxrUrUrVrHW
��zClientStringTests.test_unixcCs,t�t�d�}|�|jd�|�|j�dS)zz
        A UNIX strports description may omit I{lockfile} or I{timeout} to allow
        the defaults to be used.
        zunix:path=/var/foo/barrN)rrtr�r�rvr�r�)rTr�rUrUrV�test_unixDefaultsg
sz#ClientStringTests.test_unixDefaultscCr�)z�
        When passed a UNIX strports description specifying path as a positional
        argument, L{endpoints.clientFromString} returns a L{UNIXClientEndpoint}
        instance initialized with the values from the string.
        z&unix:/var/foo/bar:lockfile=1:timeout=9rBr�Nr�rxrUrUrV�test_unixPathPositionalArgp
r�z,ClientStringTests.test_unixPathPositionalArgcCrN)
z�
        L{endpoints.clientFromString} looks up plugins of type
        L{IStreamClientEndpoint} and constructs endpoints from them.
        �crfake:alpha:beta:cee=dee:num=1r��fakeClientWithReactor�alpha�beta�dee�1��cee�numN)rVr�rrtrWr�rErXr�r�r.rY)rTrZ�clientEndpointr�rUrUrVr\�
s�z%ClientStringTests.test_typeFromPlugincCrI)zq
        L{endpoints.clientFromString} raises C{ValueError} when given an
        unknown endpoint type.
        NrJrK)r�r�rrtr�r8rLrUrUrVr�
rMz"ClientStringTests.test_unknownTypec	CsVt|�t�}t�|d�}ddlm}|�|j|j|j	f||ddft
ddd�f�d	S)
z�
        L{endpoints.clientFromString} will pass a reactor to plugins
        implementing the L{IStreamClientEndpointStringParserWithReactor}
        interface.
        r�rr�r�r�r�r�r�N)rVr�rrtrWr�r�rXr�r.rY)rTrr�r�rUrUrV�test_stringParserWithReactor�
s�
��z.ClientStringTests.test_stringParserWithReactorN)rhrirjrkrrzr}r~rrHr�r�r\rr�rUrUrUrVrp
s

	rpc@rM)
�SSLClientStringTestszU
    Tests for L{twisted.internet.endpoints.clientFromString} which require SSL.
    cs`t�}t�|dtttf�}|�|tj�|�|j|�|�	|j
d�|�	|jd�|�	|jd�|�	|j
d�|j}|�|t�|�	|jt�|�|jt@�|��}|�|t�|�	t|j�t�t|j�}|�t|j��|�	|t�dd�t� d�t� d	�fD�}g�G�fd
d�d�}|j!�"|��|�	t#dd
��D�dd�d�t#|dd�d��dS)��
        When passed an SSL strports description, L{clientFromString} returns a
        L{SSL4ClientEndpoint} instance initialized with the values from the
        string.
        zdssl:host=example.net:port=4321:privateKey=%s:certKey=%s:bindAddress=10.0.0.3:timeout=3:caCertsDir=%s�example.netr"r��z10.0.0.3rcSs,g|]}|�����d�rt�|����qS)z.pem)�basename�lower�endswithrDr%r(�r)�xrUrUrVr+�
s��z1SSLClientStringTests.test_ssl.<locals>.<listcomp>�
thing1.pem�
thing2.pemc�eZdZ�fdd�ZdS)z.SSLClientStringTests.test_ssl.<locals>.ListCtxcsG�fdd�d�}|�S)Ncr�)zLSSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_store.<locals>.Storecs��|�dSr`r�)rT�cert��
addedCertsrUrV�add_cert�
r�zUSSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_store.<locals>.Store.add_certN)rhrirjr�rUr�rUrV�Store�
�r�rU)rTr�r�rUrV�get_cert_store�
sz=SSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_storeN)rhrirjr�rUr�rUrV�ListCtx�
r�r�css�|]}t|�VqdSr`�rDr�rUrUrV�	<genexpr>�
s�z0SSLClientStringTests.test_ssl.<locals>.<genexpr>cS�|��Sr`�r0�r�rUrUrVr��
�z/SSLClientStringTests.test_ssl.<locals>.<lambda>)�keycSr�r`r�r�rUrUrVr��
r�N)$r�rrtr�escapedCAsPathNamerr�rEr~r�rurrvrwrrErrBr�r#rArrrDr��testCertificaterH�_setPrivateKeyrGr��testPrivateCertificater&r'�	trustRoot�_addCACertsToContext�sorted)rTrr��certOptionsr �privateCert�
expectedCertsr�rUr�rVr!�
sF��
���zSSLClientStringTests.test_sslcCstt�}t�|dtttf�}|�|tj�|�|j|�|�	|j
d�|�	|jd�|�	|jd�|�	|j
d�dS)r�zZssl:example.net:4321:privateKey=%s:certKey=%s:bindAddress=10.0.0.3:timeout=3:caCertsDir=%sr�r"r�r�N)r�rrtrr�rr�rEr~r�rurrvrwrxrUrUrV�test_sslPositionalArgs�
s��z+SSLClientStringTests.test_sslPositionalArgscCszt�}t�|d�}|�|tj�|�|j|�|�|jd�|�|j	d�|j
}|�|jt�|�
|j�|�
|j�dS)z�
        When passed an SSL strports description without extra arguments,
        L{clientFromString} returns a L{SSL4ClientEndpoint} instance
        whose context factory is initialized with default values.
        zssl:example.net:4321r�r"N)r�rrtrr�rEr~r�rurrrrBr�r�r�)rTrr�r�rUrUrVr$sz)SSLClientStringTests.test_sslWithDefaultscCsXGdd�dt�}t�d���}||_|�dd�t�|�jD�t	�
t�d����g�dS)z�
        If a certificate in the directory is unreadable,
        L{endpoints._loadCAsFromDir} will ignore that certificate.
        c@seZdZdd�ZdS)zKSSLClientStringTests.test_unreadableCertificate.<locals>.UnreadableFilePathcSs(t�|�}|t�d���krtt��|S)Nr�)r9r(r&r'�OSErrorrrbrUrUrVr(s
zVSSLClientStringTests.test_unreadableCertificate.<locals>.UnreadableFilePath.getContentN)rhrirjr(rUrUrUrV�UnreadableFilePathsr�rmcSsg|]}t|��qSrUr�r�rUrUrVr+'szCSSLClientStringTests.test_unreadableCertificate.<locals>.<listcomp>r�N)r9r&r'�parent�	clonePathr�r�_loadCAsFromDir�_caCertsrDr%r()rTr��casPathClonerUrUrV�test_unreadableCertificates
�z/SSLClientStringTests.test_unreadableCertificatecCsHt�}t�|d�}|j}|�|t�|�|j�|��}|�|t	�dS)z�
        When passed an SSL strports description without any extra parameters,
        L{clientFromString} returns a simple non-verifying endpoint that will
        speak SSL.
        z%ssl:host=simple.example.org:port=4321N)
r�rrtrrrEr��verifyrr)rTrr�r�r rUrUrV�test_sslSimple+s�z#SSLClientStringTests.test_sslSimpleN)	rhrirjrkr!r�r$r�r�rUrUrUrVr��
s4r�c@r�)� AdoptedStreamServerEndpointTestszA
    Tests for adopted socket-based stream server endpoints.
    cCs&t�|||�}dd�|_dd�|_|S)z�
        Create an L{AdoptedStreamServerEndpoint} which may safely be used with
        an invalid file descriptor.  This is convenient for a number of unit
        tests.
        cSr�r`rU�rirUrUrVr�Jr�zPAdoptedStreamServerEndpointTests._createStubbedAdoptedEndpoint.<locals>.<lambda>cSr�r`rUr�rUrUrVr�Kr�)r�AdoptedStreamServerEndpoint�_close�_setNonBlocking)rTr�fileno�
addressFamilyr�rUrUrV�_createStubbedAdoptedEndpointAs

z>AdoptedStreamServerEndpointTests._createStubbedAdoptedEndpointcCs2d}t}|�|||�}tddd�}||||f|fS)a�
        Create a new L{AdoptedStreamServerEndpoint} for use by a test.

        @return: A three-tuple:
            - The endpoint
            - A tuple of the arguments expected to be passed to the underlying
              reactor method
            - An IAddress object which will match the result of
              L{IListeningPort.getHost} on the port returned by the endpoint.
        rrrr))rr�r)rTrr�r�r�rKr�rUrUrVr%Ns
z5AdoptedStreamServerEndpointTests.createServerEndpointcCr�)z�
        @return: The ports which were actually adopted by C{reactor} via calls
            to its L{IReactorSocket.adoptStreamPort} implementation.
        )�adoptedPortsr�rUrUrVr-`sz0AdoptedStreamServerEndpointTests.expectedServerscCsiS)zx
        @return: A C{dict} of additional keyword arguments to pass to the
            C{createServerEndpoint}.
        rUrSrUrUrVr5gsz+AdoptedStreamServerEndpointTests.listenArgscsRt�����dt�}|�t����|�t��tj�}��fdd�}|�|�|S)z�
        L{AdoptedStreamServerEndpoint.listen} can only be used once.  The file
        descriptor given is closed after the first use, and subsequent calls to
        C{listen} return a L{Deferred} that fails with L{AlreadyListened}.
        �
cs��dt�j��dSr[)r�rr��rm�rrTrUrV�listenFailedyszEAdoptedStreamServerEndpointTests.test_singleUse.<locals>.listenFailed)	r�r�rr,r�r�r�AlreadyListenedr�)rTrKr�r�rUr�rV�test_singleUsens
z/AdoptedStreamServerEndpointTests.test_singleUsecsRt�}��|dt�}g��fdd�}||_|�t��}��fdd�}|�|�|S)zv
        L{AdoptedStreamServerEndpoint.listen} sets the file description given
        to it to non-blocking.
        r�cs��d|f�dS)N�setNonBlockingr��r�)�eventsrUrVr��r^zTAdoptedStreamServerEndpointTests.test_descriptionNonBlocking.<locals>.setNonBlockingc���dg��dS)N)r�r�r�r��r�rTrUrV�listened�r^zNAdoptedStreamServerEndpointTests.test_descriptionNonBlocking.<locals>.listened)r�r�rr�r,r�r�)rTrrKr�r�r�rUr�rV�test_descriptionNonBlockings
z<AdoptedStreamServerEndpointTests.test_descriptionNonBlockingcsTt�����dt�}g���fdd�}||_|�t��}��fdd�}|�|�|S)z�
        L{AdoptedStreamServerEndpoint.listen} closes its file descriptor after
        adding it to the reactor with L{IReactorSocket.adoptStreamPort}.
        r�cs��d|t�j�f�dS)Nr5)rarr�r�)r�rrUrVr5�szEAdoptedStreamServerEndpointTests.test_descriptorClosed.<locals>.closecr�)N)r5r�r\r�r�r�rUrVr��r^zHAdoptedStreamServerEndpointTests.test_descriptorClosed.<locals>.listened)r�r�rr�r,r�r�)rTrKr5r�r�rU)r�rrTrV�test_descriptorClosed�s
z6AdoptedStreamServerEndpointTests.test_descriptorClosedN)rhrirjrkr�r%r-r5r�r�r�rUrUrUrVr�<s
r�c@sFeZdZdZejZdd�Zdd�Zdd�Z	dd	�Z
d
d�Zdd
�ZdS)�SystemdEndpointPluginTestsz�
    Unit tests for the systemd stream server endpoint and endpoint string
    description parser.

    @see: U{systemd<http://www.freedesktop.org/wiki/Software/systemd>}
    cC�>tttj��}|D]}t||j�rdSq	|�d|���dS)z�
        L{endpoints._SystemdParser} is found as a plugin for
        L{interfaces.IStreamServerEndpointStringParser} interface.
        zDid not find systemd parser in N�rir2r�!IStreamServerEndpointStringParserr7�_parserClassr��rT�parsersr�rUrUrV�test_pluginDiscovery�s�z/SystemdEndpointPluginTests.test_pluginDiscoverycC�|��}|�ttj|��dS)zx
        L{endpoints._SystemdParser} instances provide
        L{interfaces.IStreamServerEndpointStringParser}.
        N�r�r�rrr��rTrXrUrUrVr���
�z)SystemdEndpointPluginTests.test_interfacecCsjt�}gd�}d}|��}t|�|_|j||t|�d�}|�|j|�|�|j	|�|�|j
||�dS)a�
        Helper for unit tests for L{endpoints._SystemdParser.parseStreamServer}
        for different address families.

        Handling of the address family given will be verify.  If there is a
        problem a test-failing exception will be raised.

        @param addressFamily: An address family constant, like
            L{socket.AF_INET}.

        @param addressFamilyString: A string which should be recognized by the
            parser as representing C{addressFamily}.
        )r�rrC�r�r�)�domain�indexN)r�r�r;�	_sddaemon�parseStreamServerr8rErr�r�r�)rTr��addressFamilyStringr�descriptorsr�rXr�rUrUrV�_parseStreamServerTest�s

�z1SystemdEndpointPluginTests._parseStreamServerTestcC�|�td�dS)zC
        IPv4 can be specified using the string C{"INET"}.
        �INETN)r�rrSrUrUrV�test_parseStreamServerINET�r�z5SystemdEndpointPluginTests.test_parseStreamServerINETcCr�)zD
        IPv6 can be specified using the string C{"INET6"}.
        �INET6N)r�rrSrUrUrV�test_parseStreamServerINET6�r�z6SystemdEndpointPluginTests.test_parseStreamServerINET6cCs:zddlm}Wntyt�d��w|�|d�dS)zS
        A UNIX domain socket can be specified using the string C{"UNIX"}.
        r)�AF_UNIXzPlatform lacks AF_UNIX supportrN)�socketr��ImportErrorr>�SkipTestr�)rTr�rUrUrV�test_parseStreamServerUNIX�s
�z5SystemdEndpointPluginTests.test_parseStreamServerUNIXN)
rhrirjrkr�_SystemdParserr�r�r�r�r�r�r�rUrUrUrVr��s

r�c@�.eZdZdZejZdd�Zdd�Zdd�Z	dS)	�TCP6ServerEndpointPluginTestsz[
    Unit tests for the TCP IPv6 stream server endpoint string description
    parser.
    cCr�)z�
        L{endpoints._TCP6ServerParser} is found as a plugin for
        L{interfaces.IStreamServerEndpointStringParser} interface.
        z*Did not find TCP6ServerEndpoint parser in Nr�r�rUrUrVr�	��z2TCP6ServerEndpointPluginTests.test_pluginDiscoverycCr�)z{
        L{endpoints._TCP6ServerParser} instances provide
        L{interfaces.IStreamServerEndpointStringParser}.
        Nr�r�rUrUrVr�r�z,TCP6ServerEndpointPluginTests.test_interfacecCsXt�t�d�}|�|tj�|�|jt�|�|jd�|�|jd�|�|j	d�dS)z�
        L{serverFromString} returns a L{TCP6ServerEndpoint} instance with a
        'tcp6' endpoint string description.
        z$tcp6:8080:backlog=12:interface=\:\:1i�rrN)
rrr�rr r~r�rrrr,rUrUrV�test_stringDescriptions�z4TCP6ServerEndpointPluginTests.test_stringDescriptionN)
rhrirjrkr�_TCP6ServerParserr�r�r�r�rUrUrUrVr�s
r�c@r�)	�StandardIOEndpointPluginTestszM
    Unit tests for the Standard I/O endpoint string description parser.
    cCr�)z�
        L{endpoints._StandardIOParser} is found as a plugin for
        L{interfaces.IStreamServerEndpointStringParser} interface.
        z*Did not find StandardIOEndpoint parser in Nr�r�rUrUrVr�5r�z2StandardIOEndpointPluginTests.test_pluginDiscoverycCr�)z{
        L{endpoints._StandardIOParser} instances provide
        L{interfaces.IStreamServerEndpointStringParser}.
        Nr�r�rUrUrVr�Ar�z,StandardIOEndpointPluginTests.test_interfacecCs.t�t�d�}|�|tj�|�|jt�dS)z�
        L{serverFromString} returns a L{StandardIOEndpoint} instance with a
        'stdio' endpoint string description.
        zstdio:N)rrr�rrDr~r,rUrUrVr�Ksz4StandardIOEndpointPluginTests.test_stringDescriptionN)
rhrirjrkr�_StandardIOParserr�r�r�r�rUrUrUrVr�.s
r�c@ru)�ConnectProtocolTestsz'
    Tests for C{connectProtocol}.
    cCslt�}t�|dd�}t�}t�||�|�t|j�d�|jddj}|�	|t
j�|�|�
d�|�dS)z�
        C{endpoints.connectProtocol} calls the given endpoint's C{connect()}
        method with a factory that will build the given protocol.
        r
rr\r�N)r�rrr��connectProtocolr�rr��_wrappedFactoryrrr(rEr�)rTrrK�theProtocolr�rUrUrV�"test_connectProtocolCreatesFactoryZsz7ConnectProtocolTests.test_connectProtocolCreatesFactorycs:t���G�fdd�d�}|�}|��t�|t���dS)z~
        C{endpoints.connectProtocol} returns the result of calling the given
        endpoint's C{connect()} method.
        cr�)zOConnectProtocolTests.test_connectProtocolReturnsConnectResult.<locals>.Endpointc��S)zR
                Return a marker object for use in our assertion.
                rU)rTr��rnrUrVrtszWConnectProtocolTests.test_connectProtocolReturnsConnectResult.<locals>.Endpoint.connectN)rhrirjrrUrrUrV�Endpointsr�rN)rr�rErrr�)rTrrKrUrrV�(test_connectProtocolReturnsConnectResultlsz=ConnectProtocolTests.test_connectProtocolReturnsConnectResultN)rhrirjrkrrrUrUrUrVrUsrcs4eZdZdZ�fdd�Z�fdd�Zdd�Z�ZS)�UppercaseWrapperProtocolzL
    A wrapper protocol which uppercases all strings passed through it.
    c�t��|���dS)z�
        Uppercase a string passed in from the transport.

        @param data: The string to uppercase.
        @type data: L{bytes}
        N)rWrc�upperrbr\rUrVrc��z%UppercaseWrapperProtocol.dataReceivedcr
)z�
        Uppercase a string passed out to the transport.

        @param data: The string to uppercase.
        @type data: L{bytes}
        N)rWr_rrbr\rUrVr_�rzUppercaseWrapperProtocol.writecCs|D]}|�|�qdS)zy
        Uppercase a series of strings passed out to the transport.

        @param seq: An iterable of strings.
        Nr^)rT�seqrPrUrUrVr��s�z&UppercaseWrapperProtocol.writeSequence)rhrirjrkrcr_r�rmrUrUr\rVr	~s
		r	c@r)�UppercaseWrapperFactoryzK
    A wrapper factory which uppercases all strings passed through it.
    N)rhrirjrkr	rrUrUrUrVr�src@ru)�NetstringTrackerz�
    A netstring receiver which keeps track of the strings received.

    @ivar strings: A L{list} of received strings, in order.
    cCs
g|_dSr`)�stringsrSrUrUrVrW�rszNetstringTracker.__init__cCs|j�|�dS)z�
        Receive a string and append it to C{self.strings}.

        @param string: The string to be appended to C{self.strings}.
        N)rra)rTr�rUrUrV�stringReceived�szNetstringTracker.stringReceivedN)rhrirjrkrWrrUrUrUrVr�src@r7)�	FakeErrorz�
    An error which isn't really an error.

    This is raised in the L{wrapClientTLS} tests in place of a
    'real' exception.
    Nr9rUrUrUrVr�r:rc@r�)�WrapperClientEndpointTestsz.
    Tests for L{_WrapperClientEndpoint}.
    cCs6t�\|_|_t�|_t�|jt�|_t	�
t�|_dSr`)
r<rK�	completerr��contextr�_WrapperEndpointrr�r(r�rr�rSrUrUrVrL�s�z WrapperClientEndpointTests.setUpcCsL|j�|j�}|j��}|�|�}|jj�d�|�	�|�
|jdg�dS)z�
        Any modifications performed by the underlying L{ProtocolWrapper}
        propagate through to the wrapped L{Protocol}.
        s5:hello,sHELLON)r�rr�r�succeedOncerHr�r�r_�flushr�r�rT�
connecting�pumprrUrUrV�test_wrappingBehavior�s

z0WrapperClientEndpointTests.test_wrappingBehaviorcCsB|j�|j�}|j��}|�|�}|�d�|�|j�	�d�dS)z�
        Methods defined on the wrapped L{Protocol} are accessible from the
        L{Protocol} returned from C{connect}'s L{Deferred}.
        sspams4:SPAM,N)
r�rr�rrrH�
sendStringr��clientIO�getOutBufferrrUrUrV�test_methodsAvailable�s



z0WrapperClientEndpointTests.test_methodsAvailablecCs6|j�|j�}|�|�|j�t��|�|t�dS)zS
        Connection failures propagate upward to C{connect}'s L{Deferred}.
        N)r�rr��assertNoResultr�failOncerr��rTr�rUrUrV�test_connectionFailure�s
z1WrapperClientEndpointTests.test_connectionFailurecCs0|j�|j�}|�|�|��|�|t�dS)zM
        Cancellation propagates upward to C{connect}'s L{Deferred}.
        N)r�rr�r!rr�r!r#rUrUrV�test_connectionCancellation�s
z6WrapperClientEndpointTests.test_connectionCancellationcCs8|j�|j�}|j��}|�|�}|�|jj|j�dS)z|
        The transport of the wrapped L{Protocol}'s transport is the transport
        passed to C{makeConnection}.
        N)	r�rr�rrrHrEr�rrrUrUrV�*test_transportOfTransportOfWrappedProtocol�s

zEWrapperClientEndpointTests.test_transportOfTransportOfWrappedProtocolN)
rhrirjrkrLrr r$r%r&rUrUrUrVr�s		rcCs|�d�jS)a,
    Given a L{MemoryReactor} and the result of calling L{wrapClientTLS},
    extract the L{IOpenSSLClientConnectionCreator} associated with it.

    Implementation presently uses private attributes but could (and should) be
    refactored to just call C{.connect()} on the endpoint, when
    L{HostnameEndpoint} starts directing its C{getaddrinfo} call through the
    reactor it is passed somehow rather than via the global threadpool.

    @param memoryReactor: the reactor attached to the given endpoint.
        (Presently unused, but included so tests won't need to be modified to
        honor it.)

    @param tlsEndpoint: The result of calling L{wrapClientTLS}.

    @return: the client connection creator associated with the endpoint
        wrapper.
    @rtype: L{IOpenSSLClientConnectionCreator}
    N)�_wrapperFactory�_connectionCreator)r��tlsEndpointrUrUrV�connectionCreatorFromEndpointsr*c@r#)�WrapClientTLSParserTestsz0
    Tests for L{_TLSClientEndpointParser}.
    cCsjt�}t�|td��}|j}|�|j|�|�|jd�|�|j	d�|�|j
d�|�|jtd��dS)zm
        A L{HostnameEndpoint} is constructed from parameters passed to
        L{clientFromString}.
        z4tls:example.com:443:timeout=10:bindAddress=127.0.0.1r�r�rr
N)r�rrtr6�_wrappedEndpointrEr~r�r�rrvrw)rTrrK�hostnameEndpointrUrUrV�!test_hostnameEndpointConstruction!s�z:WrapClientTLSParserTests.test_hostnameEndpointConstructioncCs>t�}t�|d�}|�|jjd�t||�}|�|jd�dS)z�
        The hostname passed to L{clientFromString} is treated as utf-8 bytes;
        it is then encoded as IDNA when it is passed along to
        L{HostnameEndpoint}, and passed as unicode to L{optionsForClientTLS}.
        stls:éxample.example.com:443sxn--xample-9ua.example.comuéxample.example.comN)r�rrtr�r,r�r*�	_hostname)rTrrK�connectionCreatorrUrUrV�test_utf8Encoding2s��
z*WrapClientTLSParserTests.test_utf8Encodingcs|t�}t�t|dg�d�ttt�t��j	���
d��}|�t�
t��}|j��\}}}}}|�d��|�|��dus=J�t�t���}	t|	jj|	jt�t���jg|	d�}
t��t|
dt�
�fdd��d	��d��t�fd
d��fdd��\}}}
�j�d�|�|�}|j�d
�|
� �|�!�jj"�|�!|jj"�|�!�jj#�|�!|jj#�t�$�j�}|�%|t�t����dS)z�
        When passed a string endpoint description beginning with C{tls:},
        L{clientFromString} returns a client endpoint initialized with the
        values from the string.
        r
z=tls:localhost:4321:privateKey={}:certificate={}:trustRoots={}�asciiN)r�r�r/r�Fcrr`rUrU)�plainServerrUrVr�qr�z3WrapClientTLSParserTests.test_tls.<locals>.<lambda>)�isClient�wrappedFactorycrr`rUrU)�serverProtocolrUrVr�tr�crr`rUrU)�clientProtocolrUrVr�ur�shello
shi you too
)&r�rrtrLr:rr
�pemPathr�rr�encoderr(r�r)r��popr�r!rHr%r(rEr��originalrD�	chainPathrJr=r�r_rHrr��
disconnecting�disconnected�peerFromTransportr�)rTrrKr�r�r(r�r�r��
serverCert�
serverOptions�sProto�cProtor�plainClient�peerCertificaterU)r7r3r6rV�test_tlsBsX
��

���


�
z!WrapClientTLSParserTests.test_tlscCs>t�}t�|d�}t||�}|�|jd�|�|jjd�dS)z�
        When passed a C{tls:} strports description without extra arguments,
        L{clientFromString} returns a client endpoint whose context factory is
        initialized with default values.
        stls:example.com:443r`r�N)r�rrtr*r�r/r,r�)rTrrK�creatorrUrUrV�test_tlsWithDefaults�s

z-WrapClientTLSParserTests.test_tlsWithDefaultsN)rhrirjrkr.r1rFrHrUrUrUrVr+sAr+cKs�z|j}|j}Wnty|j}|j}Ynw|D]
}||vr'td�|���qi}|�|�|�|�t||�}|||j	<|S)a�
    Create a copy of the given function with the given globals substituted.

    The globals must already exist in the function's existing global scope.

    @param function: any function object.
    @type function: L{types.FunctionType}

    @param newGlobals: each keyword argument should be a global to set in the
        new function's returned scope.
    @type newGlobals: L{dict}

    @return: a new function, like C{function}, but with new global scope.
    z<Name bound by replacingGlobals but not present in module: {})
�	func_code�func_globalsr��__code__�__globals__�	TypeErrorr:rbrrh)�function�
newGlobals�
codeObject�funcGlobalsr��
mergedGlobals�newFunctionrUrUrV�replacingGlobals�s*

����



rTc@r�)�WrapClientTLSTestszj
    Tests for the error-reporting behavior of L{wrapClientTLS} when
    C{pyOpenSSL} is unavailable.
    cCs2ttjdd�}|�t|dd�}|�dt|��dS)z�
        If SSL is not supported, L{TLSMemoryBIOFactory} will be L{None}, which
        causes C{_wrapper} to also be L{None}.  If C{_wrapper} is L{None}, then
        an exception is raised.
        NrIzOpenSSL not available)rTr�
wrapClientTLSr��NotImplementedErrorr�r8)rT�replaced�notImplementedrUrUrV�test_noOpenSSL�sz!WrapClientTLSTests.test_noOpenSSLN)rhrirjrkrZrUrUrUrVrU�rzrU)rUN)r_)�rk�errnorr�rrrrr�typesr�unicodedatar	r>r
�zope.interfacerrr
�zope.interface.interfacer�zope.interface.verifyrr�twistedrrurrrrrrrr�twisted.internet.abstractr�twisted.internet.addressrrrrr�twisted.internet.endpointsr �twisted.internet.errorr!�twisted.internet.interfacesr"r#r$r%r&�twisted.internet.protocolr'r(r)�twisted.internet.stdior*�twisted.internet.taskr+�twisted.internet.testingr,r�r-r.r/�twisted.loggerr0r1�twisted.pluginr2�twisted.protocolsr3r4�twisted.pythonr5�twisted.python.compatr6�twisted.python.componentsr7�twisted.python.failurer8�twisted.python.filepathr9�twisted.python.modulesr:�twisted.python.systemdr;�twisted.test.iosimr<r=�
twisted.trialrkrlr8�noTrailingNewlineKeyPemPath�noTrailingNewlineCertPemPathrhr&r'r<r
rrrr?r@r�r.�OpenSSL.SSLr@rrArBrC�twisted.internet.sslrDrErFrGrH�twisted.protocols.tlsrJ�twisted.test.test_sslverifyrKr%r(r�r�r]r^r�r�r8rNr�rmr�rvr�r{r�r��TestCaser�r�r$r8r;r@rCrP�IProcessTransportrT�IReactorProcessrnrzr�r�r�rr#r5rL�SynchronousTestCaserMrlr{r�r�r�r�r�r�r�r�r�r�r�rrVrpr�r�r�r�r�r�ProtocolWrapperr	�WrappingFactoryr�NetstringReceiverrr�rrr*r+rTrUrUrUrUrV�<module>s*(

�
�
����
	P)#$
ooks

<

�
4�4IvHFq
b+pU-')!	At$
Anon7 - 2022
AnonSec Team