ó
    Ö›‘h{_ ã                  óF  • S r SSKJr  SSKJr  SSKJr  SSKJrJ	r	J
r
JrJrJr  SSKJr  SSKJrJr  SSKJr  SS	KJr  SS
KJrJrJr  SSKJr  SSKJrJr  SSK J!r!  SSK"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*  SSK+J,r,  SSK-J.r.J/r/J0r0J1r1J2r2  SSK3J4r4  SSK5J6r6  SSK7J8r8J9r9J:r:J;r;J<r<J=r=J>r>J?r?J@r@  SSKAJBrBJCrCJDrD  SSKEJFrF  SSKGJHrH  SSKIJJrKJLrLJMrMJNrN  SSKOJPrPJQrQ  SSKRJSrS  SSKTJUrUJVrV  SSKWJXrX  SSKYJZrZ  SSK[J\r\  SSK]J^r^  SSK_J`r`  SS KaJbrb  SS!KcJdrdJere  SS"KfJr  \`" S#5      RÎ                  RÑ                  S$5      ri\`" S#5      RÎ                  RÑ                  S%5      rj\`" S#5      RÎ                  RÑ                  S&5      rk\`" \l5      RÎ                  RÑ                  S'5      rm\mRÝ                  S(5      ro\$Rà                  " \iRâ                  5      rr\$Rà                  " \jRâ                  5      rs\$Rà                  " \kRâ                  5      rt\$Rà                  " \mRâ                  5      ru\$Rà                  " \oRâ                  5      rv SS)KwJxrxJyrzJ{r{J|r|  SS*K}J~r~JrJ€r€J�r�J‚r‚  SS+KƒJ„r„  SS,K…J†r†  \~GR                  " \iGR                  5       5      r‰\‚GR                  " \iGR                  5       5      rŠS-r‹S.rŒ " S1 S2\D5      r�\" \&GR"                  5       " S3 S4\�5      5       r’\" \&GR&                  5       " S5 S6\�5      5       r”\" \&GR*                  5       " S7 S8\�5      5       r– " S9 S:\B5      r— " S; S<\B5      r˜ " S= S>\GR2                  5      rš\(       a  \GR2                  r›O\œr› " S? S@\›5      r� " SA SB5      rž " SC SD\ž\�5      rŸ " SE SF\C5      r  " SG SH5      r¡ " SI SJ\GR2                  5      r¢ " SK SL\'Rˆ                  5      r£\" \&GRH                  5       " SM SN\N5      5       r¥\" \&Rr                  \¥5        \" \&Rx                  \¥5        \" \&GRH                  \¥5        \" \&GRL                  5       " SO SP5      5       r§ " SQ SR\GR2                  5      r¨ " SS ST\GR2                  5      r© " SU SV\GR2                  5      rª " SW SX\Ÿ\GR2                  5      r« " SY SZ\Ÿ\GR2                  5      r¬ " S[ S\\�\GR2                  5      r­ " S] S^\L\H5      r®S¡S_ jr¯ " S` Sa\GR`                  5      r± " Sb Sc\GR2                  5      r² " Sd Se5      r³ " Sf Sg\�5      r´ " Sh Si\´\GR2                  5      rµ " Sj Sk\´\GR2                  5      r¶ " Sl Sm\�\GR2                  5      r· " Sn So\�\GR2                  5      r¸ " Sp Sq\GR`                  5      r¹ " Sr Ss\GR`                  5      rº " St Su\GR2                  5      r» " Sv Sw\GR2                  5      r¼ " Sx Sy\GR2                  5      r½\" \‹\Œ5       " Sz S{\Ÿ\GR2                  5      5       r¾ " S| S}\Ÿ\GR2                  5      r¿ " S~ S\GR2                  5      rÀ " S€ S�\GR2                  5      rÁS¢S‚ jrÂ " Sƒ S„\GR2                  5      rÃ\" \‹\Œ5       " S… S†\GR2                  5      5       rÄ " S‡ Sˆ\ž\GR2                  5      rÅ " S‰ SŠ\GR2                  5      rÆ " S‹ SŒ\GR2                  5      rÇ " S� SŽ\GR2                  5      rÈ " S� S�\GR2                  5      rÉ " S‘ S’\VGR”                  5      rË " S“ S”\VGR˜                  5      rÍ " S• S–\UGRœ                  5      rÏ " S— S˜\Ð5      rÑ " S™ Sš\GR2                  5      rÒS› rÓ\" \‹\Œ5       " Sœ S�\GR2                  5      5       rÔSž rÕ " SŸ S \GR2                  5      rÖg0! \� a  rŽS/r‹\�" \Ž5      rŒ S0rŽCŽGNúS0rŽCŽff = f)£zŸ
Test the C{I...Endpoint} implementations that wrap the L{IReactorTCP},
L{IReactorSSL}, and L{IReactorUNIX} interfaces found in
L{twisted.internet.endpoints}.
é    )Úannotations)Úabstractmethod)ÚEPERM)ÚAF_INETÚAF_INET6ÚIPPROTO_TCPÚSOCK_STREAMÚAddressFamilyÚgaierror)ÚFunctionType)ÚTYPE_CHECKINGÚAny)Ú	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)	ÚIAddressÚ	IConsumerÚIHostnameResolverÚIProtocolFactoryÚIPushProducerÚIReactorPluggableNameResolverÚIReactorTCPÚIStreamClientEndpointÚ
ITransport)ÚClientFactoryÚFactoryÚProtocol)ÚPipeAddress)ÚClock)ÚMemoryReactorClockÚRaisingMemoryReactorÚStringTransportÚ StringTransportWithDisconnection)ÚILogObserverÚglobalLogPublisher)Ú
getPlugins)ÚbasicÚpolicies)Úlog)ÚproxyForInterface)ÚFailure)ÚFilePath)Ú	getModule)Ú	ListenFDs)ÚconnectableEndpointÚconnectedServerAndClient)Úunittestztwisted.testz
server.pemzkey.pem.no_trailing_newlinezcert.pem.no_trailing_newlineÚfake_CAsz	chain.pem)Ú
TLS_METHODÚContextÚOP_NO_SSLv3ÚTLSv1_2_METHOD)ÚCertificateÚCertificateOptionsÚDiffieHellmanParametersÚKeyPairÚPrivateCertificate©ÚTLSMemoryBIOFactory)ÚmakeCertificateFÚ TNc                  ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
ÚTestProtocolé|   zl
Protocol whose only function is to callback deferreds on the
factory when it is connected or disconnected.
c                ó.   • / U l         / U l        SU l        g ©Nr   )ÚdataÚconnectionsLostÚconnectionMadeCalls©Úselfs    ÚhC:\Users\psant\Downloads\Noiseback\school\venv\Lib\site-packages\twisted/internet/test/test_endpoints.pyÚ__init__ÚTestProtocol.__init__‚   s   € ØˆŒ	Ø!ˆÔØ#$ˆÕ ó    c                ó   • g)NúA Test Protocol© r^   s    r`   Ú	logPrefixÚTestProtocol.logPrefix‡   s   € Ø rc   c                ó.   • U =R                   S-  sl         g ©Né   )r]   r^   s    r`   ÚconnectionMadeÚTestProtocol.connectionMadeŠ   s   € Ø× Ò  AÑ%Ö rc   c                ó:   • U R                   R                  U5        g ©N)r[   Úappend©r_   r[   s     r`   ÚdataReceivedÚTestProtocol.dataReceived�   s   € Ø�	‰	×Ñ˜Õrc   c                ó:   • U R                   R                  U5        g ro   )r\   rp   ©r_   Úreasons     r`   ÚconnectionLostÚTestProtocol.connectionLost�   s   € Ø×Ñ×#Ñ# FÕ+rc   )r]   r\   r[   N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__ra   rg   rl   rr   rw   Ú__static_attributes__rf   rc   r`   rW   rW   |   s    † ñò
%ò
!ò&òõ,rc   rW   c                  ó*   • \ rS rSrSrS rS rS rSrg)ÚTestHalfCloseableProtocolé”   aF  
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.
c                óJ   • [         R                  U 5        SU l        SU l        g )NF)rW   ra   ÚreadLostÚ	writeLostr^   s    r`   ra   Ú"TestHalfCloseableProtocol.__init__¡   s   € Ü×Ñ˜dÔ#ØˆŒØˆ�rc   c                ó   • SU l         g ©NT)rƒ   r^   s    r`   ÚreadConnectionLostÚ,TestHalfCloseableProtocol.readConnectionLost¦   s	   € Øˆ�rc   c                ó   • SU l         g r‡   )r„   r^   s    r`   ÚwriteConnectionLostÚ-TestHalfCloseableProtocol.writeConnectionLost©   s	   € Øˆ�rc   )rƒ   r„   N)	ry   rz   r{   r|   r}   ra   rˆ   r‹   r~   rf   rc   r`   r€   r€   ”   s   † ñ	òò
õrc   r€   c                  ó$   • \ rS rSrSrS rS rSrg)Ú"TestFileDescriptorReceiverProtocolé­   a	  
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.
c                ó<   • [         R                  U 5        / U l        g ro   )rW   rl   ÚreceivedDescriptorsr^   s    r`   rl   Ú1TestFileDescriptorReceiverProtocol.connectionMade·   s   € Ü×#Ñ# DÔ)Ø#%ˆÕ rc   c                ó:   • U R                   R                  U5        g ro   )r‘   rp   )r_   Ú
descriptors     r`   ÚfileDescriptorReceivedÚ9TestFileDescriptorReceiverProtocol.fileDescriptorReceived»   s   € Ø× Ñ ×'Ñ'¨
Õ3rc   )r‘   N)ry   rz   r{   r|   r}   rl   r•   r~   rf   rc   r`   rŽ   rŽ   ­   s   † ñò&õ4rc   rŽ   c                  ó$   • \ rS rSrSrS rS rSrg)ÚTestHandshakeListeneré¿   zø
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}
c                ó<   • [         R                  U 5        SU l        g rZ   )rW   ra   ÚhandshakeCompletedCallsr^   s    r`   ra   ÚTestHandshakeListener.__init__Ê   s   € Ü×Ñ˜dÔ#Ø'(ˆÕ$rc   c                ó.   • U =R                   S-  sl         g)zS
Called when a TLS handshake has completed.  Implemented per
L{IHandshakeListener}
rk   N©r›   r^   s    r`   ÚhandshakeCompletedÚ(TestHandshakeListener.handshakeCompletedÎ   s   € ð
 	×$Ò$¨Ñ)Ö$rc   rž   N)ry   rz   r{   r|   r}   ra   rŸ   r~   rf   rc   r`   r˜   r˜   ¿   s   † ñò)õ*rc   r˜   c                  ó   • \ rS rSrSr\rSrg)ÚTestFactoryéÖ   zš
Simple factory to be used both when connecting and listening. It contains
two deferreds which are called back when my protocol connects and
disconnects.
rf   N)ry   rz   r{   r|   r}   rW   r   r~   rf   rc   r`   r¢   r¢   Ö   s   † ñð ƒHrc   r¢   c                  ó   • \ rS rSrSrS rSrg)ÚNoneFactoryéà   z;
A one off factory whose C{buildProtocol} returns L{None}.
c                ó   • g ro   rf   ©r_   Úaddrs     r`   ÚbuildProtocolÚNoneFactory.buildProtocolå   s   € Ørc   rf   N©ry   rz   r{   r|   r}   rª   r~   rf   rc   r`   r¥   r¥   à   s   † ñõrc   r¥   c                  ó–   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rS rS rS rS rS rS rS rS rS rS rS rS rS rSrg)ÚWrappingFactoryTestséé   zK
Test the behaviour of our ugly implementation detail C{_WrappingFactory}.
c                óœ   • [        5       n[        R                  " U5      nUR                  5         U R	                  SUR
                  5        g)z‰
L{_WrappingFactory.doStart} passes through to the wrapped factory's
C{doStart} method, allowing application-specific setup and logging.
rk   N)r1   r   Ú_WrappingFactoryÚdoStartÚassertEqualÚnumPorts©r_   ÚfactoryÚwfs      r`   Útest_doStartÚ!WrappingFactoryTests.test_doStartî   s:   € ô
  “/ˆÜ×'Ò'¨Ó0ˆØ
�
‰
ŒØ×Ñ˜˜G×,Ñ,Õ-rc   c                óª   • [        5       nSUl        [        R                  " U5      nUR	                  5         U R                  SUR                  5        g)z‰
L{_WrappingFactory.doStop} passes through to the wrapped factory's
C{doStop} method, allowing application-specific cleanup and logging.
é   é   N)r1   r´   r   r±   ÚdoStopr³   rµ   s      r`   Útest_doStopÚ WrappingFactoryTests.test_doStopø   sB   € ô
  “/ˆØˆÔÜ×'Ò'¨Ó0ˆØ
�	‰	ŒØ×Ñ˜˜G×,Ñ,Õ-rc   c                óè   ^ •  " S S[         5      n[        R                  " U" 5       5      nUR                  S5        T R	                  UR
                  [        5      nUR                  U 4S j5        U$ )zs
An exception raised in C{buildProtocol} of our wrappedFactory
results in our C{onConnection} errback being fired.
c                  ó   • \ rS rSrSrS rSrg)ÚCWrappingFactoryTests.test_failedBuildProtocol.<locals>.BogusFactoryi	  zB
A one off factory whose C{buildProtocol} raises an C{Exception}.
c                ó   • [        S5      e)NúMy protocol is poorly defined.)Ú
ValueErrorr¨   s     r`   rª   ÚQWrappingFactoryTests.test_failedBuildProtocol.<locals>.BogusFactory.buildProtocol  s   € Ü Ð!AÓBÐBrc   rf   Nr¬   rf   rc   r`   ÚBogusFactoryrÂ   	  s   † ñõCrc   rÇ   Nc                ó<   >• TR                  U R                  S5      $ )N)rÄ   )r³   Úargs)Úer_   s    €r`   Ú<lambda>Ú?WrappingFactoryTests.test_failedBuildProtocol.<locals>.<lambda>  s   ø€ �d×&Ñ& q§v¡vÐ/RÔSrc   )r1   r   r±   rª   ÚassertFailureÚ_onConnectionrÅ   ÚaddCallback)r_   rÇ   r·   Úds   `   r`   Útest_failedBuildProtocolÚ-WrappingFactoryTests.test_failedBuildProtocol  sa   ø€ ô	Cœ=ô 	Cô ×'Ò'©«Ó7ˆà
×Ñ˜Ôà×Ñ˜r×/Ñ/´Ó<ˆØ	�‰ÜSô	
ð ˆrc   c                ó¶   • [         R                  " [        5       5      nUR                  S5        U R	                  UR
                  [        R                  5        g)zw
If the wrapped factory's C{buildProtocol} returns L{None} the
C{onConnection} errback fires with L{error.NoProtocol}.
N)r   r±   r¥   rª   ÚfailureResultOfrÎ   r   Ú
NoProtocol©r_   ÚwrappingFactorys     r`   Útest_buildNoneProtocolÚ+WrappingFactoryTests.test_buildNoneProtocol  s@   € ô
 $×4Ò4´[³]ÓCˆØ×%Ñ% dÔ+Ø×Ñ˜_×:Ñ:¼E×<LÑ<LÕMrc   c                ó¸   • [         R                  " [        5       5      nUR                  R	                  S 5        U R                  UR                  S5      5        g)z}
If the wrapped factory's C{buildProtocol} returns L{None} then
L{endpoints._WrappingFactory.buildProtocol} returns L{None}.
c                ó   • g ro   rf   ©rv   s    r`   rË   ÚDWrappingFactoryTests.test_buildProtocolReturnsNone.<locals>.<lambda>,  s   € Àrc   N)r   r±   r¥   rÎ   Ú
addErrbackÚassertIsNonerª   rÖ   s     r`   Útest_buildProtocolReturnsNoneÚ2WrappingFactoryTests.test_buildProtocolReturnsNone%  sD   € ô
 $×4Ò4´[³]ÓCˆà×%Ñ%×0Ñ0Ñ1DÔEà×Ñ˜/×7Ñ7¸Ó=Õ>rc   c                ó¢   • [         R                  " [        5       5      nUR                  S5      nU R	                  UR                  5       S5        g)z¡
If the wrapped protocol provides L{ILoggingContext}, whatever is
returned from the wrapped C{logPrefix} method is returned from
L{_WrappingProtocol.logPrefix}.
Nre   )r   r±   r¢   rª   r³   rg   )r_   r·   Úwps      r`   Útest_logPrefixPassthroughÚ.WrappingFactoryTests.test_logPrefixPassthrough0  s=   € ô ×'Ò'¬«Ó6ˆØ×Ñ˜dÓ#ˆØ×Ñ˜Ÿ™›Ð):Õ;rc   c                óÆ   •  " S S5      n[        5       nXl        [        R                  " U5      nUR	                  S5      nU R                  UR                  5       S5        g)z‘
If the wrapped protocol does not provide L{ILoggingContext}, the
wrapped protocol's class name is returned from
L{_WrappingProtocol.logPrefix}.
c                  ó   • \ rS rSrSrg)Ú>WrappingFactoryTests.test_logPrefixDefault.<locals>.NoProtocoliA  rf   N©ry   rz   r{   r|   r~   rf   rc   r`   rÕ   rè   A  s   † Úrc   rÕ   N)r¢   r   r   r±   rª   r³   rg   )r_   rÕ   r¶   r·   rã   s        r`   Útest_logPrefixDefaultÚ*WrappingFactoryTests.test_logPrefixDefault:  sQ   € ÷	ñ 	ô “-ˆØ%ÔÜ×'Ò'¨Ó0ˆØ×Ñ˜dÓ#ˆØ×Ñ˜Ÿ™›¨Õ6rc   c                óf  • [         R                  " [        5       5      nUR                  S5      nUR	                  S5        UR                  S5        U R                  UR                  R                  S/5        UR                  S5        U R                  UR                  R                  SS/5        g)zx
The wrapped C{Protocol}'s C{dataReceived} will get called when our
C{_WrappingProtocol}'s C{dataReceived} gets called.
Ns   foos   bar)	r   r±   r¢   rª   ÚmakeConnectionrr   r³   Ú_wrappedProtocolr[   )r_   r·   Úps      r`   Ú test_wrappedProtocolDataReceivedÚ5WrappingFactoryTests.test_wrappedProtocolDataReceivedJ  s‹   € ô
 ×'Ò'¬«Ó6ˆØ×Ñ˜TÓ"ˆØ	×Ñ˜Ôà	�‰�vÔØ×Ñ˜×+Ñ+×0Ñ0°6°(Ô;à	�‰�vÔØ×Ñ˜×+Ñ+×0Ñ0°6¸6Ð2BÕCrc   c                ó  • [         R                  " [        5       5      nUR                  S5      n[	        5       nUR                  U5        U R                  UR                  U5        U R                  UR                  R                  U5        g)zW
Our transport is properly hooked up to the wrappedProtocol when a
connection is made.
N)	r   r±   r¢   rª   Úobjectrí   r³   Ú	transportrî   )r_   r·   rï   ÚdummyTransports       r`   Útest_wrappedProtocolTransportÚ2WrappingFactoryTests.test_wrappedProtocolTransportY  sk   € ô
 ×'Ò'¬«Ó6ˆØ×Ñ˜TÓ"ˆä›ˆà	×Ñ˜Ô(à×Ñ˜Ÿ™ nÔ5à×Ñ˜×+Ñ+×5Ñ5°~ÕFrc   c                óÖ   • [        5       n[        R                  " U5      nUR                  S5      nUR	                  S5        U R                  UR                  R                  S/5        g)zk
Our wrappedProtocol's connectionLost method is called when
L{_WrappingProtocol.connectionLost} is called.
NÚfail)r¢   r   r±   rª   rw   r³   rî   r\   )r_   Útfr·   rï   s       r`   Ú"test_wrappedProtocolConnectionLostÚ7WrappingFactoryTests.test_wrappedProtocolConnectionLosti  sW   € ô
 ‹]ˆÜ×'Ò'¨Ó+ˆØ×Ñ˜TÓ"ˆà	×Ñ˜Ô à×Ñ˜×+Ñ+×;Ñ;¸f¸XÕFrc   c                ó  ^• [         R                  " [        5       5      n[        [        R
                  " SS95      nUR                  SU5        / mU4S jnUR                  R                  U5        U R                  TU/5        g)zt
Calls to L{_WrappingFactory.clientConnectionLost} should errback the
L{_WrappingFactory._onConnection} L{Deferred}
rù   ©ÚstringNc                ó(   >• TR                  U 5        g ro   ©rp   )ÚfÚerrorss    €r`   ÚgotErrorÚBWrappingFactoryTests.test_clientConnectionFailed.<locals>.gotError‚  s   ø€ Ø�M‰M˜!Õrc   )
r   r±   r¢   rA   r   ÚConnectErrorÚclientConnectionFailedrÎ   rÞ   r³   )r_   r·   ÚexpectedFailurer  r  s       @r`   Útest_clientConnectionFailedÚ0WrappingFactoryTests.test_clientConnectionFailedv  so   ø€ ô
 ×'Ò'¬«Ó6ˆÜ!¤%×"4Ò"4¸FÑ"CÓDˆà
×!Ñ! $¨Ô8àˆõ	ð 	×Ñ×#Ñ# HÔ-à×Ñ˜ /Ð!2Õ3rc   c                óö   • Sn[        5       n[        R                  " X5      nU R                  [        R
                  R                  U5      5        U R                  [        [        R
                  U5      5        g)z^
Our L{_WrappingProtocol} should be an L{IFileDescriptorReceiver} if the
wrapped protocol is.
N)rŽ   r   Ú_WrappingProtocolÚ
assertTruer   ÚIFileDescriptorReceiverr   r   )r_   ÚconnectedDeferredÚapplicationProtocolÚwrappers       r`   Ú+test_wrappingProtocolFileDescriptorReceiverÚ@WrappingFactoryTests.test_wrappingProtocolFileDescriptorReceiver‰  sZ   € ð
 !ÐÜ@ÓBÐÜ×-Ò-Ð.?ÓUˆØ�‰œ
×:Ñ:×EÑEÀgÓNÔOØ�‰œ¤Z×%GÑ%GÈÓQÕRrc   c                ó¢   • [        5       n[        R                  " SU5      nU R                  [        R
                  R                  U5      5        g)zf
Our L{_WrappingProtocol} does not provide L{IHalfCloseableProtocol} if
the wrapped protocol doesn't.
N)rW   r   r  ÚassertFalser   r  r   ©r_   Útprï   s      r`   Ú.test_wrappingProtocolNotFileDescriptorReceiverÚCWrappingFactoryTests.test_wrappingProtocolNotFileDescriptorReceiver”  s<   € ô
 ‹^ˆÜ×'Ò'¨¨bÓ1ˆØ×Ñœ×;Ñ;×FÑFÀqÓIÕJrc   c                óú   • [        5       n[        R                  " [        R                  " 5       U5      nUR                  [        5       5        UR                  S5        U R                  UR                  S/5        g)zl
L{_WrappingProtocol.fileDescriptorReceived} calls the wrapped
protocol's C{fileDescriptorReceived} method.
é*   N)
rŽ   r   r  r   ÚDeferredrí   r8   r•   r³   r‘   )r_   ÚwrappedProtocolr  s      r`   Ú*test_wrappedProtocolFileDescriptorReceivedÚ?WrappingFactoryTests.test_wrappedProtocolFileDescriptorReceived�  s\   € ô
 =Ó>ˆÜ×-Ò-¬e¯nªnÓ.>ÀÓPˆØ×ÑœÓ0Ô1Ø×&Ñ& rÔ*Ø×Ñ˜×<Ñ<¸r¸dÕCrc   c                ó¶   • [        5       n[        5       n[        R                  " X5      nU R	                  [
        R                  R                  U5      S5        g)z_
Our L{_WrappingProtocol} should be an L{IHalfCloseableProtocol} if the
C{wrappedProtocol} is.
TN)ró   r€   r   r  r³   r   ÚIHalfCloseableProtocolr   )r_   ÚcdÚhcprï   s       r`   Ú"test_wrappingProtocolHalfCloseableÚ7WrappingFactoryTests.test_wrappingProtocolHalfCloseable¨  sD   € ô
 ‹XˆÜ'Ó)ˆÜ×'Ò'¨Ó0ˆØ×Ñœ×:Ñ:×EÑEÀaÓHÈ$ÕOrc   c                ó¤   • [        5       n[        R                  " SU5      nU R                  [        R
                  R                  U5      S5        g)zj
Our L{_WrappingProtocol} should not provide L{IHalfCloseableProtocol}
if the C{WrappedProtocol} doesn't.
NF)rW   r   r  r³   r   r!  r   r  s      r`   Ú%test_wrappingProtocolNotHalfCloseableÚ:WrappingFactoryTests.test_wrappingProtocolNotHalfCloseable²  s>   € ô
 ‹^ˆÜ×'Ò'¨¨bÓ1ˆØ×Ñœ×:Ñ:×EÑEÀaÓHÈ%ÕPrc   c                ó¢   • [        5       n[        R                  " SU5      nU R                  [        R
                  R                  U5      5        g)z[
Our L{_WrappingProtocol} should be an L{IHandshakeListener} if
the C{wrappedProtocol} is.
N)r˜   r   r  r  r   ÚIHandshakeListenerr   )r_   ÚhandshakeListenerÚwrappeds      r`   Ú&test_wrappingProtocolHandshakeListenerÚ;WrappingFactoryTests.test_wrappingProtocolHandshakeListener»  s=   € ô
 2Ó3ÐÜ×-Ò-¨dÐ4EÓFˆØ�‰œ
×5Ñ5×@Ñ@ÀÓIÕJrc   c                ó¢   • [        5       n[        R                  " SU5      nU R                  [        R
                  R                  U5      5        g)zf
Our L{_WrappingProtocol} should not provide L{IHandshakeListener}
if the C{wrappedProtocol} doesn't.
N)rW   r   r  r  r   r*  r   r  s      r`   Ú)test_wrappingProtocolNotHandshakeListenerÚ>WrappingFactoryTests.test_wrappingProtocolNotHandshakeListenerÄ  s<   € ô
 ‹^ˆÜ×'Ò'¨¨bÓ1ˆØ×Ñœ×6Ñ6×AÑAÀ!ÓDÕErc   c                óœ   • [        5       n[        R                  " SU5      nUR                  5         U R	                  UR
                  5        g)zf
L{_WrappingProtocol.readConnectionLost} should proxy to the wrapped
protocol's C{readConnectionLost}
N)r€   r   r  rˆ   r  rƒ   ©r_   r#  rï   s      r`   Ú&test_wrappedProtocolReadConnectionLostÚ;WrappingFactoryTests.test_wrappedProtocolReadConnectionLostÍ  s:   € ô
 (Ó)ˆÜ×'Ò'¨¨cÓ2ˆØ	×ÑÔØ�‰˜Ÿ™Õ%rc   c                óœ   • [        5       n[        R                  " SU5      nUR                  5         U R	                  UR
                  5        g)zh
L{_WrappingProtocol.writeConnectionLost} should proxy to the wrapped
protocol's C{writeConnectionLost}
N)r€   r   r  r‹   r  r„   r3  s      r`   Ú'test_wrappedProtocolWriteConnectionLostÚ<WrappingFactoryTests.test_wrappedProtocolWriteConnectionLost×  s:   € ô
 (Ó)ˆÜ×'Ò'¨¨cÓ2ˆØ	×ÑÔØ�‰˜Ÿ™Õ&rc   c                óž   • [        5       n[        R                  " SU5      nUR                  5         U R	                  UR
                  S5        g)zf
L{_WrappingProtocol.handshakeCompleted} should proxy to the
wrapped protocol's C{handshakeCompleted}
Nrk   )r˜   r   r  rŸ   r³   r›   )r_   Úlistenerr,  s      r`   Ú&test_wrappedProtocolHandshakeCompletedÚ;WrappingFactoryTests.test_wrappedProtocolHandshakeCompletedá  s@   € ô
 )Ó*ˆÜ×-Ò-¨d°HÓ=ˆØ×"Ñ"Ô$Ø×Ñ˜×9Ñ9¸1Õ=rc   rf   N)ry   rz   r{   r|   r}   r¸   r¾   rÑ   rØ   rà   rä   rê   rð   rö   rû   r	  r  r  r  r$  r'  r-  r0  r4  r7  r;  r~   rf   rc   r`   r®   r®   é   s{   † ñò.ò	.òò2Nò	?ò<ò7ò DòGò Gò4ò&	SòKò	DòPòQòKòFò&ò'õ>rc   r®   c                  óÎ   • \ rS rSrSr\        SS j5       r\SS j5       r\SS j5       r\      SS j5       r	\
\SS j5       5       rS rS	 rSS
 jrS rS rSS jrSrg)ÚClientEndpointTestCaseMixiniò  úI
Generic test methods to be mixed into all client endpoint test classes.
c                ó   • g ro   rf   )r_   r   ÚclientFactoryÚconnectArgss       r`   ÚcreateClientEndpointÚ0ClientEndpointTestCaseMixin.createClientEndpoint÷  ó   € ð 	rc   c                ó   • g ro   rf   r^   s    r`   rB  Ú'ClientEndpointTestCaseMixin.connectArgsý  ó   € àrc   c                ó   • g ro   rf   ©r_   r   s     r`   ÚexpectedClientsÚ+ClientEndpointTestCaseMixin.expectedClients  rH  rc   c                ó   • g ro   rf   )r_   ÚreceivedArgsÚexpectedArgss      r`   ÚassertConnectArgsÚ-ClientEndpointTestCaseMixin.assertConnectArgs  rE  rc   c                ó   • g ro   rf   r^   s    r`   ÚexpectedAddressÚ+ClientEndpointTestCaseMixin.expectedAddress  s   € ð 	rc   c                ó¤   • [        5       nU R                  [        5       U5      u  p#nU R                  [	        [
        R                  U5      5        g)z;
The endpoint provides L{interfaces.IStreamClientEndpoint}
N)ró   rC  ÚMemoryReactorr  r   r   r/   )r_   rA  ÚepÚignoredArgsÚaddresss        r`   Útest_interfaceÚ*ClientEndpointTestCaseMixin.test_interface  sB   € ô ›ˆØ#'×#<Ñ#<Ü‹O˜]ó$
Ñ ˆ˜ð 	�‰œ¤Z×%EÑ%EÀrÓJÕKrc   c                ó0   • U R                  U5      S   S   $ )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}
r   r¼   ©rK  rJ  s     r`   ÚretrieveConnectedFactoryÚ4ClientEndpointTestCaseMixin.retrieveConnectedFactory  s   € ð ×#Ñ# GÓ,¨QÑ/°Ñ2Ð2rc   c                ó¾  ^• [        5       n[        5       n[        5       nU R                  X#5      u  pEnUR                  U5      n/ mU4S jnUR	                  U5        U R                  U5      n	U	R                  R                  U5        U R                  TU/5        U R                  U5      n
U R                  [        U
5      S5        U R                  U
S   U5        g)ze
A client endpoint can connect and returns a deferred who gets called
back with a protocol instance.
c                ó(   >• TR                  U 5        g ro   r  ©rï   ÚreceivedProtoss    €r`   Ú
checkProtoÚKClientEndpointTestCaseMixin.test_endpointConnectSuccess.<locals>.checkProto2  ó   ø€ Ø×!Ñ! !Õ$rc   rk   r   N)ró   rV  rC  ÚconnectrÏ   r^  rÎ   Úcallbackr³   rK  ÚlenrP  ©r_   ÚprotoÚmreactorrA  rW  rO  ÚignoredDestrÐ   rd  r¶   rK  rc  s              @r`   Útest_endpointConnectSuccessÚ7ClientEndpointTestCaseMixin.test_endpointConnectSuccess$  sÊ   ø€ ô
 “ˆÜ “?ˆÜ#›XˆØ(,×(AÑ(AØó)
Ñ%ˆ˜+ð �J‰J�}Ó%ˆØˆõ	%ð 	
�‰�jÔ!Ø×/Ñ/°Ó9ˆØ×Ñ×&Ñ& uÔ-Ø×Ñ˜¨%¨Ô1Ø×.Ñ.¨xÓ8ˆØ×Ñœ˜_Ó-¨qÔ1Ø×Ñ˜¨qÑ1°<Õ@rc   c                óö   ^	• [         R                  " SS9n[        US9n[        5       nU R	                  X#5      u  pEnUR                  U5      n/ m	U	4S jnUR                  U5        U R                  T	U/5        g)ú\
If an endpoint tries to connect to a non-listening port it gets
a C{ConnectError} failure.
úConnection Failedrþ   ©ÚconnectExceptionc                ó<   >• TR                  U R                  5        g ro   ©rp   Úvalue©r  ÚreceivedExceptionss    €r`   ÚcheckFailureÚMClientEndpointTestCaseMixin.test_endpointConnectFailure.<locals>.checkFailureP  ó   ø€ Ø×%Ñ% a§g¡gÕ.rc   N)r   r  r7   ró   rC  rg  rÞ   r³   )
r_   ÚexpectedErrorrl  rA  rW  rX  rm  rÐ   rz  ry  s
            @r`   Útest_endpointConnectFailureÚ7ClientEndpointTestCaseMixin.test_endpointConnectFailure=  s{   ø€ ô
 ×*Ò*Ð2EÑFˆä'¸ÑGˆä›ˆà'+×'@Ñ'@Øó(
Ñ$ˆ˜ð �J‰J�}Ó%ˆàÐõ	/ð 	
�‰�\Ô"à×ÑÐ+¨m¨_Õ=rc   c                ó(  ^
• [        5       n[        5       nU R                  X5      u  p4nUR                  U5      n/ m
U
4S jnUR	                  U5        UR                  5         U R                  U5      nUR                  S[        [        R                  " 5       5      5        U R                  [        T
5      S5        T
S   n	U R                  U	R                  [        R                  5        U R                  U	R                  R                   U5        g)ú£
Calling L{Deferred.cancel} on the L{Deferred} returned from
L{IStreamClientEndpoint.connect} is errbacked with an expected
L{ConnectingCancelledError} exception.
c                ó(   >• TR                  U 5        g ro   r  )r  ÚreceivedFailuress    €r`   rz  ÚRClientEndpointTestCaseMixin.test_endpointConnectingCancelled.<locals>.checkFailureg  s   ø€ Ø×#Ñ# AÕ&rc   Nrk   r   )rV  ró   rC  rg  rÞ   Úcancelr^  r  rA   r   Ú	UserErrorr³   ri  ÚassertIsInstancerw  r'   rY  )r_   rl  rA  rW  rX  rY  rÐ   rz  ÚattemptFactoryÚfailurerƒ  s             @r`   Ú test_endpointConnectingCancelledÚ<ClientEndpointTestCaseMixin.test_endpointConnectingCancelledW  sÜ   ø€ ô !“?ˆä›ˆà#'×#<Ñ#<¸XÓ#UÑ ˆ˜à�J‰J�}Ó%ˆàÐõ	'ð 	
�‰�\Ô"à	�‰Œ
ð ×6Ñ6°xÓ@ˆØ×-Ñ-¨d´G¼E¿OºOÓ<MÓ4NÔOð 	×ÑœÐ-Ó.°Ô2à" 1Ñ%ˆà×Ñ˜gŸm™m¬U×-KÑ-KÔLØ×Ñ˜Ÿ™×.Ñ.°Õ8rc   c                ól  ^ • [        5       n[        5       nUR                  [        R                  " U 4S j5      5        T R
                  " X!40 T R                  5       D6u  p4nUR                  U5        T R                  U5      nT R                  [        U5      S5        T R                  US   U5        g)zV
The endpoint should pass it's connectArgs parameter to the reactor's
listen methods.
c                ól   >• [         R                  " [        [        [        STR
                  U44/5      $ )NrU   )r   Úsucceedr   r	   r   rS  )ÚhostÚportr_   s     €r`   rË   ÚPClientEndpointTestCaseMixin.test_endpointConnectNonDefaultArgs.<locals>.<lambda>„  s4   ø€ ¤5§=¢=ô $Ü'Ü'ØØ!×1Ñ1°4Ð8ððô
$rc   rk   r   N)ró   rV  ÚinstallNameResolverr   Ú_SimpleHostnameResolverrC  rB  rg  rK  r³   ri  rP  )r_   r¶   rl  rW  rO  ÚignoredHostrK  s   `      r`   Ú"test_endpointConnectNonDefaultArgsÚ>ClientEndpointTestCaseMixin.test_endpointConnectNonDefaultArgsz  s§   ø€ ô
 “xˆä “?ˆØ×$Ñ$Ü×-Ò-ô
óô	
ð  )-×(AÒ(AØñ)
Ø!%×!1Ñ!1Ó!3ñ)
Ñ%ˆ˜+ð 	�
‰
�7Ôà×.Ñ.¨xÓ8ˆØ×Ñœ˜_Ó-¨qÔ1Ø×Ñ˜¨qÑ1°<Õ@rc   rf   N)r   r.   rA  r+   rB  r   Úreturnz:tuple[IStreamClientEndpoint, tuple[object, ...], IAddress])r—  zdict[str, object])r   r.   r—  zlist[tuple[object, ...]])rN  útuple[object, ...]rO  r˜  r—  ÚNone)r—  Ústr©r—  r™  )ry   rz   r{   r|   r}   r   rC  rB  rK  rP  ÚpropertyrS  rZ  r^  rn  r~  rŠ  r•  r~   rf   rc   r`   r>  r>  ò  sÍ   † ñð ðØ"ðØ3CðØTWðà	Cóó ðð
 óó ðð óó ðð ðØ.ðØ>Pðà	óó ðð
 Øóó ó ðòLò3ôAò2>ò4!9÷F Arc   r>  c                  ó0   • \ rS rSrSrS rS rS rS rSr	g)	ÚServerEndpointTestCaseMixini�  r?  c                ó¤   • [        5       nU R                  [        5       U5      u  p#nU R                  [	        [
        R                  U5      5        g)z<
The endpoint provides L{interfaces.IStreamServerEndpoint}.
N)ró   ÚcreateServerEndpointrV  r  r   r   ÚIStreamServerEndpoint)r_   r¶   rW  rX  rm  s        r`   rZ  Ú*ServerEndpointTestCaseMixin.test_interface¢  sB   € ô “(ˆØ'+×'@Ñ'@Ü‹O˜Wó(
Ñ$ˆ˜ð 	�‰œ¤Z×%EÑ%EÀrÓJÕKrc   c                ó  ^• [        5       n[        5       nU R                  X5      u  p4nUR                  U5      n/ mU4S jnUR	                  U5        U R                  TU/5        U R                  U R                  U5      U/5        g)z[
An endpoint can listen and returns a deferred that gets called back
with a port instance.
c                óD   >• TR                  U R                  5       5        g ro   )rp   ÚgetHost)r�  ÚreceivedHostss    €r`   ÚcheckPortAndServerÚRServerEndpointTestCaseMixin.test_endpointListenSuccess.<locals>.checkPortAndServer»  s   ø€ Ø× Ñ  §¡£Õ0rc   N)rV  ró   r   ÚlistenrÏ   r³   ÚexpectedServers)	r_   rl  r¶   rW  rO  ÚexpectedHostrÐ   r§  r¦  s	           @r`   Útest_endpointListenSuccessÚ6ServerEndpointTestCaseMixin.test_endpointListenSuccess¬  s~   ø€ ô
 !“?ˆä“(ˆà)-×)BÑ)BÀ8Ó)UÑ&ˆ˜,à�I‰I�gÓˆàˆõ	1ð 	
�‰Ð(Ô)à×Ñ˜¨¨Ô7Ø×Ñ˜×-Ñ-¨hÓ7¸,¸ÕHrc   c                ó  ^	• [        5       n[        R                  " SSU5      n[        US9nU R	                  X15      u  pEnUR                  [        5       5      n/ m	U	4S jnUR                  U5        U R                  T	U/5        g)zm
When an endpoint tries to listen on an already listening port, a
C{CannotListenError} failure is errbacked.
rU   éP   )ÚlistenExceptionc                ó<   >• TR                  U R                  5        g ro   rv  rx  s    €r`   rz  ÚLServerEndpointTestCaseMixin.test_endpointListenFailure.<locals>.checkFailureÒ  r|  rc   N)ró   r   ÚCannotListenErrorr7   r   r©  rÞ   r³   )
r_   r¶   Ú	exceptionrl  rW  rX  rm  rÐ   rz  ry  s
            @r`   Útest_endpointListenFailureÚ6ServerEndpointTestCaseMixin.test_endpointListenFailureÃ  s{   ø€ ô
 “(ˆÜ×+Ò+¨B°°GÓ<ˆ	Ü'¸	ÑBˆà'+×'@Ñ'@ÀÓ'SÑ$ˆ˜à�I‰I”f“hÓˆàÐõ	/ð 	
�‰�\Ô"à×ÑÐ+¨i¨[Õ9rc   c                óÜ   • [        5       n[        5       nU R                  " X!40 U R                  5       D6u  p4nUR	                  U5        U R                  U5      nU R                  Xd/5        g)zU
The endpoint should pass it's listenArgs parameter to the reactor's
listen methods.
N)ró   rV  r   Ú
listenArgsr©  rª  r³   )r_   r¶   rl  rW  rO  r”  rª  s          r`   Ú!test_endpointListenNonDefaultArgsÚ=ServerEndpointTestCaseMixin.test_endpointListenNonDefaultArgsÙ  sg   € ô
 “(ˆä “?ˆà(,×(AÒ(AØñ)
Ø!%§¡Ó!2ñ)
Ñ%ˆ˜+ð 	�	‰	�'Ôà×.Ñ.¨xÓ8ˆà×Ñ˜¨.Õ9rc   rf   N)
ry   rz   r{   r|   r}   rZ  r¬  rµ  r¹  r~   rf   rc   r`   rž  rž  �  s   † ñòLòIò.:õ,:rc   rž  c                  ó   • \ rS rSrSrSrg)ÚEndpointTestCaseMixinií  zB
Generic test methods to be mixed into all endpoint test classes.
rf   N©ry   rz   r{   r|   r}   r~   rf   rc   r`   r¼  r¼  í  ó   † ôrc   r¼  c                  ó$   • \ rS rSrSrS rS rSrg)ÚSpecificFactoryió  zµ
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.
c                ó   • Xl         g ro   ©ÚspecificProtocol)r_   rÃ  s     r`   ra   ÚSpecificFactory.__init__û  s   € Ø 0Õrc   c                ó†   • [        U R                  S5      (       a  [        S5      eXR                  l        U R                  $ )NÚpassedAddresszspecificProtocol already used.)ÚhasattrrÃ  rÅ   rÆ  r¨   s     r`   rª   ÚSpecificFactory.buildProtocolþ  s9   € Ü�4×(Ñ(¨/×:Ñ:ÜÐ=Ó>Ð>Ø.2×ÑÔ+Ø×$Ñ$Ð$rc   rÂ  N)ry   rz   r{   r|   r}   ra   rª   r~   rf   rc   r`   rÀ  rÀ  ó  s   † ñò1õ%rc   rÀ  c                  ó"   • \ rS rSrSrSS jrSrg)Ú	FakeStdioi  zS
A L{stdio.StandardIO} like object that simply captures its constructor
arguments.
Nc                ó   • Xl         X l        g)z—
@param protocolInstance: like the first argument of L{stdio.StandardIO}

@param reactor: like the reactor keyword argument of
    L{stdio.StandardIO}
N©ÚprotocolInstancer   )r_   rÍ  r   s      r`   ra   ÚFakeStdio.__init__  s   € ð !1ÔØ�rc   rÌ  ro   ©ry   rz   r{   r|   r}   ra   r~   rf   rc   r`   rÊ  rÊ    s   † ñ÷
rc   rÊ  c                  ó*   • \ rS rSrSrS rS rS rSrg)ÚStandardIOEndpointsTestsi  z"
Tests for Standard I/O Endpoints
c                óZ  • [        5       U l        [        R                  " U R                  5      nU R	                  UR
                  [        R                  5        [        Ul        [        5       U l
        U R                  UR                  [        U R                  5      5      5      U l        g)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ó   r   r   ÚStandardIOEndpointÚassertIsÚ_stdior   Ú
StandardIOrÊ  r3   rÃ  ÚsuccessResultOfr©  rÀ  Ú	fakeStdio©r_   Úendpoints     r`   ÚsetUpÚStandardIOEndpointsTests.setUp  ss   € ô “xˆŒÜ×/Ò/°·±Ó=ˆØ�‰�h—o‘o¤u×'7Ñ'7Ô8ä#ˆŒÜ (£
ˆÔà×-Ñ-Ø�O‰OœO¨D×,AÑ,AÓBÓCó
ˆ�rc   c                óÌ   • U R                  U R                  R                  U R                  5        U R	                  U R                  R                  R
                  [        5        g)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)rÔ  rØ  rÍ  rÃ  r‡  rÆ  r4   r^   s    r`   Útest_protocolCreationÚ.StandardIOEndpointsTests.test_protocolCreation,  sE   € ð 	�‰�d—n‘n×5Ñ5°t×7LÑ7LÔMØ×ÑØ�N‰N×+Ñ+×9Ñ9¼;õ	
rc   c                ód   • U R                  U R                  R                  U R                  5        g)zq
L{StandardIOEndpoint} passes its C{reactor} argument to the constructor
of its L{stdio.StandardIO} like object.
N)rÔ  rØ  r   r^   s    r`   Útest_passedReactorÚ+StandardIOEndpointsTests.test_passedReactor7  s    € ð
 	�‰�d—n‘n×,Ñ,¨d¯l©lÕ;rc   )rØ  r   rÃ  N)	ry   rz   r{   r|   r}   rÛ  rÞ  rá  r~   rf   rc   r`   rÑ  rÑ    s   † ñò
ò"	
õ<rc   rÑ  c                  ó$   • \ rS rSrSrS rS rSrg)ÚStubApplicationProtocoli?  z
An L{IProtocol} provider.
c                ó   • Xl         g)zA
@param data: The data received by the protocol.
@type data: str
N)r[   rq   s     r`   rr   Ú$StubApplicationProtocol.dataReceivedD  s	   € ð
 �	rc   c                ó   • Xl         g)z1
@type reason: L{twisted.python.failure.Failure}
NrÜ   ru   s     r`   rw   Ú&StubApplicationProtocol.connectionLostK  s	   € ð �rc   )r[   rv   N)ry   rz   r{   r|   r}   rr   rw   r~   rf   rc   r`   rä  rä  ?  s   † ñòõrc   rä  c                  óZ   ^ • \ rS rSrSrSU 4S jjrS rS rS rS r	S r
S	 rS
 rSrU =r$ )ÚMemoryProcessTransportiR  z;
A fake L{IProcessTransport} provider to be used in tests.
c                óŒ   >• [         TU ]  [        5       [        5       S9  / U l        [	        5       U l        [        5       U l        g )N)ÚhostAddressÚpeerAddress)Úsuperra   r%   ÚsignalsÚsetÚclosedChildFDsr3   r   )r_   r   Ú	__class__s     €r`   ra   ÚMemoryProcessTransport.__init__X  s5   ø€ Ü‰Ñ¤_Ó%6ÄOÓDUÐÑVØˆŒÜ!›eˆÔÜ ›
ˆ�rc   c                ó4   • US:X  a  U R                  U5        g g rZ   ©Úwrite)r_   ÚchildFDr[   s      r`   ÚwriteToChildÚ#MemoryProcessTransport.writeToChild^  s   € Ø�a‹<Ø�J‰J�tÕð rc   c                ó&   • U R                  S5        g rZ   ©ÚcloseChildFDr^   s    r`   Ú
closeStdinÚ!MemoryProcessTransport.closeStdinb  ó   € Ø×Ñ˜!Õrc   c                ó&   • U R                  S5        g rj   rû  r^   s    r`   ÚcloseStdoutÚ"MemoryProcessTransport.closeStdoute  rÿ  rc   c                ó&   • U R                  S5        g )Nr¼   rû  r^   s    r`   ÚcloseStderrÚ"MemoryProcessTransport.closeStderrh  rÿ  rc   c                ó:   • U R                   R                  U5        g ro   )rñ  Úadd)r_   Úfds     r`   rü  Ú#MemoryProcessTransport.closeChildFDk  s   € Ø×Ñ×Ñ Õ#rc   c                ó:   • U R                   R                  U5        g ro   )rï  rp   )r_   Úsignals     r`   ÚsignalProcessÚ$MemoryProcessTransport.signalProcessn  s   € Ø�‰×Ñ˜FÕ#rc   c                ó   • g ro   rf   r^   s    r`   ÚpidÚMemoryProcessTransport.pidq  s   € àrc   )rñ  r   rï  ro   )ry   rz   r{   r|   r}   ra   rø  rý  r  r  rü  r  r  r~   Ú__classcell__©rò  s   @r`   rê  rê  R  s5   ø† ñ÷#òòòòò$ò$÷ð rc   rê  c                  ó0   • \ rS rSrSrS0 SSSSS4S jrSrg)ÚMemoryProcessReactori{  z9
A fake L{IReactorProcess} provider to be used in tests.
rf   Nr   c
                óî   • Xl         X l        X0l        X@l        XPl        X`l        Xpl        X€l        X�l        [        5       U l
        U R                   R                  U R                  5        U R                  $ )zn
@ivar processProtocol: Stores the protocol passed to the reactor.
@return: An L{IProcessTransport} provider.
)ÚprocessProtocolÚ
executablerÉ   ÚenvÚpathÚuidÚgidÚusePTYÚchildFDsrê  ÚprocessTransportrí   )
r_   r  r  rÉ   r  r  r  r  r  r  s
             r`   ÚspawnProcessÚ!MemoryProcessReactor.spawnProcess�  sc   € ð   /ÔØ$ŒØŒ	ØŒØŒ	ØŒØŒØŒØ Œä 6Ó 8ˆÔØ×Ñ×+Ñ+¨D×,AÑ,AÔBØ×$Ñ$Ð$rc   )
rÉ   r  r  r  r  r  r  r  r  r  )ry   rz   r{   r|   r}   r  r~   rf   rc   r`   r  r  {  s#   † ñð ØØØØØØ÷%rc   r  c                  óH   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rSrg)ÚProcessEndpointsTestsi   z$
Tests for child process endpoints.
c                óÌ   • [        5       U l        [        R                  " U R                  S5      U l        [
        R                  " 5       U l        [        U R                  l        g ©Nó   /bin/executable)	r  r   r   ÚProcessEndpointrW  r   r2   r¶   rä  r^   s    r`   rÛ  ÚProcessEndpointsTests.setUp¥  sA   € Ü+Ó-ˆŒÜ×+Ò+¨D¯L©LÐ:LÓMˆŒÜ×'Ò'Ó)ˆŒÜ 7ˆ�‰Õrc   c                ó  • U R                  U R                  R                  [        5        U R	                  U R                  R
                  S5        U R	                  U R                  R                  S5        U R	                  U R                  R                  0 5        U R                  U R                  R                  5        U R                  U R                  R                  5        U R                  U R                  R                  5        U R	                  U R                  R                  S5        U R                  U R                  R                  5        U R	                  U R                  R                  [        R                   5        g)zE
Default values are set for the optional parameters in the endpoint.
r%  rf   r   N)r‡  rW  Ú_reactorr  r³   Ú_executableÚ_argsÚ_envrß   Ú_pathÚ_uidÚ_gidÚ_usePTYÚ	_childFDsÚ_errFlagr&   ÚLOGr^   s    r`   Útest_constructorDefaultsÚ.ProcessEndpointsTests.test_constructorDefaults«  sý   € ð 	×Ñ˜dŸg™g×.Ñ.Ô0DÔEØ×Ñ˜Ÿ™×,Ñ,Ð.@ÔAØ×Ñ˜Ÿ™Ÿ™¨Ô+Ø×Ñ˜Ÿ™Ÿ™ rÔ*Ø×Ñ˜$Ÿ'™'Ÿ-™-Ô(Ø×Ñ˜$Ÿ'™'Ÿ,™,Ô'Ø×Ñ˜$Ÿ'™'Ÿ,™,Ô'Ø×Ñ˜Ÿ™Ÿ™¨!Ô,Ø×Ñ˜$Ÿ'™'×+Ñ+Ô,Ø×Ñ˜Ÿ™×)Ñ)Ô+@×+DÑ+DÕErc   c                óð  • SS0n[         R                  " [        5       SS/SUS   0SSSSSS	S	S
.[        R                  5
      nU R                  UR                  [        5        U R                  UR                  S5        U R                  UR                  S/5        U R                  UR                  SUS   05        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  5        U R                  UR                   SS	S	S
.5        U R                  UR"                  [        R                  5        g)z9
The parameters passed to the endpoint are stored in it.
ó   HOMENr%  ó   /runProcessHere/rk   r¼   TÚwÚr©r»   é   é   )r   r&  r  r&   ÚDROPr‡  r)  r³   r*  r+  r,  r-  r.  r/  r  r0  r1  r2  )r_   ÚenvironrW  s      r`   Útest_constructorNonDefaultsÚ1ProcessEndpointsTests.test_constructorNonDefaultsº  s=  € ð ˜D�/ˆÜ×&Ò&Ü Ó"ØØÐ Ø�g˜gÑ&Ð'ØØØØØ˜ Ñ$Ü!×&Ñ&ó
ˆð 	×Ñ˜bŸk™kÔ+?Ô@Ø×Ñ˜Ÿ™Ð);Ô<Ø×Ñ˜Ÿ™Ð$6Ð#7Ô8Ø×Ñ˜Ÿ™ 7¨G°GÑ,<Ð"=Ô>Ø×Ñ˜Ÿ™Ð#6Ô7Ø×Ñ˜Ÿ™ !Ô$Ø×Ñ˜Ÿ™ !Ô$Ø�‰˜Ÿ
™
Ô#Ø×Ñ˜Ÿ™¨3°3¸3Ñ'?Ô@Ø×Ñ˜Ÿ™Ô&;×&@Ñ&@ÕArc   c                óÜ   • U R                   R                  U R                  5      nU R                  U5        U R                  R
                  nU R                  U[        R                  5        g)zl
The wrapper function _WrapIProtocol gives an IProcessProtocol
implementation that wraps over an IProtocol.
N)	rW  rg  r¶   r×  r   r  r‡  r   Ú_WrapIProtocol©r_   rÐ   Úwpps      r`   Útest_wrappedProtocolÚ*ProcessEndpointsTests.test_wrappedProtocol×  sM   € ð
 �G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆØ×Ñ˜c¤9×#;Ñ#;Õ<rc   c                ó|  • SS0n[        5       n[        R                  " USS/SUS   0SSSSSS	S	S
.5	      nUR                  U R                  5      nU R                  U5        U R                  UR                  [        R                  5        U R                  UR                  UR                  5        U R                  UR                  UR                  5        U R                  UR                  UR                  5        U R                  UR                   UR"                  5        U R                  UR$                  UR&                  5        U R                  UR(                  UR*                  5        U R                  UR,                  UR.                  5        U R                  UR0                  UR2                  5        g)zr
The parameters for spawnProcess stored in the endpoint are passed when
the endpoint's connect method is invoked.
r7  Nr%  r8  rk   r¼   Tr9  r:  r;  )r  r   r&  rg  r¶   r×  r‡  r  rC  r³   r  r*  rÉ   r+  r  r,  r  r-  r  r.  r  r/  r  r0  r  r1  )r_   r?  ÚmemoryReactorrW  rÐ   s        r`   Útest_spawnProcessÚ'ProcessEndpointsTests.test_spawnProcessá  sb  € ð
 ˜D�/ˆä,Ó.ˆÜ×&Ò&ØØØÐ Ø�g˜gÑ&Ð'ØØØØØ˜ Ñ$ó

ˆð �J‰J�t—|‘|Ó$ˆØ×Ñ˜QÔà×Ñ˜m×;Ñ;¼Y×=UÑ=UÔVØ×Ñ˜×1Ñ1°2·>±>ÔBØ×Ñ˜×+Ñ+¨R¯X©XÔ6Ø×Ñ˜×*Ñ*¨B¯G©GÔ4Ø×Ñ˜×+Ñ+¨R¯X©XÔ6Ø×Ñ˜×*Ñ*¨B¯G©GÔ4Ø×Ñ˜×*Ñ*¨B¯G©GÔ4Ø×Ñ˜×-Ñ-¨r¯z©zÔ:Ø×Ñ˜×/Ñ/°·±Õ>rc   c                óÜ   •  " S S[         R                  5      nU" 5       nU R                  R                  U5      nU R	                  U5        U R                  UR                  [        5        g)zb
The address passed to the factory's buildProtocol in the endpoint is a
_ProcessAddress instance.
c                  ó"   • \ rS rSr\rSrS rSrg)ÚBProcessEndpointsTests.test_processAddress.<locals>.TestAddrFactoryi  Nc                ó>   • Xl         U R                  5       nXl        U$ ro   )rY  r   r¶   )r_   r©   rï   s      r`   rª   ÚPProcessEndpointsTests.test_processAddress.<locals>.TestAddrFactory.buildProtocol  s   € Ø#”Ø—M‘M“O�Ø ”	Ø�rc   )rY  )	ry   rz   r{   r|   rä  r   rY  rª   r~   rf   rc   r`   ÚTestAddrFactoryrN    s   † Ø.ˆHØˆGõrc   rQ  N)r   r2   rW  rg  r×  r‡  rY  r%   )r_   rQ  Ú	myFactoryrÐ   s       r`   Útest_processAddressÚ)ProcessEndpointsTests.test_processAddress  sT   € ô	œh×.Ñ.ô 	ñ $Ó%ˆ	Ø�G‰G�O‰O˜IÓ&ˆØ×Ñ˜QÔØ×Ñ˜i×/Ñ/´ÕArc   c                ó˜   • U R                  U R                  R                  U R                  5      5      nU R	                  U[
        5        g)zL
L{ProcessEndpoint.connect} returns a Deferred with the connected
protocol.
N)r×  rW  rg  r¶   r‡  rä  )r_   rk  s     r`   Útest_connectÚ"ProcessEndpointsTests.test_connect  s6   € ð
 ×$Ñ$ T§W¡W§_¡_°T·\±\Ó%BÓCˆØ×Ñ˜eÔ%<Õ=rc   c                óÂ   • S nXR                   l        U R                   R                  U R                  5      nU R	                  U5      nUR
                  " [        5        g)zO
In case of failure, L{ProcessEndpoint.connect} returns a Deferred that
fails.
c	                ó   • [        5       ero   )Ú	Exception)	Úppr  rÉ   r  r  r  r  r  r  s	            r`   ÚtestSpawnProcessÚCProcessEndpointsTests.test_connectFailure.<locals>.testSpawnProcess$  s   € ô “+Ðrc   N)rW  Ú_spawnProcessrg  r¶   rÔ   ÚtraprZ  )r_   r\  rÐ   r   s       r`   Útest_connectFailureÚ)ProcessEndpointsTests.test_connectFailure  sE   € ò	ð
 !1�‰ÔØ�G‰G�O‰O˜DŸL™LÓ)ˆØ×$Ñ$ QÓ'ˆØ�
Š
”9Õrc   )rW  r¶   r   N)ry   rz   r{   r|   r}   rÛ  r4  r@  rF  rJ  rS  rV  r`  r~   rf   rc   r`   r"  r"     s3   † ñò8òFòBò:=ò?ò@Bò*>õrc   r"  c                  óx   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rS rS rS rS rS rS rS rS rSrg)ÚProcessEndpointTransportTestsi/  zY
Test the behaviour of the implementation detail
L{endpoints._ProcessEndpointTransport}.
c                óJ  • [        5       U l        [        R                  " U R                  S5      U l        U R                  U R                  R                  [        R                  " [        5      5      5      nU R                  R                  U l        UR                  U l        g r$  )r  r   r   r&  rÚ  r×  rg  r2   ÚforProtocolr3   r  Úprocessrô   ÚendpointTransport)r_   r   s     r`   rÛ  Ú#ProcessEndpointTransportTests.setUp5  ss   € Ü+Ó-ˆŒÜ!×1Ò1°$·,±,Ð@RÓSˆŒØ×'Ñ'Ø�M‰M×!Ñ!¤'×"5Ò"5´hÓ"?Ó@ó
ˆð —|‘|×4Ñ4ˆŒØ!)×!3Ñ!3ˆÕrc   c                ó8   • [        [        U R                  5        g)z5
L{_ProcessEndpointTransport}s provide L{IConsumer}.
N)r   r)   rg  r^   s    r`   Útest_verifyConsumerÚ1ProcessEndpointTransportTests.test_verifyConsumer>  s   € ô 	”Y × 6Ñ 6Õ7rc   c                ó8   • [        [        U R                  5        g)z9
L{_ProcessEndpointTransport}s provide L{IPushProducer}.
N)r   r,   rg  r^   s    r`   Útest_verifyProducerÚ1ProcessEndpointTransportTests.test_verifyProducerD  s   € ô 	”] D×$:Ñ$:Õ;rc   c                ó8   • [        [        U R                  5        g)z6
L{_ProcessEndpointTransport}s provide L{ITransport}.
N)r   r0   rg  r^   s    r`   Útest_verifyTransportÚ2ProcessEndpointTransportTests.test_verifyTransportJ  s   € ô 	”Z ×!7Ñ!7Õ8rc   c                ód   • U R                  U R                  R                  U R                  5        g)zL
The L{_ProcessEndpointTransport} instance stores the process passed to
it.
N)rÔ  rg  Ú_processrf  r^   s    r`   Útest_constructorÚ.ProcessEndpointTransportTests.test_constructorP  s"   € ð
 	�‰�d×,Ñ,×5Ñ5°t·|±|ÕDrc   c                óÎ   • [        [        5       " S S5      5       nU" 5       nU R                  R                  US5        U R	                  U R
                  R                  U5        g)zh
Registering a producer with the endpoint transport registers it with
the underlying process transport.
c                  ó   • \ rS rSrSrg)ÚFProcessEndpointTransportTests.test_registerProducer.<locals>.AProduceri]  rf   Nré   rf   rc   r`   Ú	AProducerrx  ]  s   † ârc   ry  FN)r   r,   rg  ÚregisterProducerrÔ  rf  Úproducer)r_   ry  Ú	aProducers      r`   Útest_registerProducerÚ3ProcessEndpointTransportTests.test_registerProducerW  sW   € ô 
”]Ó	#÷	ð 	ó 
$ð	ñ “Kˆ	Ø×Ñ×/Ñ/°	¸5ÔAØ�‰�d—l‘l×+Ñ+¨YÕ7rc   c                ó„   • U R                   R                  5         U R                  U R                  R                  S5        g)zI
Pausing the endpoint transport pauses the underlying process transport.
ÚpausedN)rg  ÚpauseProducingr³   rf  ÚproducerStater^   s    r`   Útest_pauseProducingÚ1ProcessEndpointTransportTests.test_pauseProducinge  s0   € ð 	×Ñ×-Ñ-Ô/Ø×Ñ˜Ÿ™×3Ñ3°XÕ>rc   c                ó¤   • U R                  5         U R                  R                  5         U R                  U R                  R
                  S5        g)zK
Resuming the endpoint transport resumes the underlying process
transport.
Ú	producingN)rƒ  rg  ÚresumeProducingr³   rf  r‚  r^   s    r`   Útest_resumeProducingÚ2ProcessEndpointTransportTests.test_resumeProducingl  s<   € ð
 	× Ñ Ô"Ø×Ñ×.Ñ.Ô0Ø×Ñ˜Ÿ™×3Ñ3°[ÕArc   c                ó„   • U R                   R                  5         U R                  U R                  R                  S5        g)zW
Stopping the endpoint transport as a producer stops the underlying
process transport.
ÚstoppedN)rg  ÚstopProducingr³   rf  r‚  r^   s    r`   Útest_stopProducingÚ0ProcessEndpointTransportTests.test_stopProducingu  s0   € ð
 	×Ñ×,Ñ,Ô.Ø×Ñ˜Ÿ™×3Ñ3°YÕ?rc   c                ó¢   • U R                  5         U R                  R                  5         U R                  U R                  R
                  5        g)zi
Unregistring the endpoint transport's producer unregisters the
underlying process transport's producer.
N)r}  rg  ÚunregisterProducerrß   rf  r{  r^   s    r`   Útest_unregisterProducerÚ5ProcessEndpointTransportTests.test_unregisterProducer}  s:   € ð
 	×"Ñ"Ô$Ø×Ñ×1Ñ1Ô3Ø×Ñ˜$Ÿ,™,×/Ñ/Õ0rc   c                ór   • / U R                   l        U R                  [        [        U R
                  S5        g)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)rf  r”  ÚassertRaisesÚAttributeErrorÚgetattrrg  r^   s    r`   Útest_extraneousAttributesÚ7ProcessEndpointTransportTests.test_extraneousAttributes†  s*   € ð  ˆ�‰ÔØ×Ñœ.¬'°4×3IÑ3IÈ7ÕSrc   c                ó¦   • U R                   R                  / SQ5        U R                  U R                  R                  R                  5       S5        g)zy
The writeSequence method of L{_ProcessEndpointTransport} writes a list
of string passed to it to the transport's stdin.
)s   test1s   test2s   test3s   test1test2test3N)rg  ÚwriteSequencer³   rf  ÚioÚgetvaluer^   s    r`   Útest_writeSequenceÚ0ProcessEndpointTransportTests.test_writeSequence�  s;   € ð
 	×Ñ×,Ñ,Ò-KÔLØ×Ñ˜Ÿ™Ÿ™×1Ñ1Ó3Ð5GÕHrc   c                ó¢   • U R                   R                  S5        U R                  U R                  R                  R                  5       S5        g)zu
The write method of L{_ProcessEndpointTransport} writes a string of
data passed to it to the child process's stdin.
s   testN)rg  rö  r³   rf  rœ  r�  r^   s    r`   Ú
test_writeÚ(ProcessEndpointTransportTests.test_write˜  s9   € ð
 	×Ñ×$Ñ$ WÔ-Ø×Ñ˜Ÿ™Ÿ™×1Ñ1Ó3°WÕ=rc   c                ó‚   • U R                   R                  5         U R                  U R                  R                  5        g)zŠ
A call to the loseConnection method of a L{_ProcessEndpointTransport}
instance returns a call to the process transport's loseConnection.
N)rg  ÚloseConnectionr  rf  Ú	connectedr^   s    r`   Útest_loseConnectionÚ1ProcessEndpointTransportTests.test_loseConnection   s.   € ð
 	×Ñ×-Ñ-Ô/Ø×Ñ˜Ÿ™×/Ñ/Õ0rc   c                ó¶   • U R                   R                  5       nU R                  U[        5        U R	                  XR
                  R                  5       5        g)zm
L{_ProcessEndpointTransport.getHost} returns a L{_ProcessAddress}
instance matching the process C{getHost}.
N)rg  r¥  r‡  r%   rÔ  rf  )r_   r�  s     r`   Útest_getHostÚ*ProcessEndpointTransportTests.test_getHost¨  óA   € ð
 ×%Ñ%×-Ñ-Ó/ˆØ×Ñ˜d¤OÔ4Ø�‰�dŸL™L×0Ñ0Ó2Õ3rc   c                ó¶   • U R                   R                  5       nU R                  U[        5        U R	                  XR
                  R                  5       5        g)zm
L{_ProcessEndpointTransport.getPeer} returns a L{_ProcessAddress}
instance matching the process C{getPeer}.
N)rg  ÚgetPeerr‡  r%   rÔ  rf  )r_   Úpeers     r`   Útest_getPeerÚ*ProcessEndpointTransportTests.test_getPeer±  r«  rc   )rÚ  rg  rf  r   N)ry   rz   r{   r|   r}   rÛ  rj  rm  rp  rt  r}  rƒ  rˆ  r�  r‘  r˜  rž  r¡  r¦  r©  r¯  r~   rf   rc   r`   rc  rc  /  s\   † ñò
4ò8ò<ò9òEò8ò?òBò@ò1òTòIò>ò1ò4õ4rc   rc  c                  óN   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rS rSrg)ÚWrappedIProtocolTestsi»  zD
Test the behaviour of the implementation detail C{_WrapIProtocol}.
c                óÚ   • [        5       U l        [        R                  " U R                  S5      U l        S U l        [        R                  " 5       U l        [        U R                  l        g r$  )
r  r   r   r&  rW  ÚeventLogr   r2   r¶   rä  r^   s    r`   rÛ  ÚWrappedIProtocolTests.setUpÀ  sH   € Ü+Ó-ˆŒÜ×+Ò+¨D¯L©LÐ:LÓMˆŒØˆŒÜ×'Ò'Ó)ˆŒÜ 7ˆ�‰Õrc   c                ó<  • U R                   R                  U R                  5      nU R                  U5        U R                  R
                  nU R                  UR                  [        5        U R                  UR                  U R                   R                  5        g)zA
Stores an L{IProtocol} provider and the flag to log/drop stderr
N)rW  rg  r¶   r×  r   r  r‡  r   rä  r³   ÚerrFlagr2  rD  s      r`   rt  Ú&WrappedIProtocolTests.test_constructorÇ  sj   € ð �G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆØ×Ñ˜cŸl™lÔ,CÔDØ×Ñ˜Ÿ™ d§g¡g×&6Ñ&6Õ7rc   c                óü   • U R                   R                  U R                  5      nU R                  U5        U R                  R
                  nU R                  UR                  R                  UR                  5        g)z`
Our process transport is properly hooked up to the wrappedIProtocol
when a connection is made.
N)	rW  rg  r¶   r×  r   r  r³   r   rô   rD  s      r`   Útest_makeConnectionÚ)WrappedIProtocolTests.test_makeConnectionÑ  sU   € ð
 �G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆØ×Ñ˜Ÿ™×/Ñ/°·±Õ?rc   c                ó   • Xl         g)z
A log observer.
N)r´  )r_   Ú	eventDicts     r`   Ú_stdLogÚWrappedIProtocolTests._stdLogÛ  s	   € ð "�rc   c                ó–  • U R                   R                  U R                  5      nU R                  U5        U R                  R
                  n[        R                  " U R                  5        U R                  [        R                  U R                  5        UR                  SS5        U R                  U R                  S   UR                  5        U R                  U R                  S   S5        U R                  U R                  S   UR                  5        U R!                  S[        R"                  " U R                  5      5        g)z{
When the _errFlag is set to L{StandardErrorBehavior.LOG},
L{endpoints._WrapIProtocol} logs stderr (in childDataReceived).
r¼   s   stderr1r  r[   r   zwrote stderr unhandled byN)rW  rg  r¶   r×  r   r  r?   ÚaddObserverr¾  Ú
addCleanupÚremoveObserverÚchildDataReceivedr³   r´  r  r   ÚassertInÚtextFromEventDictrD  s      r`   Útest_logStderrÚ$WrappedIProtocolTests.test_logStderrá  sà   € ð
 �G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆÜ�Š˜Ÿ™Ô%Ø�‰œ×*Ñ*¨D¯L©LÔ9à×Ñ˜a Ô,Ø×Ñ˜Ÿ™ |Ñ4°c·n±nÔEØ×Ñ˜Ÿ™ vÑ.°
Ô;Ø×Ñ˜Ÿ™ zÑ2°C·L±LÔAØ�‰Ð1´3×3HÒ3HÈÏÉÓ3WÕXrc   c                óÈ  • [         R                  U R                  l        U R                  R	                  U R
                  5      nU R                  U5        U R                  R                  n[        R                  " U R                  5        U R                  [        R                  U R                  5        UR                  SS5        U R                  U R                   5        g)zh
When the _errFlag is set to L{StandardErrorBehavior.DROP},
L{endpoints._WrapIProtocol} ignores stderr.
r¼   s   stderr2N)r&   r>  rW  r2  rg  r¶   r×  r   r  r?   rÁ  r¾  rÂ  rÃ  rÄ  rß   r´  rD  s      r`   Útest_stderrSkipÚ%WrappedIProtocolTests.test_stderrSkipò  s“   € ô
 1×5Ñ5ˆ�‰ÔØ�G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆÜ�Š˜Ÿ™Ô%Ø�‰œ×*Ñ*¨D¯L©LÔ9à×Ñ˜a Ô,Ø×Ñ˜$Ÿ-™-Õ(rc   c                ó  • U R                   R                  U R                  5      nU R                  U5        U R                  R
                  nUR                  SS5        U R                  UR                  R                  S5        g)zx
In childDataReceived of L{_WrappedIProtocol} instance, the protocol's
dataReceived is called when stdout is generated.
rk   s   stdoutN)
rW  rg  r¶   r×  r   r  rÄ  r³   r   r[   rD  s      r`   Útest_stdoutÚ!WrappedIProtocolTests.test_stdout  sa   € ð
 �G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆà×Ñ˜a Ô+Ø×Ñ˜Ÿ™×*Ñ*¨IÕ6rc   c                óš  • U R                   R                  U R                  5      nU R                  U5        U R                  R
                  nUR                  [        [        R                  " S5      5      5        U R                  UR                  R                  R                  [        R                  5      [        R                  5        g)zj
L{error.ProcessDone} with status=0 is turned into a clean disconnect
type, i.e. L{error.ConnectionDone}.
r   N)rW  rg  r¶   r×  r   r  ÚprocessEndedrA   r   ÚProcessDoner³   r   rv   ÚcheckÚConnectionDonerD  s      r`   Útest_processDoneÚ&WrappedIProtocolTests.test_processDone  s‰   € ð
 �G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆà×Ñœ¤×!2Ò!2°1Ó!5Ó6Ô7Ø×ÑØ�L‰L×Ñ×%Ñ%¤e×&:Ñ&:Ó;¼U×=QÑ=Qõ	
rc   c                ó˜  • U R                   R                  U R                  5      nU R                  U5        U R                  R
                  nUR                  [        [        R                  " 5       5      5        U R                  UR                  R                  R                  [        R                  5      [        R                  5        g)zc
Exceptions other than L{error.ProcessDone} with status=0 are turned
into L{error.ConnectionLost}.
N)rW  rg  r¶   r×  r   r  rÐ  rA   r   ÚProcessTerminatedr³   r   rv   rÒ  ÚConnectionLostrD  s      r`   Útest_processEndedÚ'WrappedIProtocolTests.test_processEnded  s‡   € ð
 �G‰G�O‰O˜DŸL™LÓ)ˆØ×Ñ˜QÔØ�l‰l×*Ñ*ˆà×Ñœ¤×!8Ò!8Ó!:Ó;Ô<Ø×ÑØ�L‰L×Ñ×%Ñ%¤e×&:Ñ&:Ó;¼U×=QÑ=Qõ	
rc   )rW  r´  r¶   r   N)ry   rz   r{   r|   r}   rÛ  rt  rº  r¾  rÇ  rÊ  rÍ  rÔ  rÙ  r~   rf   rc   r`   r²  r²  »  s6   † ñò8ò8ò@ò"òYò")ò
7ò
õ
rc   r²  c                  óB   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
rg)ÚTCP4EndpointsTestsi*  z
Tests for TCP IPv4 Endpoints.
c                ó   • UR                   $ ©z4
@return: List of calls to L{IReactorTCP.listenTCP}
©Ú
tcpServersrJ  s     r`   rª  Ú"TCP4EndpointsTests.expectedServers/  ó   € ð ×!Ñ!Ð!rc   c                ó   • UR                   $ ©z5
@return: List of calls to L{IReactorTCP.connectTCP}
©Ú
tcpClientsrJ  s     r`   rK  Ú"TCP4EndpointsTests.expectedClients5  râ  rc   c                ó¨   • Uu  p4pVnUu  nn	n
nnU R                  X85        U R                  XI5        U R                  Xk5        U R                  X|5        g©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³   ©r_   rN  rO  r�  r�  ÚignoredFactoryÚtimeoutÚbindAddressr«  ÚexpectedPortÚ_ignoredFactoryÚexpectedTimeoutÚexpectedBindAddresss                r`   rP  Ú$TCP4EndpointsTests.assertConnectArgs;  ód   € ð >JÑ:ˆ�^¨kð ñ	
ØØØØØð 	×Ñ˜Ô,Ø×Ñ˜Ô,Ø×Ñ˜Ô2Ø×Ñ˜Õ:rc   c                ó   • SSS.$ ©ú;
@return: C{dict} of keyword arguments to pass to connect.
é
   ©Ú	localhosti»Á  ©rí  rî  rf   r^   s    r`   rB  ÚTCP4EndpointsTests.connectArgsW  ó   € ð Ð.BÑCÐCrc   c                ó   • SSS.$ ©ú9
@return: C{dict} of keyword arguments to pass to listen
éd   ú	127.0.0.1©ÚbacklogÚ	interfacerf   r^   s    r`   r¸  ÚTCP4EndpointsTests.listenArgs]  ó   € ð ¨[Ñ9Ð9rc   c                óÀ   • [        SSS5      n[        R                  " XR                  40 UD6UR                  UUR	                  SS5      UR	                  SS5      4U4$ )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.0r   r  é2   r  rU   )r"   r   ÚTCP4ServerEndpointr�  Úget©r_   r   r¶   r¸  rY  s        r`   r   Ú'TCP4EndpointsTests.createServerEndpointc  se   € ô ˜e Y°Ó2ˆô ×(Ò(¨·,±,ÑMÀ*ÑMà—‘ØØ—‘˜y¨"Ó-Ø—‘˜{¨BÓ/ð	ð ð	
ð 		
rc   c           	     óì   • [        SSS5      n[        R                  " XR                  UR                  40 UD6UR                  UR                  UUR                  SS5      UR                  SS5      4U4$ )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}
r	  rú  r¯  rí  é   rî  N)r"   r   ÚTCP4ClientEndpointr�  r�  r  ©r_   r   rA  rB  rY  s        r`   rC  Ú'TCP4EndpointsTests.createClientEndpoint|  sz   € ô ˜e [°"Ó5ˆô ×(Ò(ØŸ™ w§|¡|ñØ7Bñð —‘Ø—‘ØØ—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð
ð 	
rc   rf   N©ry   rz   r{   r|   r}   rª  rK  rP  rB  r¸  r   rC  r~   rf   rc   r`   rÜ  rÜ  *  s+   † ñò"ò"ò;ò8Dò:ò
õ2
rc   rÜ  c                  óB   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
rg)ÚTCP6EndpointsTestsi™  z
Tests for TCP IPv6 Endpoints.
c                ó   • UR                   $ rÞ  rß  rJ  s     r`   rª  Ú"TCP6EndpointsTests.expectedServersž  râ  rc   c                ó   • UR                   $ rä  rå  rJ  s     r`   rK  Ú"TCP6EndpointsTests.expectedClients¤  râ  rc   c                ó¨   • Uu  p4pVnUu  nn	n
nnU R                  X85        U R                  XI5        U R                  Xk5        U R                  X|5        gré  rê  rë  s                r`   rP  Ú$TCP6EndpointsTests.assertConnectArgsª  rô  rc   c                ó   • SSS.$ rö  rf   r^   s    r`   rB  ÚTCP6EndpointsTests.connectArgsÆ  rý  rc   c                ó   • SSS.$ )r   r  ú::1r  rf   r^   s    r`   r¸  ÚTCP6EndpointsTests.listenArgsÌ  s   € ð ¨UÑ3Ð3rc   c                óÂ   • UR                  SS5      n[        SUS5      n[        R                  " XR                  40 UD6UR                  X#R                  SS5      U4U4$ )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}.
r  z::r	  r   r  r  )r  r#   r   ÚTCP6ServerEndpointr�  )r_   r   r¶   r¸  r  rY  s         r`   r   Ú'TCP6EndpointsTests.createServerEndpointÒ  sa   € ð —N‘N ;°Ó5ˆ	Ü˜e Y°Ó2ˆô ×(Ò(¨·,±,ÑMÀ*ÑMØ�\‰\˜7§N¡N°9¸bÓ$AÀ9ÐMØð
ð 	
rc   c           	     óì   • [        SSS5      n[        R                  " XR                  UR                  40 UD6UR                  UR                  UUR                  SS5      UR                  SS5      4U4$ )á�  
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}
r	  r!  r¯  rí  r  rî  N)r#   r   ÚTCP6ClientEndpointr�  r�  r  r  s        r`   rC  Ú'TCP6EndpointsTests.createClientEndpointç  sz   € ô ˜e U¨BÓ/ˆô ×(Ò(ØŸ™ w§|¡|ñØ7Bñð —‘Ø—‘ØØ—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð
ð 	
rc   rf   Nr  rf   rc   r`   r  r  ™  s+   † ñò"ò"ò;ò8Dò4ò
õ*
rc   r  c                  ó<   • \ rS rSrSrS rS rS rS rS r	S r
S	rg
)ÚTCP6EndpointNameResolutionTestsi  z`
Tests for a TCP IPv6 Client Endpoint pointed at a hostname instead
of an IPv6 address literal.
c           	     ó,  ^ • [        SSS5      n[        R                  " USUR                  40 UD6T l        U 4S jnUT R                  l        T R                  UR                  UR                  UUR                  SS5      UR                  SS	5      4U4$ )
r'  r	  ú::2r¯  úipv6.example.comc                óÄ   >• TR                  SU 5        [        [        [        SS4[        [        [        SS4[        [        [        SS4/n[        R
                  " U5      $ )Nr.  rU   )r-  r   r   r   )z::3r   r   r   )z::4r   r   r   )r³   r   r	   r   r   rŽ  )r�  r[   r_   s     €r`   ÚtestNameResolutionÚPTCP6EndpointNameResolutionTests.createClientEndpoint.<locals>.testNameResolution  sY   ø€ Ø×ÑÐ/°Ô6äœ;¬°RÐ9IÐJÜœ;¬°RÐ9IÐJÜœ;¬°RÐ9IÐJðˆDô
 —=’= Ó&Ð&rc   rí  r  rî  N)r#   r   r(  r�  rW  Ú_nameResolutionr�  r  )r_   r   rA  rB  rY  r0  s   `     r`   rC  Ú4TCP6EndpointNameResolutionTests.createClientEndpoint
  s–   ø€ ô ˜e U¨BÓ/ˆÜ×.Ò.ØÐ'¨¯©ñ
Ø9Dñ
ˆŒõ	'ð #5ˆ�‰Ôð �G‰Gà—‘Ø—‘ØØ—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð

ð 
	
rc   c                ó   • SSS.$ rö  rf   r^   s    r`   rB  Ú+TCP6EndpointNameResolutionTests.connectArgs2  rý  rc   c                ó   • UR                   $ rä  rå  rJ  s     r`   rK  Ú/TCP6EndpointNameResolutionTests.expectedClients8  râ  rc   c                ó¨   • Uu  p4pVnUu  nn	n
nnU R                  X85        U R                  XI5        U R                  Xk5        U R                  X|5        gré  rê  rë  s                r`   rP  Ú1TCP6EndpointNameResolutionTests.assertConnectArgs>  rô  rc   c                óˆ   • [         R                  " SSS5      nU R                  UR                  [        R
                  5        g)zO
By default, L{TCP6ClientEndpoint._deferToThread} is
L{threads.deferToThread}.
Nzwww.example.coméÒ  )r   r(  r³   Ú_deferToThreadr   ÚdeferToThread©r_   rW  s     r`   Útest_freeFunctionDeferToThreadÚ>TCP6EndpointNameResolutionTests.test_freeFunctionDeferToThreadZ  s5   € ô
 ×)Ò)¨$Ð0AÀ4ÓHˆØ×Ñ˜×*Ñ*¬G×,AÑ,AÕBrc   c                óò   ^• [        5       n/ mU4S jn[        R                  " USS5      n[        5       nXCl        X#l        UR                  [        5       5        U R                  USS[        40 4/T5        g)zT
While resolving hostnames, _nameResolution calls
_deferToThread with _getaddrinfo.
c                óT   >• TR                  XU45        [        R                  " 5       $ ro   )rp   r   r  )r  rÉ   ÚkwargsÚcallss      €r`   ÚfakeDeferToThreadÚNTCP6EndpointNameResolutionTests.test_nameResolution.<locals>.fakeDeferToThreadj  s!   ø€ Ø�L‰L˜! 6Ð*Ô+Ü—>’>Ó#Ð#rc   r.  r;  r   N)
rV  r   r(  ró   Ú_getaddrinfor<  rg  r¢   r³   r   )r_   rl  rE  rÚ  ÚfakegetaddrinforD  s        @r`   Útest_nameResolutionÚ3TCP6EndpointNameResolutionTests.test_nameResolutionb  su   ø€ ô
 !“?ˆØˆõ	$ô ×/Ò/°Ð:LÈdÓSˆÜ ›(ˆØ /ÔØ"3ÔØ×Ñœ›Ô'Ø×ÑØÐ 2°A´xÐ@À"ÐEÐFÈõ	
rc   )rW  N)ry   rz   r{   r|   r}   rC  rB  rK  rP  r?  rI  r~   rf   rc   r`   r+  r+    s(   † ñò
&
òPDò"ò;ò8Cõ
rc   r+  c                  ó"   • \ rS rSrSrSS jrSrg)ÚRaisingMemoryReactorWithClockix  z=
An extension of L{RaisingMemoryReactor} with L{task.Clock}.
Nc                ó^   • [         R                  " U 5        [        R                  " XU5        g ro   )r5   ra   r7   )r_   r°  rt  s      r`   ra   Ú&RaisingMemoryReactorWithClock.__init__}  s   € Ü�Š�tÔÜ×%Ò% dÐ=MÕNrc   rf   )NNrÏ  rf   rc   r`   rL  rL  x  s   † ñ÷Orc   rL  c                ó  ^^^• Tc  0 mTR                  5       m[        [        5       " UU4S jS5      5       m[        [        5       " U4S jS[	        [        S[        [        U 5      5      5      5      5      5       nU" U 5      $ )a  
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.
c                  ó8   >• \ rS rSr\   SU U4S jj5       rSrg)Ú9deterministicResolvingReactor.<locals>.SimpleNameResolveri¢  Nc                ó  >• U R                  S 5        TR                  UT5       HH  n[        U[        5      (       a  [        [
        /[        U5         " SXR5      nU R                  U5        MJ     U R                  5         g )Nr	  )	ÚresolutionBeganr  Ú
isinstancerš  r"   r#   r    ÚaddressResolvedÚresolutionComplete)ÚresolutionReceiverÚhostNameÚ
portNumberÚaddressTypesÚtransportSemanticsrS  ÚexpectedAddressesÚhostMaps         €€r`   ÚresolveHostNameÚIdeterministicResolvingReactor.<locals>.SimpleNameResolver.resolveHostName¤  sv   ø€ ð ×.Ñ.¨tÔ4Ø#*§;¡;¨xÐ9JÖ#K�Ü˜o¬s×3Ñ3Ü'2´KÐ&@Ü% oÓ6ò'à˜_ó':�Oð #×2Ñ2°?ÖCñ $Lð ×1Ñ1Õ3rc   rf   )r   Nr	  )ry   rz   r{   r|   Ústaticmethodr^  r~   )r\  r]  s   €€r`   ÚSimpleNameResolverrQ  ¢  s    ø† à	ð ØØ$÷	4ó 
ó	4rc   ra  c                  ó&   >• \ rS rSr Y " 5       rSrg)Ú3deterministicResolvingReactor.<locals>.WithResolveriµ  rf   N)ry   rz   r{   r|   ÚnameResolverr~   )ra  s   €r`   ÚWithResolverrc  µ  s   ø† ò *Ó+‹rc   re  Ú*)Úcopyr   r*   r-   r@   r   Útupler   )r   r\  r]  re  ra  s    `` @r`   ÚdeterministicResolvingReactorri  ‚  s|   ú€ ð8 �ØˆØ�l‰l‹n€GäÔ"Ó#÷4ô 4ó $ð4ô$ Ô.Ó/÷,Üœ.¨¬e´J¸wÓ4GÓ.HÓIÓJó,ó 0ð,ñ
 ˜Ó Ð rc   c                  ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
ÚSimpleHostnameResolverTestsi¾  aV  
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.
c                ó  ^ • / T l         [        R                  " 5       T l        [        R
                  " T R                  5      T l        / T l        / T l	        ST l
        [        [        R                  5       " U 4S jS5      5       nUT l        g )Nr   c                  óX   >• \ rS rSr\U 4S j5       r\U 4S j5       r\U 4S j5       rSrg)Ú4SimpleHostnameResolverTests.setUp.<locals>._Receiveriä  c                ó<   >• TR                   R                  U 5        g ro   )ÚresolutionBeganCallsrp   )ÚresolutionInProgressr_   s    €r`   rS  ÚDSimpleHostnameResolverTests.setUp.<locals>._Receiver.resolutionBeganæ  s   ø€ à×)Ñ)×0Ñ0Ð1EÕFrc   c                ó<   >• TR                   R                  U 5        g ro   )ÚaddressResolvedCallsrp   )rY  r_   s    €r`   rU  ÚDSimpleHostnameResolverTests.setUp.<locals>._Receiver.addressResolvedê  s   ø€ à×)Ñ)×0Ñ0°Õ9rc   c                 ó0   >• T =R                   S-  sl         g rj   )ÚresolutionCompleteCallCountr^   s   €r`   rV  ÚGSimpleHostnameResolverTests.setUp.<locals>._Receiver.resolutionCompleteî  s   ø€ à×0Ò0°AÑ5Ö0rc   rf   N)	ry   rz   r{   r|   r`  rS  rU  rV  r~   r^   s   €r`   Ú	_Receiverrn  ä  s?   ø† àôGó ðGð ô:ó ð:ð ô6ó ó6rc   ry  )ÚfakeResolverCallsr   r  ÚfakeResolverReturnsr   r“  ÚfakeResolverÚresolverrp  rt  rw  r   r   ÚIResolutionReceiverÚreceiver)r_   ry  s   ` r`   rÛ  Ú!SimpleHostnameResolverTests.setUpÛ  su   ø€ Ø!#ˆÔÜ#(§>¢>Ó#3ˆÔ Ü!×9Ò9¸$×:KÑ:KÓLˆŒà$&ˆÔ!Ø$&ˆÔ!Ø+,ˆÔ(ä	”*×0Ñ0Ó	1÷	6ó 	6ó 
2ð	6ð "ˆ�rc   c                óR   • U R                   R                  X45        U R                  $ )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}
)rz  rp   r{  )r_   rX  rY  s      r`   r|  Ú(SimpleHostnameResolverTests.fakeResolverô  s'   € ð 	×Ñ×%Ñ% xÐ&<Ô=Ø×'Ñ'Ð'rc   c                ój   • U R                  [        [        R                  U R                  5      5        g)z[
A L{endpoints._SimpleHostnameResolver} instance provides
L{interfaces.IHostnameResolver}.
N)r  r   r   r*   r}  r^   s    r`   rZ  Ú*SimpleHostnameResolverTests.test_interface  s!   € ð
 	�‰œ¤Z×%AÑ%AÀ4Ç=Á=ÓQÕRrc   c                ó²  ^^• / m[        [        5      U4S j5       m[        R                  " T5        U R	                  U4S j5        U R
                  R                  U R                  S5        U R                  R                  [        5       5        U R                  S[        T5      5        U R                  S[        U R                  [        5      5      5        Tu  nU R                  UR                  S5      5        U R                  UR                  SS5      5        U R                  UR                  S[!        U R"                  5      5      5        U R                  S[        U R$                  5      5        U R                  U R$                  S   R&                  S5        U R)                  U R*                  5        U R                  SU R,                  5        g	)
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.
c                ó(   >• TR                  U 5        g ro   r  )ÚeventÚlogss    €r`   ÚcaptureLogsÚHSimpleHostnameResolverTests.test_resolveNameFailure.<locals>.captureLogs  s   ø€ à�K‰K˜Õrc   c                 ó0   >• [         R                  " T 5      $ ro   )r;   rÃ  )r‰  s   €r`   rË   ÚESimpleHostnameResolverTests.test_resolveNameFailure.<locals>.<lambda>  s   ø€ Ô 2× AÒ AÀ+Ô Nrc   úexample.comrk   ÚisErrorÚnameÚcallabler   N)r   r:   r;   rÁ  rÂ  r}  r^  r  r{  ÚerrbackrZ  r³   ri  ÚflushLoggedErrorsr  r  Úreprr|  rp  r�  r  rt  rw  )r_   r‡  r‰  rˆ  s     @@r`   Útest_resolveNameFailureÚ3SimpleHostnameResolverTests.test_resolveNameFailure
  s[  ù€ ð ˆä	”,Ó	ô	ó 
 ð	ô 	×&Ò& {Ô3Ø�‰ÔNÔOà�‰×%Ñ% d§m¡m°]ÔCà× Ñ ×(Ñ(¬«Ô5à×Ñ˜œC ›IÔ&Ø×Ñ˜œC × 6Ñ 6´yÓ AÓBÔCà‰ˆØ�‰˜Ÿ	™	 )Ó,Ô-Ø�‰˜Ÿ	™	 &¨-Ó8Ô9Ø�‰˜Ÿ	™	 *¬d°4×3DÑ3DÓ.EÓFÔGà×Ñ˜œC × 9Ñ 9Ó:Ô;Ø×Ñ˜×2Ñ2°1Ñ5×:Ñ:¸MÔJØ×Ñ˜×2Ñ2Ô3Ø×Ñ˜˜D×<Ñ<Õ=rc   c           	     ó  • SnSnSnU R                   R                  U R                  S5        U R                  R	                  [
        [        [        SX!44[        [        [        SX144/5        U R                  S[        U R                  5      5        U R                  U R                  S   R                  S5        U R                  U R                  [        SX!5      [        SX15      /5        U R                  U R                   S5        g	)
z[
The resolution receiver begins, and resolved hostnames are
delivered before it completes.
r¯  ú1.2.3.4z
1::2::3::4r�  rU   rk   r   r	  N)r}  r^  r  r{  rh  r   r	   r   r   r³   ri  rp  r�  rt  r"   r#   rw  )r_   r�  Úipv4HostÚipv6Hosts       r`   Útest_resolveNameDeliversÚ4SimpleHostnameResolverTests.test_resolveNameDelivers+  sé   € ð
 ˆØˆØˆà�‰×%Ñ% d§m¡m°]ÔCà× Ñ ×)Ñ)äœ+¤{°B¸Ð8HÐIÜœ;¬°R¸(Ð9IÐJðô	
ð 	×Ñ˜œC × 9Ñ 9Ó:Ô;Ø×Ñ˜×2Ñ2°1Ñ5×:Ñ:¸MÔJØ×ÑØ×%Ñ%Ü˜ Ó/´¸UÀHÓ1SÐTô	
ð 	×Ñ˜×9Ñ9¸1Õ=rc   )rt  rz  r{  r  rp  rw  r}  N)ry   rz   r{   r|   r}   rÛ  r|  rZ  r”  rš  r~   rf   rc   r`   rk  rk  ¾  s"   † ñò8"ò2(òSò>õB>rc   rk  c                  ó   • \ rS rSrSrS rSrg)Ú+HostnameEndpointFallbackNameResolutionTestsiF  zX
L{HostnameEndpoint._fallbackNameResolution} defers a name
resolution call to a thread.
c                ó    ^ ^^• SSK Jn  [        R                  " USSS9nSu  mmUR	                  TT5      nUUU 4S jnUR                  U5      $ )zr
L{_fallbackNameResolution} returns a L{Deferred} that fires
with the resoution of the the host and request port.
r   )r   Úignored)r�  r�  )r—  rk   c                óÌ   >• TR                  [        U 5      S5        U u  u  p  p4TR                  U[        5        TR                  U[        5        TR                  UTT45        g rj   )r³   ri  r   r	   )ÚresultÚfamilyÚsocktypeÚ_Úsockaddrr�  r�  r_   s        €€€r`   ÚassertHostPortFamilySockTypeÚmHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolution.<locals>.assertHostPortFamilySockTypeY  sZ   ø€ Ø×ÑœS ›[¨!Ô,Ø39Ñ0Ñ/ˆf  1Ø×Ñ˜V¤WÔ-Ø×Ñ˜X¤{Ô3Ø×Ñ˜X¨¨d |Õ4rc   )Útwisted.internetr   r   ÚHostnameEndpointÚ_fallbackNameResolutionrÏ   )r_   r   rW  ÚresolutionDeferredr¦  r�  r�  s   `    @@r`   Útest_fallbackNameResolutionÚGHostnameEndpointFallbackNameResolutionTests.test_fallbackNameResolutionL  sQ   ú€ õ
 	-ä×'Ò'¨°iÀaÑHˆà#‰
ˆˆdà×7Ñ7¸¸dÓCÐ÷	5ð "×-Ñ-Ð.JÓKÐKrc   rf   N)ry   rz   r{   r|   r}   r¬  r~   rf   rc   r`   r�  r�  F  s   † ñõ
Lrc   r�  c                  ó   • \ rS rSrSrSrg)ÚNoNameReactoric  zC
This class does I{not} implement L{IReactorPluggableNameResolver}
rf   Nr½  rf   rc   r`   r¯  r¯  c  r¾  rc   r¯  c                  óF   • \ rS rSrSrS rS rS rS rS r	SS jr
S	 rS
rg)Ú#_HostnameEndpointMemoryReactorMixinii  z‰
Common methods for testing L{HostnameEndpoint} against
L{MemoryReactor} instances that do not provide
L{IReactorPluggableNameResolver}.
c                óŠ   •  U" U0 UD6n[         R                  " U5      $ ! [         a    [         R                  " 5       s $ f = f)aE  
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.
)r   rŽ  ÚBaseExceptionrù   )r_   r  rÉ   rC  r¡  s        r`   ÚsynchronousDeferredToThreadÚ?_HostnameEndpointMemoryReactorMixin.synchronousDeferredToThreadp  sD   € ð	)Ù˜Ð' Ñ'ˆFô —=’= Ó(Ð(øô ó 	 Ü—:’:“<Òð	 ús   ‚   AÁAc                ó   • UR                   $ )z“
Extract expected clients from the reactor.

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

@return: List of calls to L{IReactorTCP.connectTCP}
rå  rJ  s     r`   rK  Ú3_HostnameEndpointMemoryReactorMixin.expectedClients…  s   € ð ×!Ñ!Ð!rc   c                ó   • SSS.$ )z<

@return: C{dict} of keyword arguments to pass to connect.
g      $@rù  rû  rf   r^   s    r`   rB  Ú/_HostnameEndpointMemoryReactorMixin.connectArgs�  s   € ð
  Ð0DÑEÐErc   c                ó¨   • Uu  p4pVnUu  nn	n
nnU R                  X85        U R                  XI5        U R                  Xk5        U R                  X|5        gré  rê  rë  s                r`   rP  Ú5_HostnameEndpointMemoryReactorMixin.assertConnectArgs–  rô  rc   c                ó„  • [         R                  " SS9n[        US9n[        5       nU R	                  X#5      u  pEnUR                  U5      nUR                  [        R                  R                  5        U R                  U R                  U5      R                  U5        U R                  / UR                  5       5        g)z~
When L{HostnameEndpoint.connect} cannot connect to its
destination, the returned L{Deferred} will fail with
C{ConnectError}.
rr  rþ   rs  N©r   r  rL  ró   rC  rg  Úadvancer   r©  Ú_DEFAULT_ATTEMPT_DELAYr³   rÔ   rw  ÚgetDelayedCalls©r_   r}  rl  rA  rW  rX  rm  rÐ   s           r`   r~  Ú?_HostnameEndpointMemoryReactorMixin.test_endpointConnectFailure²  ó¢   € ô ×*Ò*Ð2EÑFˆä0À-ÑPˆä›ˆà'+×'@Ñ'@Øó(
Ñ$ˆ˜ð �J‰J�}Ó%ˆØ×Ñœ×3Ñ3×JÑJÔKØ×Ñ˜×-Ñ-¨aÓ0×6Ñ6¸ÔFØ×Ñ˜˜X×5Ñ5Ó7Õ8rc   c                ó,  • [        5       n[        5       nU R                  X!5        U R                  5       nU R	                  S[        U5      5        U R                  [        US   S   5        US   S   nU R                  UR                  S5      5        g)z‚
Instantiating L{HostnameEndpoint} with a reactor that does not
provide L{IReactorPluggableResolver} emits a deprecation warning.
rk   r   ÚcategoryÚmessagezöPassing HostnameEndpoint a reactor that does not provide IReactorPluggableNameResolver (twisted.internet.test.test_endpoints.NoNameReactor) was deprecated in Twisted 17.5.0; please use a reactor that provides IReactorPluggableNameResolver insteadN)
ró   r¯  rC  ÚflushWarningsr³   ri  rÔ  ÚDeprecationWarningr  Ú
startswith)r_   rA  rl  ÚwarningsrÆ  s        r`   Útest_deprecationÚ4_HostnameEndpointMemoryReactorMixin.test_deprecationÇ  s‡   € ô
 $›Xˆä%›ˆØ×!Ñ! (Ô:à×%Ñ%Ó'ˆØ×Ñ˜œC ›MÔ*Ø�‰Ô(¨(°1©+°jÑ*AÔBà˜1‘+˜iÑ(ˆØ�‰Ø×Ñð9óõ		
rc   c                óž  ^• [        5       n[        5       nS mU R                  X5      u  p4nUR                  [        R
                  " U4S j5      5        UR                  U5      nU R                  U R                  U5      R                  [        R                  5        U R                  S[        U R                  [        5      5      5        g)z(
Hostname resolution errors are logged.
c                 ó   • [        SS5      e)Néûÿÿÿz#No address associated with hostname)r   )rÉ   rC  s     r`   ÚgetaddrinfoThatFailsÚS_HostnameEndpointMemoryReactorMixin.test_errorsLogged.<locals>.getaddrinfoThatFailsè  s   € Ü˜2ÐDÓEÐErc   c                ó2   >• [         R                  " TX5      $ ro   )r   Úexecute)r�  r�  rÐ  s     €r`   rË   ÚG_HostnameEndpointMemoryReactorMixin.test_errorsLogged.<locals>.<lambda>ð  s   ø€ ¤5§=¢=Ð1EÀtÔ#Rrc   rk   N)rV  ró   rC  r’  r   r“  rg  r‡  rÔ   rw  r   ÚDNSLookupErrorr³   ri  r’  r   )r_   rl  rA  rW  rX  rm  rÐ   rÐ  s          @r`   Útest_errorsLoggedÚ5_HostnameEndpointMemoryReactorMixin.test_errorsLoggedá  s«   ø€ ô !“?ˆÜ›ˆò	Fð (,×'@Ñ'@Øó(
Ñ$ˆ˜ð 	×$Ñ$Ü×-Ò-ÜRóô	
ð
 �J‰J�}Ó%ˆØ×Ñ˜d×2Ñ2°1Ó5×;Ñ;¼U×=QÑ=QÔRØ×Ñ˜œC × 6Ñ 6´xÓ @ÓAÕBrc   rf   Nr›  )ry   rz   r{   r|   r}   r´  rK  rB  rP  r~  rË  rÖ  r~   rf   rc   r`   r±  r±  i  s,   † ñò)ò*"òFò;ò89ô*
õ4Crc   r±  c                  ó"   • \ rS rSrSrSrS rSrg)Ú&HostnameEndpointMemoryIPv4ReactorTestsiø  z†
IPv4 resolution tests for L{HostnameEndpoint} with
L{MemoryReactor} subclasses that do not provide
L{IReactorPluggableNameResolver}.
r—  c           	     óP  ^ • [        SS5      n[        US5      nUb*  UR                  " [        R                  " U 4S j5      5        [        R
                  " USUR                  40 UD6nUT R                  UR                  UUR                  SS5      UR                  SS5      4U4$ )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))}
ó   example.comr¯  Nc                ó2   >^• TR                  UU4S j5      $ )Nc                 óX   >• [         [        [        TR                  TR                  T 44/$ ro   )r   r	   r   rS  ©rY  r_   s   €€r`   rË   Ú_HostnameEndpointMemoryIPv4ReactorTests.createClientEndpoint.<locals>.<lambda>.<locals>.<lambda>  s-   ø€ ä 'Ü +Ü +Ø $× 4Ñ 4Ø!%×!5Ñ!5°zÐ Bðñ!rc   ©r´  ©rX  rY  r_   s    `€r`   rË   ÚMHostnameEndpointMemoryIPv4ReactorTests.createClientEndpoint.<locals>.<lambda>  ó   ù€ °×1QÑ1Qõô
2rc   rí  r  rî  )	r!   r-   r’  r   r“  r©  r�  rS  r  )r_   r   rA  rB  rY  ÚresolverPlugrÚ  s   `      r`   rC  Ú;HostnameEndpointMemoryIPv4ReactorTests.createClientEndpoint  s±   ø€ ô  " .°"Ó5ˆä4°W¸dÓCˆØÑ#Ø×'Ò'Ü×1Ò1ô
óôô  ×-Ò-Ø�^ W§\¡\ñ
Ø5@ñ
ˆð
 à×$Ñ$Ø—‘ØØ—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð

ð 
	
rc   rf   N©ry   rz   r{   r|   r}   rS  rC  r~   rf   rc   r`   rÙ  rÙ  ø  s   † ñð  €Oõ2
rc   rÙ  c                  ó"   • \ rS rSrSrSrS rSrg)Ú&HostnameEndpointMemoryIPv6ReactorTestsi8  z†
IPv6 resolution tests for L{HostnameEndpoint} with
L{MemoryReactor} subclasses that do not provide
L{IReactorPluggableNameResolver}.
ú1:2::3:4c           	     ó@  ^ • Sn[        SS5      n[        US5      nUb*  UR                  " [        R                  " U 4S j5      5        [        R
                  " USUR                  40 UD6nUUUR                  UUR                  SS5      UR                  SS5      4U4$ )	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))}
ré  ó   ipv6.example.comr¯  Nc                ó2   >^• TR                  UU4S j5      $ )Nc                 óX   >• [         [        [        TR                  TR                  T 44/$ ro   )r   r	   r   rS  rÞ  s   €€r`   rË   Ú_HostnameEndpointMemoryIPv6ReactorTests.createClientEndpoint.<locals>.<lambda>.<locals>.<lambda>Z  s-   ø€ ä (Ü +Ü +Ø $× 4Ñ 4Ø!%×!5Ñ!5°zÐ Bðñ!rc   rà  rá  s    `€r`   rË   ÚMHostnameEndpointMemoryIPv6ReactorTests.createClientEndpoint.<locals>.<lambda>Y  rã  rc   rí  r  rî  )r!   r-   r’  r   r“  r©  r�  r  )r_   r   rA  rB  rS  rY  rä  rÚ  s   `       r`   rC  Ú;HostnameEndpointMemoryIPv6ReactorTests.createClientEndpointC  s²   ø€ ð  %ˆÜ!Ð"5°rÓ:ˆÜ4°W¸dÓCˆØÑ#Ø×'Ò'Ü×1Ò1ô
óôô ×-Ò-ØÐ(¨'¯,©,ñ
Ø:Eñ
ˆð àØ—‘ØØ—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð

ð 
	
rc   rf   Nræ  rf   rc   r`   rè  rè  8  s   † ñð !€Oõ0
rc   rè  c                  óR   • \ rS rSrSrS rS rS rS rSS jr	S	 r
S
 rS rS rSrg)ÚHostnameEndpointsOneIPv4Testsiv  zR
Tests for the hostname based endpoints when GAI returns only one
(IPv4) address.
c           	     óà   • Sn[        SS5      n[        R                  " [        X/5      SUR                  40 UD6nUUUR                  UUR                  SS5      UR                  SS5      4U4$ )zc
Creates a L{HostnameEndpoint} instance where the hostname is resolved
into a single IPv4 address.
r—  rÛ  r¯  rí  r  rî  N©r!   r   r©  ri  r�  r  )r_   r   rA  rB  rS  rY  rÚ  s          r`   rC  Ú2HostnameEndpointsOneIPv4Tests.createClientEndpoint|  s†   € ð
 $ˆÜ! .°"Ó5ˆÜ×-Ò-Ü)¨'Ð3DÓEØØ�L‰Lñ
ð ñ	
ˆð àØ—‘ØØ—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð

ð 
	
rc   c                ó   • UR                   $ rä  rå  rJ  s     r`   rK  Ú-HostnameEndpointsOneIPv4Tests.expectedClients–  râ  rc   c                ó¨   • Uu  p4pVnUu  nn	n
nnU R                  X85        U R                  XI5        U R                  Xk5        U R                  X|5        gré  rê  rë  s                r`   rP  Ú/HostnameEndpointsOneIPv4Tests.assertConnectArgsœ  rô  rc   c                ó   • SSS.$ rö  rf   r^   s    r`   rB  Ú)HostnameEndpointsOneIPv4Tests.connectArgs¸  rý  rc   Nc                óè  • [        5       n[        R                  " 5       n[        R                  Ul        U R	                  X#5      u  pEnUR                  U5      nUb  UR                  U5        UR                  5         U R                  U5      nUR                  S[        [        R                  " 5       5      5        U R                  U5      n	U R                  U	R                  [        R                   5        U R#                  U	R                  R$                  U5        U R'                  UR(                  S   S   R*                  R,                  5        U R#                  / UR/                  5       5        g)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.
Nr   r¼   )rV  r   r2   r3   rC  rg  r¾  r…  r^  r  rA   r   r†  rÔ   r‡  rw  r'   r³   rY  r  ræ  Ú
_connectorÚstoppedConnectingrÀ  )
r_   r¾  rl  rA  rW  rX  rY  rÐ   rˆ  r‰  s
             r`   rŠ  Ú>HostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelled¾  s  € ô !“?ˆä ×(Ò(Ó*ˆÜ!)×!2Ñ!2ˆÔà#'×#<Ñ#<¸XÓ#UÑ ˆ˜à�J‰J�}Ó%ˆØÑØ×Ñ˜WÔ%Ø	�‰Œ
ð ×6Ñ6°xÓ@ˆØ×-Ñ-¨d´G¼E¿OºOÓ<MÓ4NÔOð ×&Ñ& qÓ)ˆà×Ñ˜gŸm™m¬U×-KÑ-KÔLØ×Ñ˜Ÿ™×.Ñ.°Ô8Ø�‰˜×+Ñ+¨AÑ.¨qÑ1×<Ñ<×NÑNÔOØ×Ñ˜˜X×5Ñ5Ó7Õ8rc   c                ód   • [         R                  R                  nXS-  -   nU R                  US9  g)zø
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)r   r©  r¿  rŠ  )r_   Ú
oneBetweenr¾  s      r`   Ú7test_endpointConnectingCancelledAfterAllAttemptsStartedÚUHostnameEndpointsOneIPv4Tests.test_endpointConnectingCancelledAfterAllAttemptsStartedÜ  s3   € ô ×/Ñ/×FÑFˆ
Ø¨SÑ 0Ñ1ˆØ×-Ñ-°gÐ-Ò>rc   c                ó„  • [         R                  " SS9n[        US9n[        5       nU R	                  X#5      u  pEnUR                  U5      nUR                  [        R                  R                  5        U R                  U R                  U5      R                  U5        U R                  / UR                  5       5        g)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þ   rs  Nr½  rÁ  s           r`   r~  Ú9HostnameEndpointsOneIPv4Tests.test_endpointConnectFailureç  rÃ  rc   c                óº  • [         R                  " SS9n[        5       n[        5       nU R	                  X#5      u  pEnUR                  U5      nUR                  S5        UR                  S   u  p‰p«nU
R                  UR                  S   U5        U R                  U R                  U5      R                  U5        U R                  / UR                  5       5        g)zÕ
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  rþ   ç333333Ó?r   N)r   r  rV  ró   rC  rg  r¾  ræ  r  Ú
connectorsr³   rÔ   rw  rÀ  )r_   r}  rl  rA  rW  rX  rm  rÐ   r�  r�  r¶   rí  rî  s                r`   Ú)test_endpointConnectFailureAfterIterationÚGHostnameEndpointsOneIPv4Tests.test_endpointConnectFailureAfterIterationü  sÅ   € ô ×*Ò*Ð2EÑFˆä “?ˆä›ˆà'+×'@Ñ'@Øó(
Ñ$ˆ˜ð �J‰J�}Ó%ˆØ×Ñ˜ÔØ4<×4GÑ4GÈÑ4JÑ1ˆ�G kØ×&Ñ& x×':Ñ':¸1Ñ'=¸}ÔMØ×Ñ˜×-Ñ-¨aÓ0×6Ñ6¸ÔFØ×Ñ˜˜X×5Ñ5Ó7Õ8rc   c                ó   ^• [        5       n[        5       n[        5       nU R                  X#5      u  pEnUR                  U5      n/ mU4S jnUR	                  U5        U R                  U5      n	UR                  S5        U	R                  R                  U5        U R                  TU/5        U R                  U5      n
U R                  [        U
5      S5        U R                  U
S   U5        U R                  / UR                  5       5        g)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.
c                ó(   >• TR                  U 5        g ro   r  rb  s    €r`   rd  Ú[HostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIteration.<locals>.checkProto+	  rf  rc   r  rk   r   N)ró   rV  rC  rg  rÏ   r^  r¾  rÎ   rh  r³   rK  ri  rP  rÀ  rj  s              @r`   Ú)test_endpointConnectSuccessAfterIterationÚGHostnameEndpointsOneIPv4Tests.test_endpointConnectSuccessAfterIteration	  sñ   ø€ ô “ˆÜ “?ˆä›ˆà(,×(AÑ(AØó)
Ñ%ˆ˜+ð �J‰J�}Ó%ˆàˆõ	%ð 	
�‰�jÔ!à×/Ñ/°Ó9ˆà×Ñ˜Ôà×Ñ×&Ñ& uÔ-Ø×Ñ˜¨%¨Ô1à×.Ñ.¨xÓ8ˆà×Ñœ˜_Ó-¨qÔ1Ø×Ñ˜¨qÑ1°<Ô@Ø×Ñ˜˜X×5Ñ5Ó7Õ8rc   rf   ro   )ry   rz   r{   r|   r}   rC  rK  rP  rB  rŠ  r  r~  r	  r  r~   rf   rc   r`   rò  rò  v  s5   † ñò

ò4"ò;ò8Dô9ò<	?ò9ò*9õ2&9rc   rò  c                  ó<   • \ rS rSrSrS rS rS rS rS r	S r
S	rg
)ÚHostnameEndpointsOneIPv6Testsi>	  zR
Tests for the hostname based endpoints when GAI returns only one
(IPv6) address.
c           	     óÞ   • [        SS5      n[        R                  " [        US/5      SUR                  40 UD6nUSUR                  UUR                  SS5      UR                  SS5      4U4$ )zc
Creates a L{HostnameEndpoint} instance where the hostname is resolved
into a single IPv6 address.
rë  r¯  ré  rí  r  rî  Nrô  )r_   r   rA  rB  rY  rÚ  s         r`   rC  Ú2HostnameEndpointsOneIPv6Tests.createClientEndpointD	  sƒ   € ô
 "Ð"5°rÓ:ˆÜ×-Ò-Ü)¨'°J°<Ó@ØØ�L‰Lñ
ð ñ	
ˆð àØ—‘ØØ—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð

ð 
	
rc   c                ó   • UR                   $ rä  rå  rJ  s     r`   rK  Ú-HostnameEndpointsOneIPv6Tests.expectedClients\	  râ  rc   c                ó¨   • Uu  p4pVnUu  nn	n
nnU R                  X85        U R                  XI5        U R                  Xk5        U R                  X|5        gré  rê  rë  s                r`   rP  Ú/HostnameEndpointsOneIPv6Tests.assertConnectArgsb	  rô  rc   c                ó   • SSS.$ rö  rf   r^   s    r`   rB  Ú)HostnameEndpointsOneIPv6Tests.connectArgs~	  rý  rc   c                óØ  • [        5       n[        R                  " 5       n[        R                  Ul        U R	                  [        US/5      U5      u  p4nUR                  U5      nUR                  5         U R                  U5      nUR                  S[        [        R                  " 5       5      5        U R                  U5      nU R                  UR                  [        R                   5        U R#                  UR                  R$                  U5        U R'                  UR(                  S   S   R*                  R,                  5        U R#                  / UR/                  5       5        g)r�  r  Nr   r¼   )rV  r   r2   r3   rC  ri  rg  r…  r^  r  rA   r   r†  rÔ   r‡  rw  r'   r³   rY  r  ræ  rý  rþ  rÀ  )	r_   rl  rA  rW  rX  rY  rÐ   rˆ  r‰  s	            r`   rŠ  Ú>HostnameEndpointsOneIPv6Tests.test_endpointConnectingCancelled„	  s  € ô !“?ˆÜ ×(Ò(Ó*ˆÜ!)×!2Ñ!2ˆÔà#'×#<Ñ#<Ü)¨(°[°MÓBÀMó$
Ñ ˆ˜ð �J‰J�}Ó%ˆØ	�‰Œ
ð ×6Ñ6°xÓ@ˆØ×-Ñ-¨d´G¼E¿OºOÓ<MÓ4NÔOð ×&Ñ& qÓ)ˆà×Ñ˜gŸm™m¬U×-KÑ-KÔLØ×Ñ˜Ÿ™×.Ñ.°Ô8Ø�‰˜×+Ñ+¨AÑ.¨qÑ1×<Ñ<×NÑNÔOØ×Ñ˜˜X×5Ñ5Ó7Õ8rc   c                óT  • [         R                  " SS9n[        US9n[        5       nU R	                  X#5      u  pEnUR                  U5      nUR                  S5        U R                  U R                  U5      R                  U5        U R                  / UR                  5       5        g)rq  rr  rþ   rs  r  N)r   r  rL  ró   rC  rg  r¾  r³   rÔ   rw  rÀ  rÁ  s           r`   r~  Ú9HostnameEndpointsOneIPv6Tests.test_endpointConnectFailure¡	  s–   € ô
 ×*Ò*Ð2EÑFˆÜ0À-ÑPˆÜ›ˆà'+×'@Ñ'@Øó(
Ñ$ˆ˜ð �J‰J�}Ó%ˆØ×Ñ˜ÔØ×Ñ˜×-Ñ-¨aÓ0×6Ñ6¸ÔFØ×Ñ˜˜X×5Ñ5Ó7Õ8rc   rf   N)ry   rz   r{   r|   r}   rC  rK  rP  rB  rŠ  r~  r~   rf   rc   r`   r  r  >	  s&   † ñò

ò0"ò;ò8Dò9õ:9rc   r  c                  ó<   • \ rS rSrSrSrSrS rS rSS jr	S r
S	rg
)ÚHostnameEndpointIDNATestsi´	  zB
Tests for L{HostnameEndpoint}'s constructor's encoding behavior.
õ
   bÃ¼cher.chs   xn--bcher-kva.chc                ó  • [         R                  " [        [        5       S/5      U R                  S5      nU R                  UR                  U R                  5        U R                  UR                  U R                  5        g)zm
A L{HostnameEndpoint} constructed with text will contain an
IDNA-encoded bytes representation of that text.
r  r¯  N©	r   r©  ri  rV  ÚsampleIDNATextr³   Ú
_hostBytesÚsampleIDNABytesÚ	_hostTextrÙ  s     r`   Útest_idnaHostnameTextÚ/HostnameEndpointIDNATests.test_idnaHostnameText¼	  óh   € ô
 ×-Ò-Ü)¬-«/¸K¸=ÓIØ×ÑØó
ˆð
 	×Ñ˜×,Ñ,¨d×.BÑ.BÔCØ×Ñ˜×+Ñ+¨T×-@Ñ-@ÕArc   c                ó  • [         R                  " [        [        5       S/5      U R                  S5      nU R                  UR                  U R                  5        U R                  UR                  U R                  5        g)zr
A L{HostnameEndpoint} constructed with bytes will contain an
IDNA-decoded textual representation of those bytes.
r  r¯  Nr"  rÙ  s     r`   Útest_idnaHostnameBytesÚ0HostnameEndpointIDNATests.test_idnaHostnameBytesÉ	  r)  rc   c                ó  • [         R                  " [        [        5       S/5      [	        SU R
                  5      S5      nU R                  UR                  U R                  5        U R                  UR                  U R
                  5        g)zp
A L{HostnameEndpoint} constructed with NFD-normalized text will store
the NFC-normalized version of that text.
r  ÚNFDr¯  N)
r   r©  ri  rV  r   r#  r³   r$  r%  r&  rÙ  s     r`   Útest_nonNormalizedTextÚ0HostnameEndpointIDNATests.test_nonNormalizedTextÖ	  so   € ô
 ×-Ò-Ü)¬-«/¸K¸=ÓIÜ�e˜T×0Ñ0Ó1Øó
ˆð
 	×Ñ˜×,Ñ,¨d×.BÑ.BÔCØ×Ñ˜×+Ñ+¨T×-@Ñ-@ÕArc   c                óø  • [         R                  " [        [        5       S/5      SS5      nUR	                  [
        R                  " [        5      5      nU R                  U[        5      nU R                  S[        U5      5        [         R                  " [        [        5       S/5      SS5      nUR	                  [        5       5      nU R                  U[        5      nU R                  S[        U5      5        g)zþ
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-ÿr¯  z\xff-garbage-\xffu   â¿°-garbage-â¿°z\u2ff0-garbage-\u2ff0N)r   r©  ri  rV  rg  r2   re  r3   rÔ   rÅ   rÅ  rš  )r_   rÚ  ÚdeferredÚerrs       r`   Útest_deferBadEncodingToConnectÚ8HostnameEndpointIDNATests.test_deferBadEncodingToConnectã	  sÇ   € ô ×-Ò-Ü)¬-«/¸K¸=ÓIØ Øó
ˆð
 ×#Ñ#¤G×$7Ò$7¼Ó$AÓBˆØ×"Ñ" 8¬ZÓ8ˆØ�‰Ð+¬S°«XÔ6Ü×-Ò-Ü)¬-«/¸K¸=ÓIØ#Øó
ˆð
 ×#Ñ#¤G£IÓ.ˆØ×"Ñ" 8¬ZÓ8ˆØ�‰Ð/´°S³Õ:rc   rf   Nr›  )ry   rz   r{   r|   r}   r#  r%  r'  r+  r/  r5  r~   rf   rc   r`   r  r  ´	  s*   † ñð $€NØ)€OòBòBôBõ;rc   r  c                  ó0   • \ rS rSrSrS rS rS rS rSr	g)	ÚHostnameEndpointReprTestsiü	  z8
Tests for L{HostnameEndpoint}'s string representation.
c                óÐ   • [         R                  " [        [        5       / 5      SS5      n[	        U5      nU R                  SU5        U R                  [        [        U5      5        g)zh
The string representation of L{HostnameEndpoint} includes the host and
port passed to the constructor.
r�  r¯  z!<HostnameEndpoint example.com:80>N©	r   r©  ri  r5   r“  r³   rÔ  rš  Útype©r_   rÚ  Úreps      r`   Útest_allASCIIÚ'HostnameEndpointReprTests.test_allASCII
  sT   € ô
 ×-Ò-Ü)¬%«'°2Ó6ØØó
ˆô �8‹nˆà×ÑÐ<¸cÔBØ�‰”cœ4 ›9Õ%rc   c                óÐ   • [         R                  " [        [        5       / 5      SS5      n[	        U5      nU R                  SU5        U R                  [        [        U5      5        g)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<  s      r`   Útest_idnaHostnameÚ+HostnameEndpointReprTests.test_idnaHostname
  sT   € ô
 ×-Ò-Ü)¬%«'°2Ó6ØØó
ˆô �8‹nˆà×ÑÐBÀCÔHØ�‰”cœ4 ›9Õ%rc   c                óÐ   • [         R                  " [        [        5       / 5      SS5      n[	        U5      nU R                  SU5        U R                  [        [        U5      5        g)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<  s      r`   Útest_hostIPv6AddressÚ.HostnameEndpointReprTests.test_hostIPv6Address!
  sT   € ô ×-Ò-Ü)¬%«'°2Ó6ØØó
ˆô �8‹nˆà×ÑÐ6¸Ô<Ø�‰”cœ4 ›9Õ%rc   c                óŽ   • [         R                  " [        [        5       / 5      SS5      nU R	                  S[        U5      5        g)zˆ
When a bad hostname is passed to L{HostnameEndpoint}, the string
representation displays invalid characters in backslash-escaped form.
r2  r¯  z'<HostnameEndpoint \xff-garbage-\xff:80>N)r   r©  ri  r5   r³   r“  rÙ  s     r`   Útest_badEncodingÚ*HostnameEndpointReprTests.test_badEncoding3
  s?   € ô
 ×-Ò-Ü)¬%«'°2Ó6Ð8LÈbó
ˆð 	×ÑØ7Ü�‹Nõ	
rc   rf   N)
ry   rz   r{   r|   r}   r>  rB  rF  rI  r~   rf   rc   r`   r8  r8  ü	  s   † ñò&ò &ò &õ$
rc   r8  c                  ó   • \ rS rSrSrS rSrg)Ú HostnameEndpointsGAIFailureTestsiB
  zE
Tests for the hostname based endpoints when GAI returns no address.
c                ó  • [         R                  " [        [        5       / 5      SS5      n[	        5       nUR                  U5      nU R                  U[        R                  5      nU R                  S[        U5      5        g)zm
If no address is returned by GAI for a hostname, the connection attempt
fails with L{error.DNSLookupError}.
rÛ  r¯  r�  N)r   r©  ri  r5   ró   rg  rÔ   r   rÕ  rÅ  rš  )r_   rÚ  rA  ÚdConnectÚexcs        r`   Útest_failureÚ-HostnameEndpointsGAIFailureTests.test_failureG
  sg   € ô
 ×-Ò-Ü)¬%«'°2Ó6¸Èó
ˆô ›ˆØ×#Ñ# MÓ2ˆØ×"Ñ" 8¬U×-AÑ-AÓBˆØ�‰�m¤S¨£XÕ.rc   rf   N)ry   rz   r{   r|   r}   rP  r~   rf   rc   r`   rL  rL  B
  s   † ñõ/rc   rL  c                  ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
Ú&HostnameEndpointsFasterConnectionTestsiU
  z‰
Tests for the hostname based endpoints when gai returns an IPv4 and
an IPv6 address, and one connection takes less time than the other.
c                óˆ   • [        5       U l        [        R                  " [	        U R                  SS/5      SS5      U l        g )Nr—  ré  ó   www.example.comr¯  )rV  rl  r   r©  ri  rÚ  r^   s    r`   rÛ  Ú,HostnameEndpointsFasterConnectionTests.setUp[
  s6   € Ü%›ˆŒÜ!×2Ò2Ü)¨$¯-©-¸)ÀZÐ9PÓQØØó
ˆ�rc   c                óê  • [        5       U l        [        R                  " [	        U R                  S[        5       S/5      SS5      U l        SnU R                  R                  U5        U R                  R                  S5        U R                  R                  S   u  p#pEnU R                  [        U R                  R                  5      S5        U R                  US5        U R                  US5        g)	zŠ
If an address type other than L{IPv4Address} and L{IPv6Address} is
returned by on address resolution, the endpoint ignores that address.
r—  ré  rU  r¯  Nr  rk   r¼   )rV  rl  r   r©  ri  ró   rÚ  rg  r¾  ræ  r³   ri  )r_   rA  r�  r�  r¶   rí  rî  s          r`   Útest_ignoreUnknownAddressTypesÚEHostnameEndpointsFasterConnectionTests.test_ignoreUnknownAddressTypesc
  sÆ   € ô
 &›ˆŒÜ!×2Ò2Ü)Ø—‘ 	¬6«8°ZÐ@óð Øó
ˆŒð ˆà�‰×Ñ˜mÔ,à�‰×Ñ˜cÔ"Ø6:·m±m×6NÑ6NÈqÑ6QÑ3ˆ�W {Ø×Ñœ˜TŸ]™]×5Ñ5Ó6¸Ô:Ø×Ñ˜˜zÔ*Ø×Ñ˜˜rÕ"rc   c                ó�  • [         R                  " 5       n[         R                  Ul         U R                  R	                  U5      n/ nUR                  UR                  5        U R                  R                  S   u  pEpgnU R                  US5        U R                  US5        UR                  XE45      n	[        5       n
U R                  U/ 5        U	R                  U
5        U R                  [        U5      S5        U R                  US   R                  U5        U R                  / U R                  R                  5       5        g)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.
r   r—  r¯  rk   N)r   r2   r3   rÚ  rg  rÏ   rp   rl  ræ  r³   rª   ró   rí   ri  r¶   rÀ  ©r_   rA  rÐ   Úresultsr�  r�  r¶   rí  rî  rk  ÚfakeTransports              r`   Útest_IPv4IsFasterÚ8HostnameEndpointsFasterConnectionTests.test_IPv4IsFasterz
  s  € ô !×(Ò(Ó*ˆÜ!)×!2Ñ!2ˆÔà�M‰M×!Ñ! -Ó0ˆØˆØ	�‰�g—n‘nÔ%Ø6:·m±m×6NÑ6NÈqÑ6QÑ3ˆ�W {à×Ñ˜˜yÔ)Ø×Ñ˜˜rÔ"à×%Ñ% t lÓ3ˆÜ›ˆà×Ñ˜ "Ô%à×Ñ˜]Ô+à×Ñœ˜W› qÔ)Ø×Ñ˜ ™×+Ñ+¨]Ô;Ø×Ñ˜˜TŸ]™]×:Ñ:Ó<Õ=rc   c                óÆ  • [         R                  " 5       n[         R                  Ul         U R                  R	                  U5      n/ nUR                  UR                  5        U R                  R                  S5        U R                  R                  S   u  pEpgnU R                  US5        U R                  US5        UR                  XE45      n	[        5       n
U R                  U/ 5        U	R                  U
5        U R                  [        U5      S5        U R                  US   R                  U5        U R                  / U R                  R!                  5       5        g)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  rk   ré  r¯  r   N)r   r2   r3   rÚ  rg  rÏ   rp   rl  r¾  ræ  r³   rª   ró   rí   ri  r¶   rÀ  r[  s              r`   Útest_IPv6IsFasterÚ8HostnameEndpointsFasterConnectionTests.test_IPv6IsFaster™
  s  € ô !×(Ò(Ó*ˆÜ!)×!2Ñ!2ˆÔà�M‰M×!Ñ! -Ó0ˆØˆØ	�‰�g—n‘nÔ%à�‰×Ñ˜cÔ"Ø6:·m±m×6NÑ6NÈqÑ6QÑ3ˆ�W {à×Ñ˜˜zÔ*Ø×Ñ˜˜rÔ"à×%Ñ% t lÓ3ˆÜ›ˆà×Ñ˜ "Ô%à×Ñ˜]Ô+à×Ñœ˜W› qÔ)Ø×Ñ˜ ™×+Ñ+¨]Ô;Ø×Ñ˜˜TŸ]™]×:Ñ:Ó<Õ=rc   c                óf  • [         R                  " 5       n[         R                  Ul         U R                  R	                  U5      n/ nUR                  UR                  5        U R                  R                  S5        U R                  R                  S   u  pEpgnUR                  XE45      n	[        5       n
U	R                  U
5        U R                  SU R                  R                  S   S   R                  R                  5        U R                  / U R                  R!                  5       5        g)zØ
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  rk   Tr   r¼   N)r   r2   r3   rÚ  rg  rÏ   rp   rl  r¾  ræ  rª   ró   rí   r³   rý  rþ  rÀ  r[  s              r`   Útest_otherConnectionsCancelledÚEHostnameEndpointsFasterConnectionTests.test_otherConnectionsCancelledº
  sï   € ô !×(Ò(Ó*ˆÜ!)×!2Ñ!2ˆÔà�M‰M×!Ñ! -Ó0ˆØˆØ	�‰�g—n‘nÔ%à�‰×Ñ˜cÔ"Ø6:·m±m×6NÑ6NÈqÑ6QÑ3ˆ�W {à×%Ñ% t lÓ3ˆÜ›ˆà×Ñ˜]Ô+à×ÑØ�$—-‘-×*Ñ*¨1Ñ-¨aÑ0×;Ñ;×MÑMô	
ð 	×Ñ˜˜TŸ]™]×:Ñ:Ó<Õ=rc   )rÚ  rl  N)ry   rz   r{   r|   r}   rÛ  rX  r^  ra  rd  r~   rf   rc   r`   rS  rS  U
  s!   † ñò

ò#ò.>ò>>õB>rc   rS  c                  ó@   • \ rS rSrSrS rS rS rS rS r	SS jr
S	rg
)Ú HostnameEndpointBindAddressTypesi×
  zZ
Tests that HostnameEndpoint accepts all specified types for the
'bindAddress=' argument.
c                ó8   • [        [        5       S/5      U l        g )Nr  )ri  rV  Údrrr^   s    r`   rÛ  Ú&HostnameEndpointBindAddressTypes.setUpÝ
  s   € Ü0´³À;À-ÓPˆ�rc   c                ó‚   • Sn[         R                  " U R                  SSUS9nU R                  UR                  S5        g )Nó   1.2.3.4rÛ  r¯  ©rî  ©r—  r   ©r   r©  ri  r³   Ú_bindAddress©r_   ÚbarW  s      r`   Ú
test_bytesÚ+HostnameEndpointBindAddressTypes.test_bytesà
  s6   € ØˆÜ×'Ò'¨¯©°.À"ÐRTÑUˆØ×Ñ˜Ÿ™¨.Õ9rc   c                ó‚   • Sn[         R                  " U R                  SSUS9nU R                  UR                  S5        g )Nr—  rÛ  r¯  rm  rn  ro  rq  s      r`   Útest_strÚ)HostnameEndpointBindAddressTypes.test_strå
  s6   € ØˆÜ×'Ò'¨¯©°.À"ÐRTÑUˆØ×Ñ˜Ÿ™¨.Õ9rc   c                ó‚   • Sn[         R                  " U R                  SSUS9nU R                  UR                  S5        g )N)rl  r;  rÛ  r¯  rm  ©r—  r;  ro  rq  s      r`   Útest_tuple_bytesÚ1HostnameEndpointBindAddressTypes.test_tuple_bytesê
  s7   € ØˆÜ×'Ò'¨¯©°.À"ÐRTÑUˆØ×Ñ˜Ÿ™Ð*;Õ<rc   c                ó‚   • Sn[         R                  " U R                  SSUS9nU R                  UR                  S5        g )Nry  rÛ  r¯  rm  ro  rq  s      r`   Útest_tuple_strÚ/HostnameEndpointBindAddressTypes.test_tuple_strï
  s7   € ØˆÜ×'Ò'¨¯©°.À"ÐRTÑUˆØ×Ñ˜Ÿ™Ð*;Õ<rc   c                ó‚   • S n[         R                  " U R                  SSUS9nU R                  UR                  S 5        g )NrÛ  r¯  rm  ro  rq  s      r`   Ú	test_noneÚ*HostnameEndpointBindAddressTypes.test_noneô
  s6   € ØˆÜ×'Ò'¨¯©°.À"ÐRTÑUˆØ×Ñ˜Ÿ™¨$Õ/rc   )ri  Nr›  )ry   rz   r{   r|   r}   rÛ  rs  rv  rz  r}  r€  r~   rf   rc   r`   rg  rg  ×
  s&   † ñò
Qò:ò
:ò
=ò
=÷
0rc   rg  c                  óH   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rSrg)ÚSSL4EndpointsTestsiú
  z
Tests for SSL Endpoints.
c                ó   • UR                   $ )z4
@return: List of calls to L{IReactorSSL.listenSSL}
)Ú
sslServersrJ  s     r`   rª  Ú"SSL4EndpointsTests.expectedServers   râ  rc   c                ó   • UR                   $ )z5
@return: List of calls to L{IReactorSSL.connectSSL}
)Ú
sslClientsrJ  s     r`   rK  Ú"SSL4EndpointsTests.expectedClients  râ  rc   c                óÒ   • Uu  nnnnnnUu  n	n
nnnnU R                  X95        U R                  XJ5        U R                  Xl5        U R                  X}5        U R                  XŽ5        g)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ê  )r_   rN  rO  r�  r�  rì  ÚcontextFactoryrí  rî  r«  rï  rð  ÚexpectedContextFactoryrñ  rò  s                  r`   rP  Ú$SSL4EndpointsTests.assertConnectArgs  s‚   € ð* ñ	
ØØØØØØð ñ	
ØØØØ"ØØð 	×Ñ˜Ô,Ø×Ñ˜Ô,Ø×Ñ˜Ô@Ø×Ñ˜Ô2Ø×Ñ˜Õ:rc   c                ó   • SSS.$ rö  rf   r^   s    r`   rB  ÚSSL4EndpointsTests.connectArgs2  rý  rc   c                ó   • SSS.$ rÿ  rf   r^   s    r`   r¸  ÚSSL4EndpointsTests.listenArgs8  r  rc   c                óÄ   • [        SSS9u  U l        U l        [        SSS9u  U l        U l        [        U R                  U R                  SS9U l        [        SS9U l        g	)
z6
Set up client and server SSL contexts for use later.
zServer Test CertificateÚserver)ÚOÚCNzClient Test CertificateÚclientF)Ú
privateKeyÚcertificateÚrequireCertificate)r™  N)rT   ÚsKeyÚsCertÚcKeyÚcCertrN   ÚserverSSLContextÚclientSSLContextr^   s    r`   rÛ  ÚSSL4EndpointsTests.setUp>  sc   € ô !0Ø'¨Hñ!
ÑˆŒ	�4”:ô !0Ø'¨Hñ!
ÑˆŒ	�4”:ô !3Ø—y‘y¨d¯j©jÈUñ!
ˆÔô !3ÀeÑ LˆÕrc   c           	     óì   • [        SSS5      n[        R                  " XR                  U R                  40 UD6UR                  UU R                  UR                  SS5      UR                  SS5      4U4$ )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}.
r	  r
  r   r  r  r  rU   )r"   r   ÚSSL4ServerEndpointr�  rž  r  r  s        r`   r   Ú'SSL4EndpointsTests.createServerEndpointM  s~   € ô ˜e Y°Ó2ˆô ×(Ò(ØŸ™ t×'<Ñ'<ñØ@Jñð —‘ØØ×%Ñ%Ø—‘˜y¨"Ó-Ø—‘˜{¨BÓ/ðð ð
ð 	
rc   c           
     ó  • [        SSS5      n[        R                  " UUR                  UR                  U R
                  40 UD6UR                  UR                  UU R
                  UR                  SS5      UR                  SS5      4U4$ )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}
r	  rú  r¯  rí  r  rî  N)r"   r   ÚSSL4ClientEndpointr�  r�  rŸ  r  r  s        r`   rC  Ú'SSL4EndpointsTests.createClientEndpointi  s’   € ô ˜e [°"Ó5ˆô ×(Ò(ØØ—‘Ø—‘Ø×%Ñ%ñ	ð
 ñð —‘Ø—‘ØØ×%Ñ%Ø—‘ 	¨2Ó.Ø—‘ ¨tÓ4ðð ð!
ð 	
rc   )r�  rœ  rŸ  r›  rš  rž  N)ry   rz   r{   r|   r}   rª  rK  rP  rB  r¸  rÛ  r   rC  r~   rf   rc   r`   rƒ  rƒ  ú
  s2   † ñò"ò"ò$;òLDò:òMò
õ8
rc   rƒ  c                  óH   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rSrg)ÚUNIXEndpointsTestsi‹  z!
Tests for UnixSocket Endpoints.
c                ó0   • U R                  U5      S   S   $ )z€
Override L{EndpointTestCaseMixin.retrieveConnectedFactory} to account
for different index of 'factory' in C{connectUNIX} args.
r   rk   r]  rJ  s     r`   r^  Ú+UNIXEndpointsTests.retrieveConnectedFactory�  s   € ð
 ×#Ñ# GÓ,¨QÑ/°Ñ2Ð2rc   c                ó   • UR                   $ )z6
@return: List of calls to L{IReactorUNIX.listenUNIX}
)ÚunixServersrJ  s     r`   rª  Ú"UNIXEndpointsTests.expectedServers—  ó   € ð ×"Ñ"Ð"rc   c                ó   • UR                   $ )z7
@return: List of calls to L{IReactorUNIX.connectUNIX}
)ÚunixClientsrJ  s     r`   rK  Ú"UNIXEndpointsTests.expectedClients�  r®  rc   c                ó‚   • Uu  p4pVUu  nnn	n
U R                  X75        U R                  XY5        U R                  Xj5        g)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ê  )r_   rN  rO  r  rì  rí  ÚcheckPIDÚexpectedPathrð  rñ  ÚexpectedCheckPIDs              r`   rP  Ú$UNIXEndpointsTests.assertConnectArgs£  sQ   € ð 5AÑ1ˆ˜wð ñ	
ØØØØð 	×Ñ˜Ô,Ø×Ñ˜Ô2Ø×Ñ˜Õ4rc   c                ó   • SSS.$ )r÷  rø  rk   )rí  r³  rf   r^   s    r`   rB  ÚUNIXEndpointsTests.connectArgs¼  s   € ð ¨1Ñ-Ð-rc   c                ó   • SSSS.$ )r   r  i€  rk   )r  ÚmodeÚwantPIDrf   r^   s    r`   r¸  ÚUNIXEndpointsTests.listenArgsÂ  s   € ð ¨¸!Ñ<Ð<rc   c           	     óú   • [        U R                  5       5      n[        R                  " XR                  40 UD6UR                  UUR                  SS5      UR                  SS5      UR                  SS5      4U4$ )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}.
r  r  rº  é¶  r»  r   )r$   Úmktempr   ÚUNIXServerEndpointr�  r  r  s        r`   r   Ú'UNIXEndpointsTests.createServerEndpointÈ  su   € ô ˜dŸk™k›mÓ,ˆô ×(Ò(¨·,±,ÑMÀ*ÑMà—‘ØØ—‘˜y¨"Ó-Ø—‘˜v uÓ-Ø—‘˜y¨!Ó,ðð ð

ð 
	
rc   c                óØ   • [        U R                  5       5      n[        R                  " XR                  40 UD6UR                  UUR                  SS5      UR                  SS5      4U4$ )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í  r  r³  r   )r$   r¿  r   ÚUNIXClientEndpointr�  r  r  s        r`   rC  Ú'UNIXEndpointsTests.createClientEndpointâ  sg   € ô ˜dŸk™k›mÓ,ˆô ×(Ò(¨·,±,ÑNÀ+ÑNà—‘ØØ—‘ 	¨2Ó.Ø—‘ 
¨AÓ.ð	ð ð	
ð 		
rc   rf   N)ry   rz   r{   r|   r}   r^  rª  rK  rP  rB  r¸  r   rC  r~   rf   rc   r`   r¨  r¨  ‹  s/   † ñò3ò#ò#ò5ò2.ò=ò
õ4
rc   r¨  c                  ó^   • \ rS rSrSrSrS rS rS rS r	S r
S	 rS
 rS rS rS rS rSrg)ÚParserTestsiü  zC
Tests for L{endpoints._parseServer}, the low-level parsing logic.
r2   c                ó.   • [         R                  " U0 UD6$ )zD
Provide a hook for test_strports to substitute the deprecated API.
)r   Ú_parseServer)r_   ÚaÚkws      r`   ÚparseÚParserTests.parse  s   € ô ×%Ò% qÐ/¨BÑ/Ð/rc   c                ó€   • U R                  U R                  SU R                  5      SSU R                  4SSS.45        g)z>
Simple strings with a 'tcp:' prefix should be parsed as TCP.
ztcp:80r	  r¯  rU   r  ©r  r  N©r³   rË  r  r^   s    r`   Útest_simpleTCPÚParserTests.test_simpleTCP	  s;   € ð 	×ÑØ�J‰J�x §¡Ó(Ø�R˜Ÿ™�L°¸rÑ"BÐCõ	
rc   c                ó€   • U R                  U R                  SU R                  5      SSU R                  4SSS.45        g)zE
TCP port descriptions parse their 'interface' argument as a string.
ztcp:80:interface=127.0.0.1r	  r¯  r  r  rÎ  NrÏ  r^   s    r`   Útest_interfaceTCPÚParserTests.test_interfaceTCP  s<   € ð 	×ÑØ�J‰JÐ3°T·V±VÓ<Ø�R˜Ÿ™�L°ÈÑ"KÐLõ	
rc   c                ó€   • U R                  U R                  SU R                  5      SSU R                  4SSS.45        g)zE
TCP port descriptions parse their 'backlog' argument as an integer.
ztcp:80:backlog=6r	  r¯  rU   é   rÎ  NrÏ  r^   s    r`   Útest_backlogTCPÚParserTests.test_backlogTCP  s<   € ð 	×ÑØ�J‰JÐ)¨4¯6©6Ó2Ø�R˜Ÿ™�L°¸qÑ"AÐBõ	
rc   c           	     ó‚   • U R                  U R                  SU R                  5      SSU R                  4SSSS.45        g)	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.
zunix:/var/run/fingerÚUNIXú/var/run/fingerr¾  r  T©rº  r  r»  NrÏ  r^   s    r`   Útest_simpleUNIXÚParserTests.test_simpleUNIX$  sC   € ð 	×ÑØ�J‰JÐ-¨t¯v©vÓ6àØ" D§F¡FÐ+Ø¨2¸$Ñ?ðõ	
rc   c           	     ó‚   • U R                  U R                  SU R                  5      SSU R                  4SSSS.45        g)	z;
C{mode} can be set by including C{"mode=<some integer>"}.
zunix:/var/run/finger:mode=0660rÚ  rÛ  i°  r  TrÜ  NrÏ  r^   s    r`   Útest_modeUNIXÚParserTests.test_modeUNIX3  sC   € ð 	×ÑØ�J‰JÐ7¸¿¹Ó@àØ" D§F¡FÐ+Ø¨2¸$Ñ?ðõ	
rc   c           	     ó‚   • U R                  U R                  SU R                  5      SSU R                  4SSSS.45        g)	z=
C{wantPID} can be set to false by included C{"lockfile=0"}.
zunix:/var/run/finger:lockfile=0rÚ  rÛ  r¾  r  FrÜ  NrÏ  r^   s    r`   Útest_wantPIDUNIXÚParserTests.test_wantPIDUNIX@  sC   € ð 	×ÑØ�J‰JÐ8¸$¿&¹&ÓAàØ" D§F¡FÐ+Ø¨2¸%Ñ@ðõ	
rc   c           	     ó‚   • U R                  U R                  SU R                  5      SSU R                  4SSSS.45        g)	zN
Backslash can be used to escape colons and backslashes in port
descriptions.
zunix:foo\:bar\=baz\:qux\\rÚ  zfoo:bar=baz:qux\r¾  r  TrÜ  NrÏ  r^   s    r`   Útest_escapeÚParserTests.test_escapeM  sC   € ð
 	×ÑØ�J‰JÐAÀ4Ç6Á6ÓJàØ&¨¯©Ð/Ø¨2¸$Ñ?ðõ	
rc   c                óP   • U R                  [        R                  " S5      S5        g)z¥
L{endpoints.quoteStringArgument} should quote backslashes and colons
for interpolation into L{endpoints.serverFromString} and
L{endpoints.clientFactory} arguments.
zsome : stuff \zsome \: stuff \\N)r³   r   ÚquoteStringArgumentr^   s    r`   Útest_quoteStringArgumentÚ$ParserTests.test_quoteStringArgument[  s$   € ð 	×ÑÜ×)Ò)Ð*=Ó>Ø'õ	
rc   c           	     ó‚   • U R                  U R                  SU R                  5      SSU R                  4SSSS.45        g)	z
In strports descriptions, '=' in a parameter value does not need to be
quoted; it will simply be parsed as part of the value.
zunix:address=foo=barrÚ  zfoo=barr¾  r  TrÜ  NrÏ  r^   s    r`   Útest_impliedEscapeÚParserTests.test_impliedEscapef  sC   € ð
 	×ÑØ�J‰JÐ.°·±Ó7àØ˜DŸF™FÐ#Ø¨2¸$Ñ?ðõ	
rc   c                ó\   • U R                  [        U R                  SU R                  5        g)zM
L{strports.parse} raises C{ValueError} when given an unknown endpoint
type.
zbogus-type:nothingN)r•  rÅ   rË  r  r^   s    r`   Útest_unknownTypeÚParserTests.test_unknownTypet  s!   € ð
 	×Ñœ* d§j¡jÐ2FÈÏÉÕOrc   rf   N)ry   rz   r{   r|   r}   r  rË  rÐ  rÓ  r×  rÝ  rà  rã  ræ  rê  rí  rð  r~   rf   rc   r`   rÆ  rÆ  ü  sF   † ñð 	€Aò0ò
ò
ò
ò
ò
ò
ò
ò	
ò
õPrc   rÆ  c                  óè   • \ rS rSrSrS r\" \\5      S 5       r	\" \\5      S 5       r
Sr\" \\5      S 5       r\" \\5      S 5       r\" \\5      S	 5       r\" \\5      S
 5       rS rS rS rSrg)ÚServerStringTestsi|  z;
Tests for L{twisted.internet.endpoints.serverFromString}.
c                óf  • [        5       n[        R                  " US5      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        g)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   ÚserverFromStringr‡  r  rÔ  r)  r³   Ú_portÚ_backlogÚ
_interface)r_   r   r“  s      r`   Útest_tcpÚServerStringTests.test_tcp�  s‰   € ô “(ˆÜ×+Ò+ØÐ=ó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨"Ô-Ø×Ñ˜×*Ñ*¨JÕ7rc   c                ó<  • [        5       n[        R                  " US[        < S[        < S35      nU R	                  U[        R
                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  R                  [        5        UR                  R                  5       nU R	                  U[         5        g)zž
When passed an SSL strports description, L{endpoints.serverFromString}
returns a L{SSL4ServerEndpoint} instance initialized with the values
from the string.
ússl:1234:backlog=12:privateKey=ú	:certKey=ú,:sslmethod=TLSv1_2_METHOD:interface=10.0.0.1r;  rõ  rö  N)ró   r   r÷  ÚescapedPEMPathNamer‡  r¢  rÔ  r)  r³   rø  rù  rú  Ú_sslContextFactoryÚmethodrL   Ú
getContextÚContextType©r_   r   r“  Úctxs       r`   Útest_sslÚServerStringTests.test_ssl‘  sÓ   € ô “(ˆÜ×+Ò+Ù÷ "×#5ð7ó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨"Ô-Ø×Ñ˜×*Ñ*¨JÔ7Ø×Ñ˜×2Ñ2×9Ñ9¼>ÔJØ×'Ñ'×2Ñ2Ó4ˆØ×Ñ˜c¤;Õ/rc   c                ó€  • [        5       n[        R                  " US[         35      nU R	                  U[        R
                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  R                  [        5        U R                  UR                  R                   ["        -  5        UR                  R%                  5       nU R	                  U[&        5        g)zz
An SSL string endpoint description with minimal arguments returns
a properly initialized L{SSL4ServerEndpoint} instance.
zssl:4321:privateKey=éá  r  rU   N)ró   r   r÷  r  r‡  r¢  rÔ  r)  r³   rø  rù  rú  r  r  rI   r  Ú_optionsrK   r  r  r  s       r`   Útest_sslWithDefaultsÚ&ServerStringTests.test_sslWithDefaults¨  sô   € ô “(ˆÜ×+Ò+ØÐ+Ô,>Ð+?Ð@ó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨"Ô-Ø×Ñ˜×*Ñ*¨BÔ/Ø×Ñ˜×2Ñ2×9Ñ9¼:ÔFØ�‰Ø×%Ñ%×.Ñ.´Ñ<ô	
ð ×'Ñ'×2Ñ2Ó4ˆØ×Ñ˜c¤;Õ/rc   z(ssl:1234:privateKey=%s:extraCertChain=%sc           	     ó(  • [         R                  " [        5       U R                  [        [
        4-  5      nS Vs/ s H>  n[        R                  " [        R                  SU4-  5      R                  5       5      PM@     nnUR                  nU R                  UR                  S   R                  S5      US   R                  S5      5        U R                  UR                  S   R                  S5      US   R                  S5      5        gs  snf )zN
Specifying a chain file loads the contained certificates in the right
order.
)rk   r¼   zthing%d.pemr   Úsha1rk   N)r   r÷  ró   ÚSSL_CHAIN_TEMPLATEr  ÚescapedChainPathNamerM   ÚloadPEMÚcasPathÚchildÚ
getContentr  r³   ÚextraCertChainÚdigest)r_   r“  ÚnÚexpectedChainCertsÚcfs        r`   Útest_sslChainLoadsÚ$ServerStringTests.test_sslChainLoadsÂ  s   € ô ×+Ò+Ü‹HØ×#Ñ#ä"Ü$ðñó
ˆñ ó
â�ô ×Ò¤§¡¨m¸q¸dÑ.BÓ C× NÑ NÓ PÖQÙð 	ð 
ð ×&Ñ&ˆØ×ÑØ×Ñ˜aÑ ×'Ñ'¨Ó/Ð1CÀAÑ1F×1MÑ1MÈfÓ1Uô	
ð 	×ÑØ×Ñ˜aÑ ×'Ñ'¨Ó/Ð1CÀAÑ1F×1MÑ1MÈfÓ1Uõ	
ùò
s   »ADc           	     óØ  • [        U R                  5       5      nUR                  5       R                  5         U R	                  [
        5       n[        R                  " [        5       U R                  [        [        R                  " UR                  5      4-  5        SSS5        U R                  [        WR                  5      SUR                  < S35        g! , (       d  f       NC= f)za
If C{extraCertChain} is passed, it has to contain at least one valid
certificate in PEM format.
NzSpecified chain file 'z7' doesn't contain any valid certificates in PEM format.)rB   r¿  ÚcreateÚcloser•  rÅ   r   r÷  ró   r  r  ré  r  r³   rš  r´  )r_   ÚfpÚcaughts      r`   Ú test_sslChainFileMustContainCertÚ2ServerStringTests.test_sslChainFileMustContainCertß  s­   € ô �d—k‘k“mÓ$ˆØ
�	‰	‹×ÑÔð ×ÑœzÔ*¨fÜ×&Ò&Ü“Ø×'Ñ'ä&Ü×1Ò1°"·'±'Ó:ðñô÷ +ð 	×ÑÜ�× Ñ Ô!ð
 �wŒwð	õ	
÷ +Õ*ús   ÁACÃ
C)c                ó2  • Sn[        5       n[        R                  " USR                  [        [        U5      5      nUR
                  nU R                  UR                  [        5        U R                  [        U5      UR                  R                  5        g)zm
If C{dhParameters} are specified, they are passed as
L{DiffieHellmanParameters} into L{CertificateOptions}.
ÚsomeFilez1ssl:4321:privateKey={}:certKey={}:dhParameters={}N)ró   r   r÷  Úformatr  r  r‡  ÚdhParametersrO   r³   rB   Ú_dhFile)r_   ÚfileNamer   r“  r  s        r`   Útest_sslDHparametersÚ&ServerStringTests.test_sslDHparametersÿ  sz   € ð ˆÜ“(ˆÜ×+Ò+ØØ?×FÑFÜ"Ô$6¸óó
ˆð ×&Ñ&ˆØ×Ñ˜bŸo™oÔ/FÔGØ×Ñœ (Ó+¨R¯_©_×-DÑ-DÕErc   c                ó<  • [        5       n[        R                  " US[        < S[        < S35      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  R                  [        5        UR                  R!                  5       nU R                  U["        5        g)zY
Lack of a trailing newline in key and cert .pem files should not
generate an exception.
rþ  rÿ  r   r;  rõ  rö  N)ró   r   r÷  Ú&escapedNoTrailingNewlineKeyPEMPathNameÚ'escapedNoTrailingNewlineCertPEMPathNamer‡  r¢  rÔ  r)  r³   rø  rù  rú  r  r  rL   r  r  r  s       r`   Útest_sslNoTrailingNewlinePemÚ.ServerStringTests.test_sslNoTrailingNewlinePem  sÓ   € ô “(ˆÜ×+Ò+Ù÷ 7ß7ð	ó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨"Ô-Ø×Ñ˜×*Ñ*¨JÔ7Ø×Ñ˜×2Ñ2×9Ñ9¼>ÔJØ×'Ñ'×2Ñ2Ó4ˆØ×Ñ˜c¤;Õ/rc   c                óœ  • [        5       n[        R                  " US5      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  5        g)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é   éS   N)ró   r   r÷  r‡  rÀ  rÔ  r)  r³   Ú_addressrù  Ú_moder  Ú_wantPID)r_   r   rÚ  s      r`   Ú	test_unixÚServerStringTests.test_unix*  sŸ   € ô “(ˆÜ×-Ò-ØÐGó
ˆð 	×Ñ˜h¬	×(DÑ(DÔEØ�‰�h×'Ñ'¨Ô1Ø×Ñ˜×*Ñ*¨NÔ;Ø×Ñ˜×*Ñ*¨AÔ.Ø×Ñ˜Ÿ™¨Ô/Ø�‰˜×)Ñ)Õ*rc   c                ó†   • U R                  [        [        R                  SS5      nU R	                  [        U5      S5        g)zY
L{endpoints.serverFromString} raises C{ValueError} when given an
unknown endpoint type.
Núftl:andromeda/carcosa/hali/2387úUnknown endpoint type: 'ftl')r•  rÅ   r   r÷  r³   rš  ©r_   rw  s     r`   rð  Ú"ServerStringTests.test_unknownType;  ó=   € ð
 ×!Ñ!äÜ×&Ñ&ØØ-ó
ˆð 	×Ñœ˜U›Ð%CÕDrc   c                ó&  • [        U 5        [        5       n[        R                  " US5      nSSKJn  U R                  UR                  U5        U R                  UR                  USS45        U R                  UR                  [        SSS95        g	)
zu
L{endpoints.serverFromString} looks up plugins of type
L{IStreamServerEndpoint} and constructs endpoints from them.
zfake:hello:world:yes=no:up=downr   )ÚfakeÚhelloÚworldÚnoÚdown)ÚyesÚupN)ÚaddFakePluginró   r   r÷  Útwisted.plugins.fakeendpointrB  rÔ  Úparserr³   rÉ   rC  Údict)r_   ÚnotAReactorÚfakeEndpointrB  s       r`   Útest_typeFromPluginÚ%ServerStringTests.test_typeFromPluginI  s|   € ô 	�dÔä“hˆÜ ×1Ò1ØÐ:ó
ˆõ 	6à�‰�l×)Ñ)¨4Ô0Ø×Ñ˜×*Ñ*¨[¸'À7Ð,KÔLØ×Ñ˜×,Ñ,¬d°tÀÑ.GÕHrc   rf   N)ry   rz   r{   r|   r}   rû  r   ÚskipSSLÚskipSSLReasonr  r  r  r  r#  r+  r0  r9  rð  rO  r~   rf   rc   r`   ró  ró  |  sÈ   † ñò8ñ  ˆG�]Ó#ñ0ó $ð0ñ, ˆG�]Ó#ñ0ó $ð0ð. DÐáˆG�]Ó#ñ
ó $ð
ñ8 ˆG�]Ó#ñ
ó $ð
ñ> ˆG�]Ó#ñFó $ðFñ" ˆG�]Ó#ñ0ó $ð0ò0+ò"EõIrc   ró  c                óÚ  ^^^• SSK mTR                  R                  5       m[        [        R
                  5      mUUU4S jnU R                  U5        [        U R                  5       5      nUR                  5         [        [        5      R                  R                  U5      R                  UR                  U5      5        [        R
                  R!                  UR"                  5        g)zt
For the duration of C{testCase}, add a fake plugin to twisted.plugins which
contains some sample endpoint parsers.
r   Nc                 ó–   >• TR                   R                  5         TR                   R                  T 5        T[        R                  S S & g ro   )ÚmodulesÚclearÚupdater   Ú__path__)ÚsavedModulesÚsavedPluginPathÚsyss   €€€r`   ÚcleanupÚaddFakePlugin.<locals>.cleanupg  s5   ø€ Ø�‰×ÑÔØ�‰×Ñ˜<Ô(Ø-Œ×Ñ™Ñrc   )r[  rU  rg  Úlistr   rX  rÂ  rB   r¿  ÚcreateDirectoryrC   ry   ÚfilePathÚsiblingÚcopyTor  rp   r  )ÚtestCaseÚdropinSourcer\  r!  rY  rZ  r[  s       @@@r`   rI  rI  ]  s¡   ú€ ó
 à—;‘;×#Ñ#Ó%€LÜœ7×+Ñ+Ó,€O÷.ð
 ×Ñ˜Ô Ü	�(—/‘/Ó#Ó	$€BØ×ÑÔÜŒhÓ× Ñ ×(Ñ(¨Ó6×=Ñ=¸b¿h¹hÀ|Ó>TÔUÜ×Ñ×Ñ˜BŸG™GÕ$rc   c                  óZ   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
 rS rS rS rSrg)ÚClientStringTestsis  z;
Tests for L{twisted.internet.endpoints.clientFromString}.
c                óž  • [        5       n[        R                  " US5      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        g)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;  r4  ©z10.0.0.2r   N©ró   r   ÚclientFromStringr‡  r  rÔ  r)  r³   Ú_hostrø  Ú_timeoutrp  ©r_   r   r–  s      r`   rû  ÚClientStringTests.test_tcpx  s�   € ô “(ˆÜ×+Ò+ØÐTó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ }Ô5Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨!Ô,Ø×Ñ˜×,Ñ,¨oÕ>rc   c                óž  • [        5       n[        R                  " US5      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        g)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;  r4  rh  Nri  rm  s      r`   Útest_tcpPositionalArgsÚ(ClientStringTests.test_tcpPositionalArgs‰  s�   € ô “(ˆÜ×+Ò+ØÐJó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ }Ô5Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨!Ô,Ø×Ñ˜×,Ñ,¨oÕ>rc   c                ó¶   • [        5       n[        R                  " US5      nU R                  UR                  S5        U R                  UR
                  S5        g)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ó   r   rj  r³   rk  rø  rm  s      r`   Útest_tcpHostPositionalArgÚ+ClientStringTests.test_tcpHostPositionalArgš  sK   € ô “(ˆä×+Ò+ØÐOó
ˆð 	×Ñ˜Ÿ™ }Ô5Ø×Ñ˜Ÿ™ tÕ,rc   c                ó¶   • [        5       n[        R                  " US5      nU R                  UR                  S5        U R                  UR
                  S5        g)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;  Nrs  rm  s      r`   Útest_tcpPortPositionalArgÚ+ClientStringTests.test_tcpPortPositionalArg¨  sK   € ô “(ˆÜ×+Ò+ØÐOó
ˆð 	×Ñ˜Ÿ™ }Ô5Ø×Ñ˜Ÿ™ tÕ,rc   c                ó´   • [        5       n[        R                  " US5      nU R                  UR                  S5        U R                  UR                  5        g)zc
A TCP strports description may omit I{timeout} or I{bindAddress} to
allow the default to be used.
ztcp:host=example.com:port=1234r  N)ró   r   rj  r³   rl  rß   rp  rm  s      r`   Útest_tcpDefaultsÚ"ClientStringTests.test_tcpDefaultsµ  sF   € ô
 “(ˆÜ×+Ò+¨GÐ5UÓVˆØ×Ñ˜Ÿ™¨"Ô-Ø×Ñ˜&×-Ñ-Õ.rc   c                ód  • [        5       n[        R                  " US5      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  5        g)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=9r3  é	   N©ró   r   rj  r‡  rÃ  rÔ  r)  r³   r-  rl  r  Ú	_checkPIDrm  s      r`   r9  ÚClientStringTests.test_unix¿  s…   € ô “(ˆÜ×+Ò+ØÐBó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ ~Ô6Ø×Ñ˜Ÿ™¨!Ô,Ø�‰˜×(Ñ(Õ)rc   c                ó°   • [         R                  " [        5       S5      nU R                  UR                  S5        U R                  UR                  5        g)zb
A UNIX strports description may omit I{lockfile} or I{timeout} to allow
the defaults to be used.
zunix:path=/var/foo/barr  N)r   rj  ró   r³   rl  r  r  )r_   r–  s     r`   Útest_unixDefaultsÚ#ClientStringTests.test_unixDefaultsÏ  sA   € ô
 ×+Ò+¬F«HÐ6NÓOˆØ×Ñ˜Ÿ™¨"Ô-Ø×Ñ˜×)Ñ)Õ*rc   c                ód  • [        5       n[        R                  " US5      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  5        g)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=9r3  r}  Nr~  rm  s      r`   Útest_unixPathPositionalArgÚ,ClientStringTests.test_unixPathPositionalArgØ  s…   € ô “(ˆÜ×+Ò+ØÐ=ó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ ~Ô6Ø×Ñ˜Ÿ™¨!Ô,Ø�‰˜×(Ñ(Õ)rc   c                ó&  • [        U 5        [        5       n[        R                  " US5      nSSKJn  U R                  UR                  U5        U R                  UR                  USS45        U R                  UR                  [        SSS95        g	)
zu
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)rI  ró   r   rj  rJ  rŠ  rÔ  rK  r³   rÉ   rC  rL  )r_   rM  ÚclientEndpointrŠ  s       r`   rO  Ú%ClientStringTests.test_typeFromPluginè  s~   € ô
 	�dÔÜ“hˆÜ"×3Ò3ØÐ:ó
ˆõ 	Gà�‰�n×+Ñ+Ð-BÔCØ×Ñ˜×,Ñ,¨{¸GÀVÐ.LÔMØ×Ñ˜×.Ñ.´¸ÀCÑ0HÕIrc   c                ó†   • U R                  [        [        R                  SS5      nU R	                  [        U5      S5        g)zY
L{endpoints.clientFromString} raises C{ValueError} when given an
unknown endpoint type.
Nr<  r=  )r•  rÅ   r   rj  r³   rš  r>  s     r`   rð  Ú"ClientStringTests.test_unknownTypeø  r@  rc   c           
     óê   • [        U 5        [        5       n[        R                  " US5      nSSKJn  U R                  UR                  UR                  UR                  4UUSS4[        SSS945        g	)
zŠ
L{endpoints.clientFromString} will pass a reactor to plugins
implementing the L{IStreamClientEndpointStringParserWithReactor}
interface.
rˆ  r   r‰  r‹  rŒ  r�  rŽ  r�  N)rI  ró   r   rj  rJ  rŠ  r³   rK  rÉ   rC  rL  )r_   r   r’  rŠ  s       r`   Útest_stringParserWithReactorÚ.ClientStringTests.test_stringParserWithReactor  su   € ô 	�dÔÜ“(ˆÜ"×3Ò3ØÐ6ó
ˆõ 	Gà×ÑØ×"Ñ" N×$7Ñ$7¸×9NÑ9NÐOà%Ø˜' 6Ð*Ü˜ CÑ(ðõ	
rc   rf   N)ry   rz   r{   r|   r}   rû  rp  rt  rw  rz  r9  r‚  r…  rO  rð  r—  r~   rf   rc   r`   rf  rf  s  s@   † ñò?ò"?ò"-ò-ò/ò*ò +ò*ò Jò Eõ
rc   rf  c                  ó6   • \ rS rSrSrS rS rS rS rS r	Sr
g	)
ÚSSLClientStringTestsi  zM
Tests for L{twisted.internet.endpoints.clientFromString} which require SSL.
c           	     ó²  ^	• [        5       n[        R                  " US[        < S[        < S[        < 35      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        UR                  nU R                  U[        5        U R                  UR                   ["        5        U R%                  UR&                  [(        -  5        UR+                  5       nU R                  U[,        5        U R                  [/        UR0                  5      [2        5        [5        UR0                  5      nUR7                  [9        UR:                  5      5        U R                  U[<        5        [>        RA                  S5      [>        RA                  S	5      4 Vs/ s H[  nURC                  5       RE                  5       RG                  S
5      (       d  M7  [.        RH                  " URK                  5       5      PM]     nn/ m	 " U	4S jS5      nURL                  RO                  U" 5       5        U R                  [Q        S T	 5       S S9[Q        US S95        gs  snf )ú”
When passed an SSL strports description, L{clientFromString} returns a
L{SSL4ClientEndpoint} instance initialized with the values from the
string.
z*ssl:host=example.net:port=4321:privateKey=rÿ  ú+:bindAddress=10.0.0.3:timeout=3:caCertsDir=úexample.netr  r»   ©z10.0.0.3r   ú
thing1.pemú
thing2.pemz.pemc                  ó"   >• \ rS rSrU 4S jrSrg)Ú.SSLClientStringTests.test_ssl.<locals>.ListCtxiG  c                ó,   >•  " U4S jS5      nU" 5       $ )Nc                  ó"   >• \ rS rSrU 4S jrSrg)ÚLSSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_store.<locals>.StoreiI  c                ó(   >• TR                  U5        g ro   r  )r_   ÚcertÚ
addedCertss     €r`   Úadd_certÚUSSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_store.<locals>.Store.add_certJ  s   ø€ Ø"×)Ñ)¨$Õ/rc   rf   N)ry   rz   r{   r|   rª  r~   ©r©  s   €r`   ÚStorer¦  I  s   ø† ÷0ð 0rc   r­  rf   )r_   r­  r©  s     €r`   Úget_cert_storeÚ=SSLClientStringTests.test_ssl.<locals>.ListCtx.get_cert_storeH  s   ø€ ÷0ô 0ñ “w�rc   rf   N)ry   rz   r{   r|   r®  r~   r¬  s   €r`   ÚListCtxr£  G  s   ø† ÷ð rc   r°  c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fro   )rM   )Ú.0Úxs     r`   Ú	<genexpr>Ú0SSLClientStringTests.test_ssl.<locals>.<genexpr>R  s   é € Ð4ª A”˜Q—�ªùs   ‚c                ó"   • U R                  5       $ ro   ©r  ©r¨  s    r`   rË   Ú/SSLClientStringTests.test_ssl.<locals>.<lambda>R  s
   € ÀtÇ{Á{Ä}rc   )Úkeyc                ó"   • U R                  5       $ ro   r·  r¸  s    r`   rË   r¹  T  s
   € °4·;±;´=rc   N))ró   r   rj  r  ÚescapedCAsPathNamer‡  r¥  rÔ  r)  r³   rk  rø  rl  rp  r  rN   r  rI   r  r  rK   r  r  rM   r˜  ÚtestCertificaterQ   Ú_setPrivateKeyrP   r—  ÚtestPrivateCertificater  r  ÚbasenameÚlowerÚendswithr  r  Ú	trustRootÚ_addCACertsToContextÚsorted)
r_   r   r–  ÚcertOptionsr  ÚprivateCertr³  ÚexpectedCertsr°  r©  s
            @r`   r  ÚSSLClientStringTests.test_ssl#  s-  ø€ ô “(ˆÜ×+Ò+Ù÷ "×#5Ö7IðKó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ }Ô5Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨!Ô,Ø×Ñ˜×,Ñ,¨oÔ>Ø×/Ñ/ˆØ×Ñ˜kÔ+=Ô>Ø×Ñ˜×+Ñ+¬ZÔ8Ø�‰˜×,Ñ,¬{Ñ:Ô;Ø×$Ñ$Ó&ˆØ×Ñ˜c¤;Ô/Ø×Ñœ [×%<Ñ%<Ó=¼ÔOÜ(¨×)@Ñ)@ÓAˆØ×"Ñ"¤7¨;×+AÑ+AÓ#BÔCØ×Ñ˜Ô&<Ô=ô —m‘m LÓ1´7·=±=ÀÓ3NÑOó
âO�Ø�z‰z‹|×!Ñ!Ó#×,Ñ,¨V×4ó 0ŒK×Ò §¡£Ö/ÙOð 	ð 
ð
 ˆ
÷	ô 	ð 	×Ñ×2Ñ2±7³9Ô=Ø×ÑÜÙ4©Ó4Ñ:Tñô �=Ñ&@ÑAõ		
ùò!
s   È6KÉ(Kc           	     óÎ  • [        5       n[        R                  " US[        < S[        < S[        < 35      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        g)	rœ  z ssl:example.net:4321:privateKey=rÿ  r�  rž  r  r»   rŸ  N)ró   r   rj  r  r¼  r‡  r¥  rÔ  r)  r³   rk  rø  rl  rp  rm  s      r`   Útest_sslPositionalArgsÚ+SSLClientStringTests.test_sslPositionalArgsW  s«   € ô “(ˆÜ×+Ò+Ù÷ "×#5Ö7IðKó
ˆð 	×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ }Ô5Ø×Ñ˜Ÿ™ tÔ,Ø×Ñ˜Ÿ™¨!Ô,Ø×Ñ˜×,Ñ,¨oÕ>rc   c                óò  • [        5       n[        R                  " US5      nU R                  U[        R                  5        U R                  UR                  U5        U R                  UR                  S5        U R                  UR                  S5        UR                  nU R                  UR                  [        5        U R                  UR                  5        U R                  UR                  5        g)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.
zssl:example.net:4321rž  r  N)ró   r   rj  r‡  r¥  rÔ  r)  r³   rk  rø  r  r  rI   rß   r˜  r—  )r_   r   r–  rÆ  s       r`   r  Ú)SSLClientStringTests.test_sslWithDefaultsk  s·   € ô “(ˆÜ×+Ò+¨GÐ5KÓLˆØ×Ñ˜f¤i×&BÑ&BÔCØ�‰�f—o‘o wÔ/Ø×Ñ˜Ÿ™ }Ô5Ø×Ñ˜Ÿ™ tÔ,Ø×/Ñ/ˆØ×Ñ˜×+Ñ+¬ZÔ8Ø×Ñ˜+×1Ñ1Ô2Ø×Ñ˜+×0Ñ0Õ1rc   c                ó~  •  " S S[         5      n[        R                  S5      R                  5       nXl        U R                  [        R                  " U5      R                   Vs/ s H  n[        U5      PM     sn[        R                  " [        R                  S5      R                  5       5      /5        gs  snf )zm
If a certificate in the directory is unreadable,
L{endpoints._loadCAsFromDir} will ignore that certificate.
c                  ó   • \ rS rSrS rSrg)ÚKSSLClientStringTests.test_unreadableCertificate.<locals>.UnreadableFilePathi‚  c                óž   • [         R                  " U 5      nU[        R                  S5      R                  5       :X  a  [	        [
        5      eU$ )Nr¡  )rB   r  r  r  ÚOSErrorr   rq   s     r`   r  ÚVSSLClientStringTests.test_unreadableCertificate.<locals>.UnreadableFilePath.getContentƒ  s=   € Ü×*Ò*¨4Ó0�ð œ7Ÿ=™=¨Ó6×AÑAÓCÓCÜ!¤%›.Ð(à�Krc   rf   N)ry   rz   r{   r|   r  r~   rf   rc   r`   ÚUnreadableFilePathrÑ  ‚  s   † õ rc   rÕ  rŸ  r   N)rB   r  r  ÚparentÚ	clonePathr³   r   Ú_loadCAsFromDirÚ_caCertsrM   r  r  )r_   rÕ  ÚcasPathCloner³  s       r`   Útest_unreadableCertificateÚ/SSLClientStringTests.test_unreadableCertificate|  sŠ   € ô	 ¤ô 	 ô —}‘} YÓ/×6Ñ6Ó8ˆØ!3ÔØ×ÑÜ%.×%>Ò%>¸|Ó%L×%UÒ%UÓVÒ%U Œ[˜Ž^Ñ%UÑVÜ× Ò ¤§¡¨|Ó!<×!GÑ!GÓ!IÓJÐKõ	
ùÚVs   Á&B:c                ó  • [        5       n[        R                  " US5      nUR                  nU R	                  U[
        5        U R                  UR                  5        UR                  5       nU R	                  U[        5        g)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ó   r   rj  r  r‡  rN   r  Úverifyr  r  )r_   r   r–  rÆ  r  s        r`   Útest_sslSimpleÚ#SSLClientStringTests.test_sslSimple“  sq   € ô “(ˆÜ×+Ò+ØÐ<ó
ˆð ×/Ñ/ˆØ×Ñ˜kÔ+=Ô>Ø×Ñ˜×+Ñ+Ô,Ø×$Ñ$Ó&ˆØ×Ñ˜c¤;Õ/rc   rf   N)ry   rz   r{   r|   r}   r  rË  r  rÛ  rß  r~   rf   rc   r`   rš  rš    s!   † ñò2
òh?ò(2ò"
õ.0rc   rš  c                  óB   • \ rS rSrSrS rS rS rS rS r	S r
S	 rS
rg)Ú AdoptedStreamServerEndpointTestsi¤  z9
Tests for adopted socket-based stream server endpoints.
c                óT   • [         R                  " XU5      nS Ul        S Ul        U$ )z”
Create an L{AdoptedStreamServerEndpoint} which may safely be used with
an invalid file descriptor.  This is convenient for a number of unit
tests.
c                ó   • g ro   rf   ©r  s    r`   rË   ÚPAdoptedStreamServerEndpointTests._createStubbedAdoptedEndpoint.<locals>.<lambda>²  s   € ˜drc   c                ó   • g ro   rf   rå  s    r`   rË   ræ  ³  s   €  trc   )r   ÚAdoptedStreamServerEndpointÚ_closeÚ_setNonBlocking)r_   r   ÚfilenoÚaddressFamilyrÊ   s        r`   Ú_createStubbedAdoptedEndpointÚ>AdoptedStreamServerEndpointTests._createStubbedAdoptedEndpoint©  s,   € ô ×1Ò1°'À=ÓQˆñ #ˆŒÙ+ˆÔØˆrc   c                ó\   • Sn[         nU R                  XU5      n[        SSS5      nXSXB4U4$ )aF  
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.
rõ  r	  r
  r;  )r   rí  r"   )r_   r   r¶   rë  rì  rÚ  rY  s          r`   r   Ú5AdoptedStreamServerEndpointTests.createServerEndpoint¶  s>   € ð ˆÜˆØ×5Ñ5°gÀ}ÓUˆä˜e Y°Ó5ˆØ =Ð:¸GÐDÐDrc   c                ó   • UR                   $ )z…
@return: The ports which were actually adopted by C{reactor} via calls
    to its L{IReactorSocket.adoptStreamPort} implementation.
)ÚadoptedPortsrJ  s     r`   rª  Ú0AdoptedStreamServerEndpointTests.expectedServersÈ  s   € ð
 ×#Ñ#Ð#rc   c                ó   • 0 $ )z`
@return: A C{dict} of additional keyword arguments to pass to the
    C{createServerEndpoint}.
rf   r^   s    r`   r¸  Ú+AdoptedStreamServerEndpointTests.listenArgsÏ  s	   € ð
 ˆ	rc   c                ó  ^ ^• [        5       mT R                  TS[        5      nUR                  [	        5       5        T R                  UR                  [	        5       5      [        R                  5      nUU 4S jnUR                  U5        U$ )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}.
é   c                óP   >• TR                  S[        TR                  5      5        g rj   )r³   ri  rò  )rŸ  r   r_   s    €€r`   ÚlistenFailedÚEAdoptedStreamServerEndpointTests.test_singleUse.<locals>.listenFailedá  s   ø€ Ø×Ñ˜Q¤ G×$8Ñ$8Ó 9Õ:rc   )	rV  rí  r   r©  ró   rÍ   r   ÚAlreadyListenedrÏ   )r_   rÚ  rÐ   rù  r   s   `   @r`   Útest_singleUseÚ/AdoptedStreamServerEndpointTests.test_singleUseÖ  si   ù€ ô  “/ˆØ×5Ñ5°g¸rÄ7ÓKˆØ�‰œ›Ô!Ø×Ñ˜xŸ™¬v«xÓ8¼%×:OÑ:OÓPˆö	;ð 	
�‰�lÔ#Øˆrc   c                óÊ   ^ ^• [        5       nT R                  US[        5      n/ mU4S jnX2l        UR	                  [        5       5      nUU 4S jnUR                  U5        U$ )z^
L{AdoptedStreamServerEndpoint.listen} sets the file description given
to it to non-blocking.
r÷  c                ó,   >• TR                  SU 45        g )NÚsetNonBlockingr  )rë  Úeventss    €r`   r   ÚTAdoptedStreamServerEndpointTests.test_descriptionNonBlocking.<locals>.setNonBlockingð  s   ø€ Ø�M‰MÐ+¨VÐ4Õ5rc   c                ó,   >• TR                  S/T5        g )N)r   r÷  rê  ©rŸ  r  r_   s    €€r`   ÚlistenedÚNAdoptedStreamServerEndpointTests.test_descriptionNonBlocking.<locals>.listened÷  s   ø€ Ø×ÑÐ4Ð5°vÕ>rc   )rV  rí  r   rê  r©  ró   rÏ   )r_   r   rÚ  r   rÐ   r  r  s   `     @r`   Útest_descriptionNonBlockingÚ<AdoptedStreamServerEndpointTests.test_descriptionNonBlockingç  sZ   ù€ ô
  “/ˆØ×5Ñ5°g¸rÄ7ÓKˆØˆõ	6ð $2Ô à�O‰OœF›HÓ%ˆö	?ð 	
�‰�hÔØˆrc   c                óÎ   ^ ^^• [        5       mT R                  TS[        5      n/ mUU4S jnX!l        UR	                  [        5       5      nUU 4S jnUR                  U5        U$ )z‰
L{AdoptedStreamServerEndpoint.listen} closes its file descriptor after
adding it to the reactor with L{IReactorSocket.adoptStreamPort}.
r÷  c                óT   >• TR                  SU [        TR                  5      45        g )Nr   )rp   ri  rò  )rë  r  r   s    €€r`   r   ÚEAdoptedStreamServerEndpointTests.test_descriptorClosed.<locals>.close  s!   ø€ Ø�M‰M˜7 F¬C°×0DÑ0DÓ,EÐFÕGrc   c                ó,   >• TR                  S/T5        g )N)r   r÷  rk   rê  r  s    €€r`   r  ÚHAdoptedStreamServerEndpointTests.test_descriptorClosed.<locals>.listened  s   ø€ Ø×ÑÐ.Ð/°Õ8rc   )rV  rí  r   ré  r©  ró   rÏ   )r_   rÚ  r   rÐ   r  r  r   s   `    @@r`   Útest_descriptorClosedÚ6AdoptedStreamServerEndpointTests.test_descriptorClosedý  sZ   ú€ ô
  “/ˆØ×5Ñ5°g¸rÄ7ÓKˆØˆö	Hð  Œà�O‰OœF›HÓ%ˆö	9ð 	
�‰�hÔØˆrc   rf   N)ry   rz   r{   r|   r}   rí  r   rª  r¸  rü  r  r  r~   rf   rc   r`   râ  râ  ¤  s+   † ñòòEò$$òòò"õ,rc   râ  c                  ó®   • \ rS rSrSr\R                  rS rS r	      SS jr
      SS jrSS jrSS jrSS	 jrSS
 jrSS jrSS jrSS jrSrg)ÚSystemdEndpointPluginTestsi  zŸ
Unit tests for the systemd stream server endpoint and endpoint string
description parser.

@see: U{systemd<http://www.freedesktop.org/wiki/Software/systemd>}
c                ó¼   • [        [        [        R                  5      5      nU H  n[	        X R
                  5      (       d  M    g   U R                  SU< 35        g)zq
L{endpoints._SystemdParser} is found as a plugin for
L{interfaces.IStreamServerEndpointStringParser} interface.
zDid not find systemd parser in N©r^  r<   r   Ú!IStreamServerEndpointStringParserrT  Ú_parserClassrù   ©r_   Úparsersrï   s      r`   Útest_pluginDiscoveryÚ/SystemdEndpointPluginTests.test_pluginDiscovery  sM   € ô
 ”z¤*×"NÑ"NÓOÓPˆãˆAÜ˜!×.Ñ.×/Ó/Ùñ ð �I‰IÐ7¸±{ÐCÕDrc   c                óv   • U R                  5       nU R                  [        [        R                  U5      5        g)z`
L{endpoints._SystemdParser} instances provide
L{interfaces.IStreamServerEndpointStringParser}.
N©r  r  r   r   r  ©r_   rK  s     r`   rZ  Ú)SystemdEndpointPluginTests.test_interface+  ó.   € ð
 ×"Ñ"Ó$ˆØ�‰Üœ×EÑEÀvÓNõ	
rc   c                óJ  • [        5       n/ SQn/ SQnSnU R                  5       n[        XE5      Ul        UR	                  X2[        U5      S9nU R                  UR                  U5        U R                  UR                  U5        U R                  UR                  XF   5        g)aÄ  
Helper for tests for L{endpoints._SystemdParser.parseStreamServer}
for different address families with a descriptor identified by index.

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=  rÖ  r4  é   r}  ©z5.socketz6.socketÚfooz8.socketz9.socketr»   )ÚdomainÚindexN)ró   r  rD   Ú	_sddaemonÚparseStreamServerrš  rÔ  r   r³   rì  rë  )	r_   rì  ÚaddressFamilyStringr   ÚdescriptorsÚnamesr%  rK  r“  s	            r`   Ú_parseIndexStreamServerTestÚ6SystemdEndpointPluginTests._parseIndexStreamServerTest5  s”   € ô  “(ˆÚ%ˆÚGˆØˆà×"Ñ"Ó$ˆÜ$ [Ó8ˆÔà×)Ñ)Ø´s¸5³zð *ð 
ˆð 	�‰�f—n‘n gÔ.Ø×Ñ˜×-Ñ-¨}Ô=Ø×Ñ˜Ÿ™¨Ñ(:Õ;rc   c                óX  • [        5       n/ SQn/ SQnSnU R                  5       n[        XE5      Ul        UR	                  UUUS9nU R                  UR                  U5        U R                  UR                  U5        U R                  UR                  XER                  U5         5        g)zM
Like L{_parseIndexStreamServerTest} but for descriptors identified by
name.
r   r"  r#  )r$  r�  N)ró   r  rD   r&  r'  rÔ  r   r³   rì  rë  r%  )	r_   rì  r(  r   r)  r*  r�  rK  r“  s	            r`   Ú_parseNameStreamServerTestÚ5SystemdEndpointPluginTests._parseNameStreamServerTestT  s�   € ô “(ˆÚ%ˆÚGˆØˆà×"Ñ"Ó$ˆÜ$ [Ó8ˆÔà×)Ñ)ØØ&Øð *ð 
ˆð
 	�‰�f—n‘n gÔ.Ø×Ñ˜×-Ñ-¨}Ô=Ø×Ñ˜Ÿ™¨·K±KÀÓ4EÑ(FÕGrc   c                ó0   • U R                  [        S5        g©z3
IPv4 can be specified using the string C{"INET"}.
ÚINETN)r+  r   r^   s    r`   Útest_parseIndexStreamServerINETÚ:SystemdEndpointPluginTests.test_parseIndexStreamServerINETl  s   € ð 	×(Ñ(¬°&Õ9rc   c                ó0   • U R                  [        S5        g©z4
IPv6 can be specified using the string C{"INET6"}.
ÚINET6N)r+  r   r^   s    r`   Ú test_parseIndexStreamServerINET6Ú;SystemdEndpointPluginTests.test_parseIndexStreamServerINET6r  s   € ð 	×(Ñ(¬°7Õ;rc   c                ó~   •  SSK Jn  U R                  US5        g! [         a    [        R
                  " S5      ef = f©zC
A UNIX domain socket can be specified using the string C{"UNIX"}.
r   )ÚAF_UNIXrÚ  zPlatform lacks AF_UNIX supportN)Úsocketr<  r+  ÚImportErrorrG   ÚSkipTest©r_   r<  s     r`   Útest_parseIndexStreamServerUNIXÚ:SystemdEndpointPluginTests.test_parseIndexStreamServerUNIXx  sA   € ð	>Ý&ð ×,Ñ,¨W°fÕ=øô ó 	FÜ×#Ò#Ð$DÓEÐEð	Fúó   ‚ ›!<c                ó0   • U R                  [        S5        gr1  )r.  r   r^   s    r`   Útest_parseNameStreamServerINETÚ9SystemdEndpointPluginTests.test_parseNameStreamServerINETƒ  s   € ð 	×'Ñ'¬°Õ8rc   c                ó0   • U R                  [        S5        gr6  )r.  r   r^   s    r`   Útest_parseNameStreamServerINET6Ú:SystemdEndpointPluginTests.test_parseNameStreamServerINET6‰  s   € ð 	×'Ñ'¬°'Õ:rc   c                ó~   •  SSK Jn  U R                  US5        g! [         a    [        R
                  " S5      ef = fr;  )r=  r<  r.  r>  rG   r?  r@  s     r`   Útest_parseNameStreamServerUNIXÚ9SystemdEndpointPluginTests.test_parseNameStreamServerUNIX�  sA   € ð	=Ý&ð ×+Ñ+¨G°VÕ<øô ó 	FÜ×#Ò#Ð$DÓEÐEð	FúrC  c                óÐ   • U R                  5       n[        / S5      Ul        U R                  [        5         UR                  [        SSSS9  SSS5        g! , (       d  f       g= f)zA
The endpoint cannot be defined using both C{index} and C{name}.
rf   r2  r   r#  )r$  r%  r�  N)r  rD   r&  r•  rÅ   r'  r   r  s     r`   Ú"test_indexAndNameMutuallyExclusiveÚ=SystemdEndpointPluginTests.test_indexAndNameMutuallyExclusiveš  sR   € ð ×"Ñ"Ó$ˆÜ$ R¨Ó,ˆÔØ×ÑœzÕ*Ø×$Ñ$¤W°VÀ1È5Ð$ÑQ÷ +×*Ö*ús   ·AÁ
A%rf   N)rì  r
   r(  rš  r—  r™  r›  )ry   rz   r{   r|   r}   r   Ú_SystemdParserr  r  rZ  r+  r.  r3  r8  rA  rE  rH  rK  rN  r~   rf   rc   r`   r  r    s�   † ñð ×+Ñ+€LòEò
ð<Ø*ð<ØADð<à	ô<ð>HØ*ðHØADðHà	ôHô0:ô<ô	>ô9ô;ô	=÷Rrc   r  c                  óB   • \ rS rSrSr\R                  rS rS r	S r
Srg)ÚTCP6ServerEndpointPluginTestsi¤  zO
Unit tests for the TCP IPv6 stream server endpoint string description
parser.
c                ó¼   • [        [        [        R                  5      5      nU H  n[	        X R
                  5      (       d  M    g   U R                  SU< 35        g)zt
L{endpoints._TCP6ServerParser} is found as a plugin for
L{interfaces.IStreamServerEndpointStringParser} interface.
z*Did not find TCP6ServerEndpoint parser in Nr  r  s      r`   r  Ú2TCP6ServerEndpointPluginTests.test_pluginDiscovery¬  óM   € ô
 ”z¤*×"NÑ"NÓOÓPˆÛˆAÜ˜!×.Ñ.×/Ó/Ùñ ð �I‰IÐBÀ7Á+ÐNÕOrc   c                óv   • U R                  5       nU R                  [        [        R                  U5      5        g)zc
L{endpoints._TCP6ServerParser} instances provide
L{interfaces.IStreamServerEndpointStringParser}.
Nr  r  s     r`   rZ  Ú,TCP6ServerEndpointPluginTests.test_interface¸  r  rc   c                ój  • [         R                  " [        5       S5      nU R                  U[         R                  5        U R                  UR
                  [        5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        g)zi
L{serverFromString} returns a L{TCP6ServerEndpoint} instance with a
'tcp6' endpoint string description.
z$tcp6:8080:backlog=12:interface=\:\:1i�  rõ  r!  N)
r   r÷  rV  r‡  r$  r)  r³   rø  rù  rú  r>  s     r`   Útest_stringDescriptionÚ4TCP6ServerEndpointPluginTests.test_stringDescriptionÂ  s„   € ô
 ×'Ò'Ü‹OÐDó
ˆð 	×Ñ˜b¤)×">Ñ">Ô?Ø×Ñ˜bŸk™k¬=Ô9Ø×Ñ˜Ÿ™ 4Ô(Ø×Ñ˜Ÿ™ bÔ)Ø×Ñ˜Ÿ™¨Õ.rc   rf   N)ry   rz   r{   r|   r}   r   Ú_TCP6ServerParserr  r  rZ  rY  r~   rf   rc   r`   rR  rR  ¤  s$   † ñð
 ×.Ñ.€Lò
Pò
õ/rc   rR  c                  óB   • \ rS rSrSr\R                  rS rS r	S r
Srg)ÚStandardIOEndpointPluginTestsiÑ  zE
Unit tests for the Standard I/O endpoint string description parser.
c                ó¼   • [        [        [        R                  5      5      nU H  n[	        X R
                  5      (       d  M    g   U R                  SU< 35        g)zt
L{endpoints._StandardIOParser} is found as a plugin for
L{interfaces.IStreamServerEndpointStringParser} interface.
z*Did not find StandardIOEndpoint parser in Nr  r  s      r`   r  Ú2StandardIOEndpointPluginTests.test_pluginDiscoveryØ  rU  rc   c                óv   • U R                  5       nU R                  [        [        R                  U5      5        g)zc
L{endpoints._StandardIOParser} instances provide
L{interfaces.IStreamServerEndpointStringParser}.
Nr  r  s     r`   rZ  Ú,StandardIOEndpointPluginTests.test_interfaceä  r  rc   c                óÂ   • [         R                  " [        5       S5      nU R                  U[         R                  5        U R                  UR
                  [        5        g)zj
L{serverFromString} returns a L{StandardIOEndpoint} instance with a
'stdio' endpoint string description.
zstdio:N)r   r÷  rV  r‡  rÓ  r)  r>  s     r`   rY  Ú4StandardIOEndpointPluginTests.test_stringDescriptionî  sB   € ô
 ×'Ò'¬«¸ÓBˆØ×Ñ˜b¤)×">Ñ">Ô?Ø×Ñ˜bŸk™k¬=Õ9rc   rf   N)ry   rz   r{   r|   r}   r   Ú_StandardIOParserr  r  rZ  rY  r~   rf   rc   r`   r]  r]  Ñ  s$   † ñð ×.Ñ.€Lò
Pò
õ:rc   r]  c                  ó$   • \ rS rSrSrS rS rSrg)ÚConnectProtocolTestsiø  z
Tests for C{connectProtocol}.
c                óŒ  • [        5       n[        R                  " USS5      n[        5       n[        R                  " X#5        U R                  [        UR                  5      S5        UR                  S   S   R                  nU R                  U[        R                  5        U R                  UR                  S5      U5        g)z€
C{endpoints.connectProtocol} calls the given endpoint's C{connect()}
method with a factory that will build the given protocol.
r  r   rk   r¼   N)rV  r   r  ró   ÚconnectProtocolr³   ri  ræ  Ú_wrappedFactoryr‡  r   r2   rÔ  rª   )r_   r   rÚ  ÚtheProtocolr¶   s        r`   Ú"test_connectProtocolCreatesFactoryÚ7ConnectProtocolTests.test_connectProtocolCreatesFactoryý  s�   € ô
  “/ˆÜ×/Ò/°¸ÀaÓHˆÜ“hˆÜ×!Ò! (Ô8ð 	×Ñœ˜W×/Ñ/Ó0°!Ô4ð ×$Ñ$ QÑ'¨Ñ*×:Ñ:ˆØ×Ñ˜g¤x×'7Ñ'7Ô8Ø�‰�g×+Ñ+¨DÓ1°;Õ?rc   c                ó¶   ^• [         R                  " 5       m " U4S jS5      nU" 5       nU R                  T[        R                  " U[        5       5      5        g)zf
C{endpoints.connectProtocol} returns the result of calling the given
endpoint's C{connect()} method.
c                  ó"   >• \ rS rSrU 4S jrSrg)ÚOConnectProtocolTests.test_connectProtocolReturnsConnectResult.<locals>.Endpointi  c                ó   >• T$ )z2
Return a marker object for use in our assertion.
rf   )r_   r¶   r¡  s     €r`   rg  ÚWConnectProtocolTests.test_connectProtocolReturnsConnectResult.<locals>.Endpoint.connect  s
   ø€ ð �rc   rf   N)ry   rz   r{   r|   rg  r~   )r¡  s   €r`   ÚEndpointro    s   ø† ÷ð rc   rr  N)r   r  rÔ  r   rh  ró   )r_   rr  rÚ  r¡  s      @r`   Ú(test_connectProtocolReturnsConnectResultÚ=ConnectProtocolTests.test_connectProtocolReturnsConnectResult  sA   ø€ ô
 —’Ó!ˆ÷	ô 	ñ “:ˆØ�‰�fœi×7Ò7¸Ä&Ã(ÓKÕLrc   rf   N)ry   rz   r{   r|   r}   rk  rs  r~   rf   rc   r`   rf  rf  ø  s   † ñò@õ$Mrc   rf  c                  ó>   ^ • \ rS rSrSrU 4S jrU 4S jrS rSrU =r	$ )ÚUppercaseWrapperProtocoli!  zD
A wrapper protocol which uppercases all strings passed through it.
c                ó@   >• [         TU ]  UR                  5       5        g)zn
Uppercase a string passed in from the transport.

@param data: The string to uppercase.
@type data: L{bytes}
N)rî  rr   Úupper©r_   r[   rò  s     €r`   rr   Ú%UppercaseWrapperProtocol.dataReceived&  s   ø€ ô 	‰Ñ˜TŸZ™Z›\Õ*rc   c                ó@   >• [         TU ]  UR                  5       5        g)zm
Uppercase a string passed out to the transport.

@param data: The string to uppercase.
@type data: L{bytes}
N)rî  rö  rx  ry  s     €r`   rö  ÚUppercaseWrapperProtocol.write/  s   ø€ ô 	‰‰�d—j‘j“lÕ#rc   c                ó8   • U H  nU R                  U5        M     g)za
Uppercase a series of strings passed out to the transport.

@param seq: An iterable of strings.
Nrõ  )r_   Úseqr[   s      r`   r›  Ú&UppercaseWrapperProtocol.writeSequence8  s   € ó ˆDØ�J‰J�tÖò rc   rf   )
ry   rz   r{   r|   r}   rr   rö  r›  r~   r  r  s   @r`   rv  rv  !  s   ø† ñõ+õ$÷ð rc   rv  c                  ó   • \ rS rSrSr\rSrg)ÚUppercaseWrapperFactoryiB  zC
A wrapper factory which uppercases all strings passed through it.
rf   N)ry   rz   r{   r|   r}   rv  r   r~   rf   rc   r`   r�  r�  B  s   † ñð (ƒHrc   r�  c                  ó$   • \ rS rSrSrS rS rSrg)ÚNetstringTrackeriJ  zz
A netstring receiver which keeps track of the strings received.

@ivar strings: A L{list} of received strings, in order.
c                ó   • / U l         g ro   ©Ústringsr^   s    r`   ra   ÚNetstringTracker.__init__Q  s	   € Øˆ�rc   c                ó:   • U R                   R                  U5        g)zr
Receive a string and append it to C{self.strings}.

@param string: The string to be appended to C{self.strings}.
N)r†  rp   )r_   rÿ   s     r`   ÚstringReceivedÚNetstringTracker.stringReceivedT  s   € ð 	�‰×Ñ˜FÕ#rc   r…  N)ry   rz   r{   r|   r}   ra   r‰  r~   rf   rc   r`   rƒ  rƒ  J  s   † ñòõ$rc   rƒ  c                  ó   • \ rS rSrSrSrg)Ú	FakeErrori]  zu
An error which isn't really an error.

This is raised in the L{wrapClientTLS} tests in place of a
'real' exception.
rf   Nr½  rf   rc   r`   rŒ  rŒ  ]  s   † ôrc   rŒ  c                  ó<   • \ rS rSrSrS rS rS rS rS r	S r
S	rg
)ÚWrapperClientEndpointTestsif  z&
Tests for L{_WrapperClientEndpoint}.
c                óâ   • [        5       u  U l        U l        [        5       U l        [
        R                  " U R                  [        5      U l        [        R                  " [        5      U l        g ro   )rE   rÚ  Ú	completerró   Úcontextr   Ú_WrapperEndpointr�  r  r2   re  rƒ  r¶   r^   s    r`   rÛ  Ú WrapperClientEndpointTests.setUpk  sM   € Ü(;Ó(=Ñ%ˆŒ�t”~Ü“xˆŒÜ ×1Ò1Ø�M‰MÔ2ó
ˆŒô ×*Ò*Ô+;Ó<ˆ�rc   c                óH  • U R                   R                  U R                  5      nU R                  R	                  5       nU R                  U5      nUR                  R                  R                  S5        UR                  5         U R                  UR                  S/5        g)zp
Any modifications performed by the underlying L{ProtocolWrapper}
propagate through to the wrapped L{Protocol}.
s   5:hello,s   HELLON)r  rg  r¶   r�  ÚsucceedOncer×  r“  rô   rö  Úflushr³   r†  ©r_   Ú
connectingÚpumprk  s       r`   Útest_wrappingBehaviorÚ0WrapperClientEndpointTests.test_wrappingBehaviors  su   € ð
 —\‘\×)Ñ)¨$¯,©,Ó7ˆ
Ø�~‰~×)Ñ)Ó+ˆØ×$Ñ$ ZÓ0ˆØ�‰×Ñ×#Ñ# KÔ0Ø�
‰
ŒØ×Ñ˜Ÿ™¨¨
Õ3rc   c                ó  • U R                   R                  U R                  5      nU R                  R	                  5       nU R                  U5      nUR                  S5        U R                  UR                  R                  5       S5        g)zx
Methods defined on the wrapped L{Protocol} are accessible from the
L{Protocol} returned from C{connect}'s L{Deferred}.
s   spams   4:SPAM,N)
r  rg  r¶   r�  r•  r×  Ú
sendStringr³   ÚclientIOÚgetOutBufferr—  s       r`   Útest_methodsAvailableÚ0WrapperClientEndpointTests.test_methodsAvailable  si   € ð
 —\‘\×)Ñ)¨$¯,©,Ó7ˆ
Ø�~‰~×)Ñ)Ó+ˆØ×$Ñ$ ZÓ0ˆØ×Ñ˜Ô!Ø×Ñ˜Ÿ™×3Ñ3Ó5°zÕBrc   c                óâ   • U R                   R                  U R                  5      nU R                  U5        U R                  R                  [        5       5        U R                  U[        5        g)zC
Connection failures propagate upward to C{connect}'s L{Deferred}.
N)r  rg  r¶   ÚassertNoResultr�  ÚfailOncerŒ  rÔ   ©r_   rÐ   s     r`   Útest_connectionFailureÚ1WrapperClientEndpointTests.test_connectionFailureŠ  sN   € ð �L‰L× Ñ  §¡Ó.ˆØ×Ñ˜AÔØ�‰×Ñ¤	£Ô,Ø×Ñ˜Q¤	Õ*rc   c                ó¼   • U R                   R                  U R                  5      nU R                  U5        UR	                  5         U R                  U[        5        g)z=
Cancellation propagates upward to C{connect}'s L{Deferred}.
N)r  rg  r¶   r£  r…  rÔ   r'   r¥  s     r`   Útest_connectionCancellationÚ6WrapperClientEndpointTests.test_connectionCancellation“  sD   € ð �L‰L× Ñ  §¡Ó.ˆØ×Ñ˜AÔØ	�‰Œ
Ø×Ñ˜QÔ 8Õ9rc   c                ó  • U R                   R                  U R                  5      nU R                  R	                  5       nU R                  U5      nU R                  UR                  R                  UR                  5        g)zd
The transport of the wrapped L{Protocol}'s transport is the transport
passed to C{makeConnection}.
N)	r  rg  r¶   r�  r•  r×  rÔ  rô   rž  r—  s       r`   Ú*test_transportOfTransportOfWrappedProtocolÚEWrapperClientEndpointTests.test_transportOfTransportOfWrappedProtocolœ  sZ   € ð
 —\‘\×)Ñ)¨$¯,©,Ó7ˆ
Ø�~‰~×)Ñ)Ó+ˆØ×$Ñ$ ZÓ0ˆØ�‰�e—o‘o×/Ñ/°·±Õ?rc   )r�  r‘  rÚ  r¶   r  N)ry   rz   r{   r|   r}   rÛ  rš  r   r¦  r©  r¬  r~   rf   rc   r`   rŽ  rŽ  f  s'   † ñò=ò
4ò	Cò+ò:õ@rc   rŽ  c                ó8   • UR                  S5      R                  $ )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)rI  ÚtlsEndpoints     r`   ÚconnectionCreatorFromEndpointr²  §  s   € ð( ×&Ñ& tÓ,×?Ñ?Ð?rc   c                  ó>   • \ rS rSrSrS
S jrS
S jrS rS rS r	Sr
g	)ÚWrapClientTLSParserTestsi¾  z(
Tests for L{_TLSClientEndpointParser}.
c                óv  • [        5       n[        R                  " US5      nUR                  nU R	                  UR
                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        g)zU
A L{HostnameEndpoint} is constructed from parameters passed to
L{clientFromString}.
z4tls:example.com:443:timeout=10:bindAddress=127.0.0.1rÛ  rA  rø  ©r  r   N©ró   r   rj  Ú_wrappedEndpointrÔ  r)  r³   r$  rø  rl  rp  ©r_   r   rÚ  ÚhostnameEndpoints       r`   Ú!test_hostnameEndpointConstructionÚ:WrapClientTLSParserTests.test_hostnameEndpointConstructionÄ  s¡   € ô
 “(ˆÜ×-Ò-ØØBó
ˆð $×4Ñ4ÐØ�‰Ð&×/Ñ/°Ô9Ø×ÑÐ)×4Ñ4°nÔEØ×ÑÐ)×/Ñ/°Ô5Ø×ÑÐ)×2Ñ2°BÔ7Ø×ÑÐ)×6Ñ6Ð8HÕIrc   c                óv  • [        5       n[        R                  " US5      nUR                  nU R	                  UR
                  U5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        U R                  UR                  S5        g)zn
A L{HostnameEndpoint} is constructed from parameters passed to
L{clientFromString} with reasonable defaults.
ztls:example.com:443rÛ  rA  r  Nr·  r¹  s       r`   Ú-test_hostnameEndpointConstructionNoParametersÚFWrapClientTLSParserTests.test_hostnameEndpointConstructionNoParametersÕ  s    € ô
 “(ˆÜ×-Ò-ØØ!ó
ˆð $×4Ñ4ÐØ�‰Ð&×/Ñ/°Ô9Ø×ÑÐ)×4Ñ4°nÔEØ×ÑÐ)×/Ñ/°Ô5Ø×ÑÐ)×2Ñ2°BÔ7Ø×ÑÐ)×6Ñ6¸Õ=rc   c                óà   • [        5       n[        R                  " US5      nU R                  UR                  R
                  S5        [        X5      nU R                  UR                  S5        g)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}.
s   tls:Ã©xample.example.com:443s   xn--xample-9ua.example.comu   Ã©xample.example.comN)ró   r   rj  r³   r¸  r$  r²  Ú	_hostname)r_   r   rÚ  ÚconnectionCreators       r`   Útest_utf8EncodingÚ*WrapClientTLSParserTests.test_utf8Encodingæ  sh   € ô “(ˆÜ×-Ò-ØÐ:ó
ˆð 	×ÑØ×%Ñ%×0Ñ0Ð2Oô	
ô :¸'ÓLÐØ×ÑÐ*×4Ñ4Ð6NÕOrc   c                ó‚  ^^^• [        5       n[        R                  " [        US/5      SR	                  [
        [
        [        R                  " [        R                  5       R                  5      5      R                  S5      5      nUR                  [        R                  " [        5      5      nUR                  R!                  5       u  pEpgnU R#                  [%        U5      [&        5        U R)                  US5        UR+                  S5      mU R-                  U5        Tc   e[.        R0                  " [        R3                  5       5      n	[5        U	R6                  R8                  U	R8                  [:        R0                  " [<        R3                  5       5      R8                  /U	S9n
[        5       m[?        U
S[        R                  " U4S j5      S	9R+                  S5      m[A        U4S
 jU4S j5      u  p¼nTRB                  RE                  S5        U RG                  U5      nURB                  RE                  S5        URI                  5         U RK                  TRB                  RL                  5        U RK                  URB                  RL                  5        U RK                  TRB                  RN                  5        U RK                  URB                  RN                  5        [:        RP                  " TRB                  5      nU R)                  U[:        R0                  " [        R3                  5       5      5        g)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  zStls:localhost:4321:privateKey={}:certificate={}:trustRoots={}:bindAddress=127.0.0.1Úasciir¶  N)r—  r˜  r  rÃ  Fc                 ó   >• T $ ro   rf   )ÚplainServers   €r`   rË   Ú3WrapClientTLSParserTests.test_tls.<locals>.<lambda>)  s   ø€ ±{rc   )ÚisClientÚwrappedFactoryc                 ó   >• T $ ro   rf   )ÚserverProtocols   €r`   rË   rÉ  ,  ó   ø€ ‘Nrc   c                 ó   >• T $ ro   rf   )ÚclientProtocols   €r`   rË   rÉ  -  rÎ  rc   s   hello
s   hi you too
))rV  r   rj  ri  r'  r  ré  ÚpemPathrÖ  r  Úencoderg  r2   re  r3   ræ  ÚpoprÔ  r;  rh  r³   rª   r£  rQ   r  r  rN   r—  ÚoriginalrM   Ú	chainPathrS   rF   rô   rö  r×  r–  r  ÚdisconnectingÚdisconnectedÚpeerFromTransport)r_   r   rÚ  rÐ   r�  r�  r¶   rí  rî  Ú
serverCertÚserverOptionsÚsProtoÚcProtor™  ÚplainClientÚpeerCertificaterÐ  rÈ  rÍ  s                   @@@r`   Útest_tlsÚ!WrapClientTLSParserTests.test_tlsö  s€  ú€ ô$  “/ˆô
 ×-Ò-Ü)¨'°K°=ÓAØa×hÑhÜ"Ü"Ü×-Ò-¬g¯n©nÓ.>×.CÑ.CÓDó÷ ‰fØóó	
ˆð ×ÑœW×0Ò0´Ó:Ó;ˆØ4;×4FÑ4F×4JÑ4JÓ4LÑ1ˆ�G kØ�‰”d˜;Ó'¬Ô/Ø×Ñ˜Ð&6Ô7Ø ×.Ñ.¨tÓ4ˆØ×Ñ˜AÔØÑ)Ð)Ð)Ü'×/Ò/´×0BÑ0BÓ0DÓEˆ
Ü*Ø!×,Ñ,×5Ñ5Ø"×+Ñ+Ü'×/Ò/´	×0DÑ0DÓ0FÓG×PÑPÐQØ ñ	
ˆô “jˆÜ,ØØÜ"×.Ò.Ô/BÓCñ
÷ ‰-˜Ó
ð	 	ô
  8Ü"Ü"ó 
Ñˆ˜ð
 	×Ñ×#Ñ# LÔ1Ø×*Ñ*¨1Ó-ˆØ×Ñ×#Ñ#Ð$5Ô6Ø�
‰
ŒØ×Ñ˜×.Ñ.×<Ñ<Ô=Ø×Ñ˜×.Ñ.×<Ñ<Ô=Ø×Ñ˜×.Ñ.×;Ñ;Ô<Ø×Ñ˜×.Ñ.×;Ñ;Ô<Ü%×7Ò7¸×8MÑ8MÓNˆØ×Ñ˜¬+×*=Ò*=¼g×>PÑ>PÓ>RÓ*SÕTrc   c                óà   • [        5       n[        R                  " US5      n[        X5      nU R	                  UR
                  S5        U R	                  UR                  R                  S5        g)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.
s   tls:example.com:443r�  rÛ  N)ró   r   rj  r²  r³   rÁ  r¸  r$  )r_   r   rÚ  Úcreators       r`   Útest_tlsWithDefaultsÚ-WrapClientTLSParserTests.test_tlsWithDefaults;  sZ   € ô “(ˆÜ×-Ò-¨gÐ7MÓNˆÜ/°ÓBˆØ×Ñ˜×*Ñ*¨MÔ:Ø×Ñ˜×2Ñ2×=Ñ=¸~ÕNrc   rf   Nr›  )ry   rz   r{   r|   r}   r»  r¾  rÃ  rß  rã  r~   rf   rc   r`   r´  r´  ¾  s&   † ñôJô">ò"Pò CUõJ
Orc   r´  c                óR  •  U R                   nU R                  nU H"  nXC;  d  M
  [        SR                  U5      5      e   0 nUR                  U5        UR                  U5        [        X%5      nXeU R                  '   U$ ! [         a    U R                  nU R                  n N‹f = f)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'  rW  r   ry   )ÚfunctionÚ
newGlobalsÚ
codeObjectÚfuncGlobalsrº  ÚmergedGlobalsÚnewFunctions          r`   ÚreplacingGlobalsrñ  H  sµ   € ð+Ø×'Ñ'ˆ
Ø×+Ñ+ˆó ˆØÕ!ÜØN×UÑUØóóð ñ ð €MØ×Ñ˜Ô%Ø×Ñ˜Ô$Ü˜zÓ9€KØ'2�(×#Ñ#Ñ$ØÐøô ó +Ø×&Ñ&ˆ
Ø×*Ñ*Šð+ús   ‚B Â"B&Â%B&c                  ó   • \ rS rSrSrS rSrg)ÚWrapClientTLSTestsil  z^
Tests for the error-reporting behavior of L{wrapClientTLS} when
C{pyOpenSSL} is unavailable.
c                óš   • [        [        R                  SS9nU R                  [        USS5      nU R                  S[        U5      5        g)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.
NrR   zOpenSSL not available)rñ  r   ÚwrapClientTLSr•  ÚNotImplementedErrorrÅ  rš  )r_   ÚreplacedÚnotImplementeds      r`   Útest_noOpenSSLÚ!WrapClientTLSTests.test_noOpenSSLr  sC   € ô $¤I×$;Ñ$;ÐQUÑVˆØ×*Ñ*Ô+>ÀÈ$ÐPTÓUˆØ�‰Ð-¬s°>Ó/BÕCrc   rf   N)ry   rz   r{   r|   r}   rù  r~   rf   rc   r`   ró  ró  l  s   † ñõ
Drc   ró  )rf   N)zfakeendpoint.py)×r}   Ú
__future__r   Úabcr   Úerrnor   r=  r   r   r   r	   r
   r   Útypesr   Útypingr   r   Úunicodedatar   rG   r   Úzope.interfacer   r   r   Úzope.interface.interfacer   Úzope.interface.verifyr   r   Útwistedr   r¨  r   r   r   r   r   r   r   r   Útwisted.internet.abstractr    Útwisted.internet.addressr!   r"   r#   r$   r%   Útwisted.internet.endpointsr&   Útwisted.internet.errorr'   Útwisted.internet.interfacesr(   r)   r*   r+   r,   r-   r.   r/   r0   Útwisted.internet.protocolr1   r2   r3   Útwisted.internet.stdior4   Útwisted.internet.taskr5   Útwisted.internet.testingr6   rV  r7   r8   r9   Útwisted.loggerr:   r;   Útwisted.pluginr<   Útwisted.protocolsr=   r>   Útwisted.pythonr?   Útwisted.python.componentsr@   Útwisted.python.failurerA   Útwisted.python.filepathrB   Útwisted.python.modulesrC   Útwisted.python.systemdrD   Útwisted.test.iosimrE   rF   Útwisted.trialr`  ra  rÑ  ÚnoTrailingNewlineKeyPemPathÚnoTrailingNewlineCertPemPathry   r  r  rÕ  ré  r  r  r.  r/  r¼  r  ÚOpenSSL.SSLrI   rJ   r  rK   rL   Útwisted.internet.sslrM   rN   rO   rP   rQ   Útwisted.protocols.tlsrS   Útwisted.test.test_sslverifyrT   r  r  r½  r¿  rQ  rR  r>  rÊ   rš  rW   r!  r€   r  rŽ   r*  r˜   r¢   r¥   ÚTestCaser®   ÚFakeTestBaseró   r>  rž  r¼  rÀ  rÊ  rÑ  rä  ÚIProcessTransportrê  ÚIReactorProcessr  r"  rc  r²  rÜ  r  r+  rL  ri  ÚSynchronousTestCaserk  r�  r¯  r±  rÙ  rè  rò  r  r  r8  rL  rS  rg  rƒ  r¨  rÆ  ró  rI  rf  rš  râ  r  rR  r]  rf  ÚProtocolWrapperrv  ÚWrappingFactoryr�  ÚNetstringReceiverrƒ  rZ  rŒ  rŽ  r²  r´  rñ  ró  rf   rc   r`   Ú<module>r'     s>  ðñõ
 #å Ý ß W× WÝ ß %Ý !Ý ç <Ñ <Ý 3ß ;å ÷	÷ 	ó 	õ 4÷õ õ =Ý ;÷
÷ 
õ 
÷ GÑ FÝ .Ý '÷ó ÷ <Ý %ß -Ý Ý 7Ý *Ý ,Ý ,Ý ,ß LÝ "á
�NÓ
#×
,Ñ
,×
4Ñ
4°\Ó
B€Ù'¨Ó7×@Ñ@×HÑHØ!óÐ ñ  )¨Ó8×AÑA×IÑIØ"ó Ð ñ �HÓ
×
&Ñ
&×
.Ñ
.¨zÓ
:€Ø�M‰M˜+Ó&€	Ø×2Ò2°7·<±<Ó@Ð Ø)2×)FÒ)FØ×$Ñ$ó*Ð &ð +4×*GÒ*GØ ×%Ñ%ó+Ð 'ð ×2Ò2°7·<±<Ó@Ð Ø ×4Ò4°Y·^±^ÓDÐ ð÷ó ÷õ õ :Ý;à!×)Ó)¨'×*<Ò*<Ó*>Ó?€OØ/×7Ó7¸×8JÒ8JÓ8LÓMÐà€GØ€Mô,�8ô ,ñ0 ˆZ×.Ò.Ó/ô ó ó 0ðñ0 ˆZ×/Ò/Ó0ô4¨ó 4ó 1ð4ñ" ˆZ×*Ò*Ó+ô*˜Ló *ó ,ð*ô,�-ô ô�-ô ô@>˜8×,Ò,ô @>öF Ø×$Ò$�Là€LôhA ,ô hA÷VM:ñ M:ô`Ð7Ð9Tô ô%�gô %÷$ñ ô"&<˜x×0Ò0ô &<ôR˜h×/Ñ/ô ñ& ˆZ×)Ò)Ó*ô Ð=ó  ó +ð ñF ˆJ× Ñ Ð"8Ô 9Ù ˆJ×$Ñ$Ð&<Ô =Ù ˆJ×(Ò(Ð*@Ô Añ ˆZ×'Ò'Ó(÷!%ð !%ó )ð!%ôHL˜H×-Ò-ô Lô^I4 H×$5Ò$5ô I4ôXl
˜H×-Ò-ô l
ô^l
Ð.°×0AÒ0Aô l
ô^h
Ð.°×0AÒ0Aô h
ôVq
Ð&AÀ8×CTÒCTô q
ôhOÐ$8¸%ô Oô9!ôxE> (×">Ò">ô E>ôPL°(×2CÒ2Cô L÷:ñ ôLCÐ*Eô LCô^=
Ø'¨×):Ò):ô=
ô@;
Ø'¨×):Ò):ô;
ô|E9Ð$?À×ARÒARô E9ôPs9Ð$?À×ARÒARô s9ôlE; × <Ò <ô E;ôPC
 × <Ò <ô C
ôL/ x×'8Ò'8ô /ô&>¨X×->Ò->ô >ôD 0 x×'8Ò'8ô  0ñF ˆ�ÓôM
Ð.°×0AÒ0Aó M
ó  ðM
ô`n
Ð.°×0AÒ0Aô n
ôb}P�(×#Ò#ô }Pô@^I˜×)Ò)ô ^IôB%ô,g
˜×)Ò)ô g
ñT ˆ�ÓôC0˜8×,Ò,ó C0ó  ðC0ôLmÐ'BÀH×DUÒDUô mô`MR ×!2Ò!2ô MRô`*/ H×$5Ò$5ô */ôZ$: H×$5Ò$5ô $:ôN&M˜8×,Ò,ô &MôR˜x×7Ò7ô ôB(˜h×6Ò6ô (ô$�u×.Ò.ô $ô&�	ô ô>@ ×!2Ò!2ô >@òB@ñ. ˆ�ÓôFO˜x×0Ò0ó FOó  ðFOòR!ôHD˜×*Ò*õ DøðkG ó Ø€GÙ˜“F†Mûðús   È3A.^ Þ^ Þ
^Þ^ 