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


W[ٯ�@s<dZddlmZmZddlZddlZddlmZddlm	Z	m
Z
ddlmZddl
mZddlmZdd	lmZdd
lmZddlmZmZmZmZmZmZddlmZdd
lmZdZ zddlm Z Wne!k
r�YnXe r�e j"s�dZ e dkr�dZ#ndZ#ej$j%Z&Gdd�dej'�Z(Gdd�dej)�Z*Gdd�de+�Z,Gdd�de+�Z-Gdd�de+�Z.Gdd�dej/�Z0Gdd�dej1�Z2Gdd�de2�Z3Gd d!�d!ej1�Z4Gd"d#�d#ej1�Z5Gd$d%�d%ej1�Z6Gd&d'�d'ej1�Z7Gd(d)�d)ej1�Z8Gd*d+�d+ej1�Z9Gd,d-�d-ej1�Z:Gd.d/�d/ej1�Z;Gd0d1�d1ej<�Z=Gd2d3�d3ej>�Z?d4Z@Gd5d6�d6e+�ZAGd7d8�d8ej)�ZBGd9d:�d:eB�ZCGd;d<�d<eC�ZDGd=d>�d>eC�ZEGd?d@�d@eC�ZFe*e*fdAdB�ZGGdCdD�dDej'�ZHGdEdF�dFej)�ZIGdGdH�dHejJ�ZKGdIdJ�dJejJ�ZLGdKdL�dLeM�ZNGdMdN�dN�ZOGdOdP�dPejJ�ZPGdQdR�dRej1�ZQGdSdT�dTejR�ZSGdUdV�dVeS�ZTGdWdX�dXeT�ZUGdYdZ�dZej)�ZVGd[d\�d\ejJ�ZWd]ZXd^ZYGd_d`�d`ejJ�ZZGdadb�dbejJ�Z[Gdcdd�dd�Z\Gdedf�df�Z]Gdgdh�dhe]�Z^Gdidj�dje]�Z_Gdkdl�dle]�Z`Gdmdn�dneB�ZaGdodp�dpejJ�ZbGdqdr�drejJ�ZcGdsdt�dte+�ZdGdudv�dve+�ZeGdwdx�dxej1�ZfGdydz�dzef�ZgGd{d|�d|ef�ZhGd}d~�d~ej)�ZiGdd��d�ej)�ZjGd�d��d�ej)�ZkGd�d��d�ejJ�Zld�d��ZmGd�d��d��Znd�d��Zod�d��Zpe dk	�rep�ZqGd�d��d�enejJ�ZrGd�d��d�eC�ZsGd�d��d�enejJ�ZtGd�d��d�enejJ�ZuGd�d��d�ej/�ZvGd�d��d�ej1�ZwGd�d��d�ej1�ZxGd�d��d�ej)�ZyGd�d��d�ez�Z{Gd�d��d�ew�Z|Gd�d��d�ejJ�Z}Gd�d��d��Z~Gd�d��d�ejJe~�ZGd�d��d�ejJe~�Z�Gd�d��d�ejJe~�Z�Gd�d��d�ejJe~�Z�Gd�d��d�ejJe~�Z�Gd�d��d�ejJ�Z�Gd�d��d�ejJ�Z�Gd�d��d�ejJe~�Z�Gd�d��d�ejJ�Z�eej��Gd�d��d�eM��Z�e	ej�e��e	ej�e��Gd�d��d�ejJ�Z�Gd�d��d�ejJ�Z�Gd�d��d�ejJ�Z�Gd�d��d�ejJ�Z�ej���e��s8d�Z�e�eb_�e�er_�e�et_�e�eu_�dS)�z%
Tests for L{twisted.protocols.amp}.
�)�absolute_import�divisionN)�implementer)�verifyClass�verifyObject)�filepath)�
intToBytes)�Failure)�amp)�unittest)�address�protocol�defer�error�reactor�
interfaces)�iosim)�StringTransport��sslzSSL not availablec@s<eZdZdZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
S)�	TestProtoz�
    A trivial protocol for use in testing where a L{Protocol} is expected.

    @ivar instanceId: the id of this instance
    @ivar onConnLost: deferred that will fired when the connection is lost
    @ivar dataToSend: data to send on the protocol
    rcCs:t|t�stt|���||_||_tj|_tjdt_dS)N�)	�
isinstance�bytes�AssertionError�repr�
onConnLost�
dataToSendr�
instanceCount�
instanceId)�selfrr�r!�7/usr/lib/python3/dist-packages/twisted/test/test_amp.py�__init__:s
zTestProto.__init__cCsg|_|j�|j�dS�N)�data�	transport�writer�r r!r!r"�connectionMadeBszTestProto.connectionMadecCs|j�|�dSr$)r%�append)r rr!r!r"�dataReceivedGszTestProto.dataReceivedcCs|j�|j�dSr$)r�callbackr%�r �reasonr!r!r"�connectionLostKszTestProto.connectionLostcCsd|jfS)z�
        Custom repr for testing to avoid coupling amp tests with repr from
        L{Protocol}

        Returns a string which contains a unique identifier that can be looked
        up using the instanceId property::

            <TestProto #3>
        z<TestProto #%d>)rr(r!r!r"�__repr__Os
zTestProto.__repr__N)
�__name__�
__module__�__qualname__�__doc__rr#r)r+r/r0r!r!r!r"r/src@seZdZdd�Zdd�ZdS)�SimpleSymmetricProtocolcCs|jd|d�S�N�hello��hello)�callRemoteString�r �textr!r!r"�	sendHello_s�z!SimpleSymmetricProtocol.sendHellocCstj|dd�Sr6�r
�Box�r �boxr!r!r"�	amp_HELLOdsz!SimpleSymmetricProtocol.amp_HELLON)r1r2r3r=rBr!r!r!r"r5]sr5c@seZdZdZdS)�UnfriendlyGreeting�&Greeting was insufficiently kind.
    N�r1r2r3r4r!r!r!r"rCisrCc@seZdZdZdS)�DeathThreatrDNrEr!r!r!r"rFmsrFc@seZdZdZdS)�UnknownProtocolz+Asked to switch to the wrong protocol.
    NrEr!r!r!r"rGqsrGc@s$eZdZdd�Zdd�Zdd�ZdS)�
TransportPeercCsdS)N�r!)r �d�name�protor!r!r"�retrieveyszTransportPeer.retrievecCs
|j��Sr$)r&�getPeer)r Z
notAStringrLr!r!r"�fromStringProto|szTransportPeer.fromStringProtocCsdSr$r!)r rK�strings�objectsrLr!r!r"�toBoxszTransportPeer.toBoxN)r1r2r3rMrOrRr!r!r!r"rHvsrHc
@s�eZdZdZde��fdejdd�fdejdd�fdedd�fdejdd�fdejdd�fd	ejdd�fgZ	de��fdejdd�fgZ
ed
iZe
diZdS)
�Hellor7�optionalT��optional�print�from�	mixedCase�dash-arg�underscore_arg�
UNFRIENDLYsDEADN)r1r2r3�commandNamer
�String�Boolean�UnicoderH�	arguments�responserC�errorsrF�fatalErrorsr!r!r!r"rS�s
�
�rSc@seZdZejZdZdS)�
NoAnswerHelloFN)r1r2r3rSr]�requiresAnswerr!r!r!r"re�srec@sxeZdZdZde��fdejdd�fdejdd�fdedd�fdejdd�fgZ	de��fdejdd�fgZ
ediZd	S)
�FutureHellor7rTTrUrWrXsbonusr\N)
r1r2r3r]r
r^r_r`rHrarbrCrcr!r!r!r"rg�s
�

�rgc@seZdZdZdS)�WTFz+
    An example of an invalid command.
    NrEr!r!r!r"rh�srhc@seZdZdZdZdS)�BrokenReturnz\ An example of a perfectly good command, but the handler is going to return
    None...
    s
broken_returnN)r1r2r3r4r]r!r!r!r"ri�sric@s eZdZde��fgZejZdS)�GoodbyesgoodbyeN)r1r2r3r
r^rb�QuitBoxZresponseTyper!r!r!r"rj�srjc@seZdZdZdS)�WaitForeverswait_foreverN)r1r2r3r]r!r!r!r"rl�srlc@s8eZdZdZde��fgZde�de��fg�fgZdS)�GetListsgetlistslength�body�xN)	r1r2r3r]r
�Integerra�AmpListrbr!r!r!r"rm�srmc@sFeZdZdZde��fdejde��fgdd�fgZde��fgZdS)	�DontRejectMesdontrejectmes	magicWordslist�nameTrUsresponseN)	r1r2r3r]r
r`rqrarbr!r!r!r"rr�s

�rrc@seZdZde��fgZdS)�SecuredPingspingedN)r1r2r3r
r_rbr!r!r!r"rt�srtc@s&eZdZdZde��fgZediZdS)�TestSwitchProtosSwitch-ProtorssUNKNOWNN)	r1r2r3r]r
r^rarGrcr!r!r!r"ru�s
�ruc@s(eZdZdd�Zdd�ZdZdd�ZdS)�SingleUseFactorycCs||_||j_dSr$)rL�factory�r rLr!r!r"r#�szSingleUseFactory.__init__cCs|jd}|_|Sr$�rL)r Zaddr�pr!r!r"�
buildProtocol�szSingleUseFactory.buildProtocolNcCs
||_dSr$)�reasonFailed�r Z	connectorr.r!r!r"�clientConnectionFailed�sz'SingleUseFactory.clientConnectionFailed)r1r2r3r#r{r|r~r!r!r!r"rv�srvsgwebol nargoc@seZdZdS)�ThingIDontUnderstandErrorN)r1r2r3r!r!r!r"r�src@s*eZdZdZdd�Zdd�Ze�e�dS)�FactoryNotifierNcCs0|jdk	r,||j_t|jd�r,|jj�d�dS)N�onMade)rw�theProto�hasattrr�r,r(r!r!r"r)�s
zFactoryNotifier.connectionMadecCs(ddlm}|�|j�s td��ddiS)Nr)�
ISSLTransportz+only send secure pings over secure channels�pingedT)Ztwisted.internet.interfacesr��
providedByr&rF)r r�r!r!r"�emitpong�szFactoryNotifier.emitpong)r1r2r3rwr)r�rt�	responderr!r!r!r"r��sr�c@s�eZdZdZddd�Zdd�Zdd�ZdZdd	d
�Ze	�
e�dd�Ze�
e�dd
d�Z
e�
e
�dd�Ze�
e�dd�Ze�
e�ddd�Zdd�Ze�
e�dd�Ze�
e�dS)�SimpleSymmetricCommandProtocolNcCstj�|�||_dSr$)r
�AMPr#r)r rr!r!r"r#sz'SimpleSymmetricCommandProtocol.__init__cCs|jt|d�S)Nr8��
callRemoterSr;r!r!r"r=sz(SimpleSymmetricCommandProtocol.sendHellocCs|jt||d�S)N�r9�Printr�)r r<Ztranslationr!r!r"�sendUnicodeHellosz/SimpleSymmetricCommandProtocol.sendUnicodeHelloFc	Csn||j��kst�|tkr t��|�d�r2td��|dkrBtd��t|d�}|dk	rd|�	t|d��d|_
|S)Nsfuck�Don't be a dick.�dieZaieeeeeeeeer8)r�T)r&rNr�THING_I_DONT_UNDERSTANDr�
startswithrCrF�dict�update�greeted)	r r9�FromrVr��	mixedCase�dash_arg�underscore_arg�resultr!r!r"�cmdHellos

z'SimpleSymmetricCommandProtocol.cmdHellocCsdtdd�g|iS)N�bodyr��x�r�)r �lengthr!r!r"�
cmdGetlistsz)SimpleSymmetricCommandProtocol.cmdGetlistcCs(|dkrd}nd|dd}t|d�S)N�list omittedz%s acceptedrrK)rbr�)r �	magicWord�listrbr!r!r"�okiwont sz&SimpleSymmetricCommandProtocol.okiwontcCst��|_|jSr$)r�Deferred�waitingr(r!r!r"�	waitforit(s
z(SimpleSymmetricCommandProtocol.waitforitcCs
tdd�S)N�everyone)�goodbyer�r(r!r!r"�saybye-sz%SimpleSymmetricCommandProtocol.saybyecs<|r
d}nd}t|jt��|jtt��|d���fdd��S)Nsno-proto�
test-proto)rKcs�Sr$r!��ign�rzr!r"�<lambda>9rIzESimpleSymmetricCommandProtocol.switchToTestProtocol.<locals>.<lambda>)rr�SWITCH_CLIENT_DATAr�rurv�addCallback)r �failrKr!r�r"�switchToTestProtocol1s�
�z3SimpleSymmetricCommandProtocol.switchToTestProtocolcCs |dkrt|jt�St|��dS�Nr�)rr�SWITCH_SERVER_DATArG�r rKr!r!r"�switchit;sz'SimpleSymmetricCommandProtocol.switchitcCsdSr$r!r(r!r!r"�	donothingAsz(SimpleSymmetricCommandProtocol.donothing)N)NNNNN)N)F)r1r2r3�
maybeLaterr#r=r�r�r�rSr�r�rmr�rrr�rlr�rjr�r�rur�rir!r!r!r"r��s0
�









r�c@seZdZdd�Ze�e�dS)� DeferredSymmetricCommandProtocolcCs*|dkr&t|jt�|_t��|_|jSdSr�)rrr��maybeLaterProtorr�r�r�r!r!r"r�Gs
z)DeferredSymmetricCommandProtocol.switchitN)r1r2r3r�rur�r!r!r!r"r�Fsr�c@s eZdZddd�Ze�e�dS)�BadNoAnswerCommandProtocolNcCsdS)zQ
        This responder does nothing and forgets to return a dictionary.
        Nr!�r r9r�rVr�r�r�r�r!r!r"�badResponderOsz'BadNoAnswerCommandProtocol.badResponder)NNNNN)r1r2r3r�rer�r!r!r!r"r�Ns�
r�c@s eZdZddd�Ze�e�dS)�NoAnswerCommandProtocolNcCst|dd�S)Ns	-noanswerr8r�r�r!r!r"�goodNoAnswerResponderWsz-NoAnswerCommandProtocol.goodNoAnswerResponder)NNNNN)r1r2r3r�rer�r!r!r!r"r�Vs�
r�cOstj||f|�|�S)z.Returns a 3-tuple: (client, server, pump)
    )r�connectedServerAndClient)�ServerClass�ClientClass�a�kwr!r!r"r�\s���r�c@seZdZdZdd�ZdS)�TotallyDumbProtocolrIcCs|j|7_dSr$)�buf�r r%r!r!r"r+gsz TotallyDumbProtocol.dataReceivedN)r1r2r3r�r+r!r!r!r"r�esr�c@seZdZdd�Zdd�ZdS)�
LiteralAmpcCs
g|_dSr$)�boxesr(r!r!r"r#kszLiteralAmp.__init__cCs|j�|�dSr$�r�r*r@r!r!r"�ampBoxReceivednszLiteralAmp.ampBoxReceivedN)r1r2r3r#r�r!r!r!r"r�jsr�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�AmpBoxTestszm
    Test a few essential properties of AMP boxes, mostly with respect to
    serialization correctness.
    cCs$tjdd�}|�t|���t�dS)z8
        Make sure that strs serialize to strs.
        svalue��keyN)r
�AmpBox�assertEqual�type�	serializer�r r�r!r!r"�test_serializeStrzszAmpBoxTests.test_serializeStrcCs"tjfddi�}|�t|j�dS)zX
        Verify that TypeError is raised when trying to serialize Unicode keys.
        r��valueN�r
r��assertRaises�	TypeErrorr�r�r!r!r"�test_serializeUnicodeKeyRaises�sz*AmpBoxTests.test_serializeUnicodeKeyRaisescCstjdd�}|�t|j�dS)zb
        Verify that TypeError is raised when trying to serialize Unicode
        values.
        r�r�Nr�r�r!r!r"� test_serializeUnicodeValueRaises�sz,AmpBoxTests.test_serializeUnicodeValueRaisesN)r1r2r3r4r�r�r�r!r!r!r"r�tsr�c@s,eZdZdd�Zdd�Zdd�Zdd�Zd	S)
�ParsingTestscCs�t��}|�|�d��|�|�d��|�t|jd�|�t|jd�|�t|jd�|�|�d�d�|�|�d�d�dS)	ze
        Verify that the Boolean parser parses 'True' and 'False', but nothing
        else.
        sTruesFalsesninjastruesTRUETFN)	r
r_�
assertTrue�
fromString�assertFalser�r�r��toString)r �br!r!r"�test_booleanValues�szParsingTests.test_booleanValuescCsFt�|���}t��}|�|�}|�|�}|�||�|�||�dS)zL
        Verify the 'Path' argument can parse and emit a file path.
        N)	rZFilePathZmktempr
�Pathr�r�ZassertIsNotr�)r �fprz�s�vr!r!r"�test_pathValueRoundTrip�s

z$ParsingTests.test_pathValueRoundTripcCst��}|�tj|jt���S)zk
        Test that empty boxes raise an error; they aren't supposed to be sent
        on purpose.
        )r
r�r�ZNoEmptyBoxesr�r?r�r!r!r"�test_sillyEmptyThing�sz!ParsingTests.test_sillyEmptyThingc
Cs�tttd�\}}}d}d}d}d}d}d}	d}
|g||
g||g||g||||g|||g||||	g|
||gg}|D]>}t��}
|
�t|��|
�|�|��|�|j	d	|
�qpd
S)zq
        Verify that various kinds of data make it through the encode/parse
        round-trip unharmed.
        )r�r�)�simplestest)sceqs: )scrteststest
)slftestshello
)snewlinestest
one
two)snewline2stest
one
 two)rnsblah

testtest���N)
r�r�r
r?r�r��_sendTo�flushr�r�)r �cr�rzZSIMPLEZCEZCRZLF�NEWLINEZNEWLINE2ZBODYTESTZtestData�testZjbr!r!r"�test_ParsingRoundTrip�s2�

�
z"ParsingTests.test_ParsingRoundTripN)r1r2r3r�r�r�r�r!r!r!r"r��s	r�c@s eZdZdZdd�Zdd�ZdS)�FakeLocatorzZ
    This is a fake implementation of the interface implied by
    L{CommandLocator}.
    cCs
i|_dS)zN
        Remember the given keyword arguments as a set of responders.
        N��commandsr(r!r!r"r#�szFakeLocator.__init__cCs
|j|S)zz
        Look up and return a function passed as a keyword argument of the given
        name to the constructor.
        r�)r r]r!r!r"�locateResponder�szFakeLocator.locateResponderN)r1r2r3r4r#r�r!r!r!r"r��sr�c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�
FakeSenderz\
    This is a fake implementation of the 'box sender' interface implied by
    L{AMP}.
    cCsg|_g|_d|_dS)zn
        Create a fake sender and initialize the list of received boxes and
        unhandled errors.
        rN)�	sentBoxes�unhandledErrors�expectedErrorsr(r!r!r"r#�szFakeSender.__init__cCs|jd7_dS)zB
        Expect one error, so that the test doesn't fail.
        rN)r�r(r!r!r"�expectError�szFakeSender.expectErrorcCs|j�|�dS)z6
        Accept a box, but don't do anything.
        N)r�r*r@r!r!r"�sendBoxszFakeSender.sendBoxcCs2|jd8_|jdkr"|��n|j�|�dS)zW
        Deal with failures by instantly re-raising them for easier debugging.
        rrN)r�ZraiseExceptionr�r*)r �failurer!r!r"�unhandledErrors

zFakeSender.unhandledErrorN)r1r2r3r4r#r�r�r�r!r!r!r"r��s

r�c@sPeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)�CommandDispatchTestsa�
    The AMP CommandDispatcher class dispatches converts AMP boxes into commands
    and responses using Command.responder decorator.

    Note: Originally, AMP's factoring was such that many tests for this
    functionality are now implemented as full round-trip tests in L{AMPTests}.
    Future tests should be written at this level instead, to ensure API
    compatibility and to provide more granular, readable units of test
    coverage.
    cCs0t�|_t�|_t�|j�|_|j�|j�dS)z-
        Create a dispatcher to use.
        N)r��locatorr��senderr
�
BoxDispatcher�
dispatcher�startReceivingBoxesr(r!r!r"�setUp$szCommandDispatchTests.setUpcsJg��fdd�}tjdddd�}||jjd<|j�|�|��|g�dS)z�
        L{CommandDispatcher.ampBoxReceived} should locate the appropriate
        command in its responder lookup, based on the '_ask' key.
        cs��|�t�ddi�S)Nr9r�)r*r
r?)rA�Zreceivedr!r"�thunk4s
z4CommandDispatchTests.test_receivedAsk.<locals>.thunkr9�test-command-id�world��_commandZ_askr9N)r
r?rr�rr�r��r r�inputr!rr"�test_receivedAsk.s�z%CommandDispatchTests.test_receivedAskcCsPtd�}|j��|j�t|��|�t|jj�d�|�|jjdj	|�dS)zy
        L{CommandDispatcher} should relay its unhandled errors in responding to
        boxes to its boxSender.
        zsomething went wrong, oh norrN)
�RuntimeErrorrr�rr�r	r��lenr�r�)r �errr!r!r"�test_sendUnhandledError?s

z,CommandDispatchTests.test_sendUnhandledErrorcsttd���fdd�}||jjd<tjdddd�}|j��|j�|�|�	t
|jj�d�|�	|jjd	j��d
S)zp
        Errors during serialization ought to be relayed to the sender's
        unhandledError method.
        zsomething undefined went wrongcsG�fdd�dtj�}|�S)NcseZdZ�fdd�ZdS)zWCommandDispatchTests.test_unhandledSerializationError.<locals>.thunk.<locals>.BrokenBoxcs��dSr$r!rx�rr!r"r�Ssz_CommandDispatchTests.test_unhandledSerializationError.<locals>.thunk.<locals>.BrokenBox._sendToN)r1r2r3r�r!rr!r"�	BrokenBoxRsrr>)r�rrr!r"rQszDCommandDispatchTests.test_unhandledSerializationError.<locals>.thunkr9rr	r
rrN)
rrr�r
r?rr�rr�r�rr�r�rr!rr"� test_unhandledSerializationErrorKs�
z5CommandDispatchTests.test_unhandledSerializationErrorcCs~|jjtdd�}|�|jjtjdddd�g�g}|�|j	�|�|g�|j�
t�dddd���|�|tdd	d
�g�dS)a[
        L{CommandDispatcher.callRemote} should emit a properly formatted '_ask'
        box to its boxSender and record an outstanding L{Deferred}.  When a
        corresponding '_answer' packet is received, the L{Deferred} should be
        fired, and the results translated via the given L{Command}'s response
        de-serialization.
        �worldr8r7�1r
�yay�ignored�r7rWs_answerZignoredr�N)rr�rSr�rr�r
r�r�r*r�r�)r �DZanswersr!r!r"�test_callRemote`s"
���

�z$CommandDispatchTests.test_callRemotecCsLg}|�|j�|�dt|jj��|�|jjdjt�|�dg|�dS)z�
        Verify that C{callResult} completes with a L{None} result and that an
        unhandled error has been logged.
        rrN)	ZaddBothr*r�rrr��assertIsInstancer��ZeroDivisionError)r �
callResultZfinalResultr!r!r"�_localCallbackErrorLoggingTestws�z3CommandDispatchTests._localCallbackErrorLoggingTestcCsP|j��|jjtdd�}|�dd��|j�t�dddd���|�	|�d	S)
z�
        If the last callback on the L{Deferred} returned by C{callRemote} (added
        by application code calling C{callRemote}) fails, the failure is passed
        to the sender's C{unhandledError} method.
        rr8cSsddS�Nrrr!�r�r!r!r"r��rIzVCommandDispatchTests.test_callRemoteSuccessLocalCallbackErrorLogging.<locals>.<lambda>rrrrN)
rr�rr�rSr�r�r
r�r �r rr!r!r"�/test_callRemoteSuccessLocalCallbackErrorLogging�s

�
zDCommandDispatchTests.test_callRemoteSuccessLocalCallbackErrorLoggingcCsP|j��|jjtdd�}|�dd��|j�t�dddd���|�	|�d	S)
z�
        Like L{test_callRemoteSuccessLocalCallbackErrorLogging}, but for the
        case where the L{Deferred} returned by C{callRemote} fails.
        rr8cSsddSr!r!r"r!r!r"r��rIzTCommandDispatchTests.test_callRemoteErrorLocalCallbackErrorLogging.<locals>.<lambda>rsbugssstuff)�_error�_error_code�_error_descriptionN)
rr�rr�rS�
addErrbackr�r
r�r r#r!r!r"�-test_callRemoteErrorLocalCallbackErrorLogging�s

�
zBCommandDispatchTests.test_callRemoteErrorLocalCallbackErrorLoggingN)r1r2r3r4rrrrrr r$r)r!r!r!r"r�s
r�c@s:eZdZdZdZde��fde��fgZde��fgZ	dS)�SimpleGreetingzN
    A very simple greeting command that uses a few basic argument types.
    r�sgreetingscookies
cookieplusN)
r1r2r3r4r]r
r`rprarbr!r!r!r"r*�s

�r*c@s*eZdZdZdd�Zdd�Ze�e�ZdS)�TestLocatorzI
    A locator which implements a responder to the 'simple' command.
    cCs
g|_dSr$)�	greetingsr(r!r!r"r#�szTestLocator.__init__cCs|j�||f�t|dd�S�N��Z
cookieplus�r,r*r��r �greeting�cookier!r!r"�greetingResponder�szTestLocator.greetingResponderN)r1r2r3r4r#r4r*r�r!r!r!r"r+�sr+c@s"eZdZdZdd�Ze�e�ZdS)�OverridingLocatorzJ
    A locator which overrides the responder to the 'simple' command.
    cCs|j�||f�t|dd�S)zV
        Return a different cookieplus than L{TestLocator.greetingResponder}.
        �r/r0r1r!r!r"r4�sz#OverridingLocator.greetingResponderN)r1r2r3r4r4r*r�r!r!r!r"r5�sr5c@seZdZdZdS)�InheritingLocatorzN
    This locator should inherit the responder from L{OverridingLocator}.
    NrEr!r!r!r"r7�sr7cs6eZdZdd�Z�fdd�Zdd�Ze�e�Z�ZS)�OverrideLocatorAMPcCs*tj�|�t�|_d|ji|_g|_dS�Nscustom)r
r�r#�object�customResponder�expectationsr,r(r!r!r"r#�szOverrideLocatorAMP.__init__cs,||jkr|j|}|Stt|��|�SdS)zB
        Override the deprecated lookupFunction function.
        N)r<�superr8�lookupFunction)r rKr���	__class__r!r"r>�s

z!OverrideLocatorAMP.lookupFunctioncCs|j�||f�t|dd�Sr-r0r1r!r!r"r4�sz$OverrideLocatorAMP.greetingResponder)	r1r2r3r#r>r4r*r��
__classcell__r!r!r?r"r8�sr8c@s@eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dS)�CommandLocatorTestsz�
    The CommandLocator should enable users to specify responders to commands as
    functions that take structured objects, annotated with metadata.
    cs:|�}|�d�}|tjddd��}��fdd�}|�|�S)z�
        Check that a locator of type C{locatorClass} finds a responder
        for command named I{simple} and that the found responder answers
        with the C{expected} result to a C{SimpleGreeting<"ni hao", 5>}
        command.
        r��ni hao�5�r2r3cs��|tjt��d��dS)Nr/)r�r
r�r��values��expectedr r!r"�donesz6CommandLocatorTests._checkSimpleGreeting.<locals>.done)r�r
r?r�)r ZlocatorClassrIr�responderCallabler�rJr!rHr"�_checkSimpleGreeting�s

z(CommandLocatorTests._checkSimpleGreetingcCs|�td�S)z�
        A method on a L{CommandLocator} subclass decorated with a L{Command}
        subclass's L{responder} decorator should be returned from
        locateResponder, wrapped in logic to serialize and deserialize its
        arguments.
        �)rLr+r(r!r!r"�test_responderDecorator	sz+CommandLocatorTests.test_responderDecoratorcCs|�td�S)z�
        L{CommandLocator} subclasses can override a responder inherited from
        a base class by using the L{Command.responder} decorator to register
        a new responder method.
        �	)rLr5r(r!r!r"�test_responderOverridingsz,CommandLocatorTests.test_responderOverridingcCs|�td�S)z�
        Responder lookup follows the same rules as normal method lookup
        rules, particularly with respect to inheritance.
        rO)rLr7r(r!r!r"�test_responderInheritancesz-CommandLocatorTests.test_responderInheritancecslt����tdt�fdd��}���j|���tdt�fdd��}|tjddd��}�fdd	�}|�|�S)
a0
        Subclasses which override locateResponder under its old name,
        lookupFunction, should have the override invoked instead.  (This tests
        an AMP subclass, because in the version of the code that could invoke
        this deprecated code path, there was no L{CommandLocator}.)
        z-Override locateResponder, not lookupFunction.cs
��d�Sr9�r�r!�rr!r"r�/rIzKCommandLocatorTests.test_lookupFunctionDeprecatedOverride.<locals>.<lambda>cs
��d�S�Nr�rRr!rSr!r"r�5rIrCrDrEcs��|tjdd��dS�N�8r/�r�r
r�rFr(r!r"rJ7szGCommandLocatorTests.test_lookupFunctionDeprecatedOverride.<locals>.done)	r8�assertWarns�PendingDeprecationWarning�__file__r�r;r
r?r�)r ZcustomResponderObjectZnormalResponderObjectr�rJr!�rr r"�%test_lookupFunctionDeprecatedOverride$s"
�
�z9CommandLocatorTests.test_lookupFunctionDeprecatedOverridecsFt����tdt�fdd��}|tjddd��}�fdd�}|�|�S)	z�
        Invoking locateResponder under its old name, lookupFunction, should
        emit a deprecation warning, but do the same thing.
        z)Call locateResponder, not lookupFunction.cs
��d�SrT)r>r!rSr!r"r�ErIzICommandLocatorTests.test_lookupFunctionDeprecatedInvoke.<locals>.<lambda>rCrDrEcs��|tjdd��dSrUrWrFr(r!r"rJGszECommandLocatorTests.test_lookupFunctionDeprecatedInvoke.<locals>.done)r+rXrYrZr
r?r�)r rKr�rJr!r[r"�#test_lookupFunctionDeprecatedInvoke<s
�z7CommandLocatorTests.test_lookupFunctionDeprecatedInvokeN)
r1r2r3r4rLrNrPrQr\r]r!r!r!r"rB�s
	rBsSuccess!sNo, really.  Success.c@s�eZdZdZdd�Zdd�Zdd�ZdZd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�ZdS)5�BinaryProtocolTestsz�
    Tests for L{amp.BinaryBoxProtocol}.

    @ivar _boxSender: After C{startReceivingBoxes} is called, the L{IBoxSender}
        which was passed to it.
    cCsg|_g|_dS)zz
        Keep track of all boxes received by this test in its capacity as an
        L{IBoxReceiver} implementor.
        N)r�r%r(r!r!r"rYszBinaryProtocolTests.setUpcCs
||_dS)zm
        Implement L{IBoxReceiver.startReceivingBoxes} to just remember the
        value passed in.
        N)�
_boxSender�r rr!r!r"rbsz'BinaryProtocolTests.startReceivingBoxescCs|j�|�dS)z5
        A box was received by the protocol.
        Nr�r@r!r!r"r�jsz"BinaryProtocolTests.ampBoxReceivedNcCs
||_dS)zD
        Record the reason that we stopped receiving boxes.
        N)�
stopReasonr-r!r!r"�stopReceivingBoxesqsz&BinaryProtocolTests.stopReceivingBoxescCsdS)Nzno peerr!r(r!r!r"rNyszBinaryProtocolTests.getPeercCsdS)Nzno hostr!r(r!r!r"�getHost}szBinaryProtocolTests.getHostcCs|�|t�|j�|�dSr$)rrr%r*r�r!r!r"r'�szBinaryProtocolTests.writecCs&t�|�}|�d�|�|j|�dS)z�
        When L{amp.BinaryBoxProtocol} is connected to a transport, it calls
        C{startReceivingBoxes} on its L{IBoxReceiver} with itself as the
        L{IBoxSender} parameter.
        N)r
�BinaryBoxProtocol�makeConnection�assertIsr_�r r
r!r!r"�test_startReceivingBoxes�s

z,BinaryProtocolTests.test_startReceivingBoxescCs>Gdd�d�}t�}t�|��}|�|�|�|��d�dS)z�
        The L{IBoxReceiver} which is started when L{amp.BinaryBoxProtocol} is
        connected to a transport can call C{sendBox} on the L{IBoxSender}
        passed to it before C{startReceivingBoxes} returns and have that box
        sent.
        c@seZdZdd�ZdS)z[BinaryProtocolTests.test_sendBoxInStartReceivingBoxes.<locals>.SynchronouslySendingReceivercSs|�t�ddi��dS)N�foo�bar)r�r
r?r`r!r!r"r�szoBinaryProtocolTests.test_sendBoxInStartReceivingBoxes.<locals>.SynchronouslySendingReceiver.startReceivingBoxesN)r1r2r3rr!r!r!r"�SynchronouslySendingReceiver�srksfoobarN)rr
rdrer�r�)r rkr&r
r!r!r"�!test_sendBoxInStartReceivingBoxes�s
�z5BinaryProtocolTests.test_sendBoxInStartReceivingBoxescCsDt�|�}|�d�|�d�|�d�|�|jtjdd�g�dS)z�
        When a binary box protocol receives:
            * a key
            * a value
            * an empty string
        it should emit a box and send it to its boxReceiver.
        r7rrIr8N)r
rdZstringReceivedr�r�r�r�r!r!r"�test_receiveBoxStateMachine�s




z/BinaryProtocolTests.test_receiveBoxStateMachinecCs4t�}t�|�}|�|�|�d�|�|j�dS)z�
        L{amp.BinaryBoxProtocol} drops its connection if the length prefix for
        the first a key it receives is larger than 255.
        �N)rr
rdrer+r��
disconnecting�r r&r
r!r!r"�$test_firstBoxFirstKeyExcessiveLength�s



z8BinaryProtocolTests.test_firstBoxFirstKeyExcessiveLengthcCsJt�}t�|�}|�|�|�d�|�|j�|�d�|�|j�dS)z�
        L{amp.BinaryBoxProtocol} drops its connection if the length prefix for
        a subsequent key in the first box it receives is larger than 255.
        skvrnN�rr
rdrer+r�ror�rpr!r!r"�)test_firstBoxSubsequentKeyExcessiveLength�s



z=BinaryProtocolTests.test_firstBoxSubsequentKeyExcessiveLengthcCsJt�}t�|�}|�|�|�d�|�|j�|�d�|�|j�dS)z�
        L{amp.BinaryBoxProtocol} drops its connection if the length prefix for
        the first key in a subsequent box it receives is larger than 255.
        skvrnNrrrpr!r!r"�)test_subsequentBoxFirstKeyExcessiveLength�s



z=BinaryProtocolTests.test_subsequentBoxFirstKeyExcessiveLengthcCs�t�|�}|�t��|�d�|�tt�d���|j	�
tj�|�|j	j
j�|�|j	j
j�|�|j	j
j
�|�|j	j
j�dS)z�
        If L{amp.BinaryBoxProtocol} disconnects because it received a key
        length prefix which was too large, the L{IBoxReceiver}'s
        C{stopReceivingBoxes} method is called with a L{TooLong} failure.
        rnzsimulated connection doneN)r
rdrerr+r/r	r�ConnectionDonera�trap�TooLongr�r��isKeyr��isLocal�assertIsNone�keyNamergr!r!r"�test_excessiveKeyFailure�s

�z,BinaryProtocolTests.test_excessiveKeyFailurecCsRt�}t�|�}|�|�|�ttd���|�dt|�	t���|�
|j�dS)z~
        L{amp.BinaryBoxProtocol.unhandledError} logs the failure passed to it
        and disconnects its transport.
        �
Fake errorrN)rr
rdrer�r	rr�r�flushLoggedErrorsr�rorpr!r!r"� test_unhandledErrorWithTransport�s

z4BinaryProtocolTests.test_unhandledErrorWithTransportcCsTt�|�}|�t��|�ttd���|�ttd���|�	dt
|�t���dS)z�
        L{amp.BinaryBoxProtocol.unhandledError} completes without error when
        there is no associated transport.
        Z	Simulatedr}rN)r
rdrerr/r	�	Exceptionr�rr�rr~rgr!r!r"�#test_unhandledErrorWithoutTransport�s

z7BinaryProtocolTests.test_unhandledErrorWithoutTransportcCsDt�|�}|�t�ddd�����|�|jt�ddd��g�dS)z�
        When a binary box protocol receives the serialized form of an AMP box,
        it should emit a similar box to its boxReceiver.
        �	valueTestsanotherValue)�testKeys
anotherKeyN)r
rdr+r?r�r�r�r�r!r!r"�test_receiveBoxDatas

���z'BinaryProtocolTests.test_receiveBoxDatacCshd}d|}t�}t�|�}|�|�|�t�d|i����|�|jt�d|i�g�|�	|j
�dS)z�
        An L{amp.BinaryBoxProtocol} can receive serialized AMP boxes with
        values of up to (2 ** 16 - 1) bytes.
        i��ro�kN)rr
rdrer+r?r�r�r�r�ro)r r�r�r&r
r!r!r"�test_receiveLongerBoxDatas

z-BinaryProtocolTests.test_receiveLongerBoxDatacCsTt�|�}|�|�t�ddd��}|�|�|�|�|�d�|j�|���dS)z�
        When a binary box protocol sends a box, it should emit the serialized
        bytes of that box to its transport.
        r�r7)r�ssomeDatarIN)	r
rdrer?r�r��joinr%r�)r r�ZaBoxr!r!r"�test_sendBox"s

�

z BinaryProtocolTests.test_sendBoxcCs:t�|�}|�|�tt��}|�|�|�|j|�dS)z�
        When a binary box protocol loses its connection, it should notify its
        box receiver that it has stopped receiving boxes.
        N)r
rdrer	rr/rfra)r r��connectionFailurer!r!r"�#test_connectionLostStopSendingBoxes0s




z7BinaryProtocolTests.test_connectionLostStopSendingBoxescs�tdd��|�G���fdd�d�}t�|���t�ddd��}��|�|��d}��|�|��j|�|�	d	�
�j�d�|�	|jdg���d
�|�	d	�
�j�d�|�tj
�j|�dS)z�
        L{BinaryBoxProtocol} has the capacity to switch to a different protocol
        on a box boundary.  When a protocol is in the process of switching, it
        cannot receive traffic.
        N�
outgoing datacs(eZdZdZdd�Z���fdd�ZdS)z@BinaryProtocolTests.test_protocolSwitch.<locals>.SwitchyReceiverFcSsdSr$r!r`r!r!r"rFszTBinaryProtocolTests.test_protocolSwitch.<locals>.SwitchyReceiver.startReceivingBoxescs*��|jd�d|_�������dS)NzShould only receive one box!T)r��switched�_lockForSwitch�	_switchTor@�r��
otherProtor�r!r"r�Hs�zOBinaryProtocolTests.test_protocolSwitch.<locals>.SwitchyReceiver.ampBoxReceivedN)r1r2r3r�rr�r!r�r!r"�SwitchyReceiverDsr�slots�data)sincludesofsHello, world!rIs	more datasHello, world!more data)rr
rdr?rer�r+rfr&r�r�r%r��ProtocolSwitchedr�)r r�Z	anyOldBoxZmoreThanOneBoxr!r�r"�test_protocolSwitch<s$

�


�z'BinaryProtocolTests.test_protocolSwitchcCs:t�|�}|�|�tdd�}|�|�|�|jg�dS)z�
        After switching to a different protocol, if no extra bytes beyond
        the switch box were delivered, an empty string is not passed to the
        switched protocol's C{dataReceived} method.
        NrI)r
rdrerr�r�r%)r r�r�r!r!r"�test_protocolSwitchEmptyBuffer`s




z2BinaryProtocolTests.test_protocolSwitchEmptyBuffercCs�t�|�}|�|�t�ddi�}|��|�tj|j|�|��|�|�|�	d�
|j�|���|��t
dd�}|�|�|�tj|j�dS)a8
        In order to make sure the protocol never gets any invalid data sent
        into the middle of a box, it must be locked for switching before it is
        switched.  It can only be unlocked if the switch failed, and attempting
        to send a box while it is locked should raise an exception.
        ssomer�rINr�)r
rdrer?r�r�r�r�Z_unlockFromSwitchr�r�r%r�rr�)r r�Z	sampleBoxr�r!r!r"� test_protocolSwitchInvalidStatesms




z4BinaryProtocolTests.test_protocolSwitchInvalidStatescCsdGdd�dtj�}|�}t�|�}|�|�|��|�|�tt��}|�	|�|�
|j|�dS)zo
        When the protocol is switched, it should notify its nested protocol of
        disconnection.
        c@seZdZdZdd�ZdS)zDBinaryProtocolTests.test_protocolSwitchLoseConnection.<locals>.LoserNcSs
||_dSr$�r.r-r!r!r"r/�szSBinaryProtocolTests.test_protocolSwitchLoseConnection.<locals>.Loser.connectionLost)r1r2r3r.r/r!r!r!r"�Loser�sr�N)r
�Protocolr
rdrer�r�r	rr/r�r.)r r��connectionLoserr�r�r!r!r"�!test_protocolSwitchLoseConnection�s




z5BinaryProtocolTests.test_protocolSwitchLoseConnectioncCsjGdd�d�}t�|�}t��}|�}|�|�|��|�||�tt��}|�	|�|�
|j|�dS)z~
        When the protocol is switched, it should notify its nested client
        protocol factory of disconnection.
        c@seZdZdZdd�ZdS)zPBinaryProtocolTests.test_protocolSwitchLoseClientConnection.<locals>.ClientLoserNcSs
||_dSr$r�r}r!r!r"�clientConnectionLost�szeBinaryProtocolTests.test_protocolSwitchLoseClientConnection.<locals>.ClientLoser.clientConnectionLost)r1r2r3r.r�r!r!r!r"�ClientLoser�sr�N)r
rdr
r�rer�r�r	rr/r�r.)r r�r�r�ZclientLoserr�r!r!r"�'test_protocolSwitchLoseClientConnection�s



z;BinaryProtocolTests.test_protocolSwitchLoseClientConnection)r1r2r3r4rrr�rarbrNrcr'rhrlrmrqrsrtr|rr�r�r�r�r�r�r�r�r�r�r!r!r!r"r^Qs6	

$
r^c@sFeZdZdd�Zdd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zee_dd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Zd7d8�Z d9d:�Z!e"d;d;fd<d=�Z#d>d?�Z$e"fd@dA�Z%dBdC�Z&dDdE�Z'dFdG�Z(dHdI�Z)dJdK�Z*dLS)M�AMPTestscCsrtjtjftjtjftjtjftjtjftjtjftjtjftjtjffD]"\}}|�	|�
|�d||f�qJdS)z~
        The classes in the amp module ought to implement the interfaces that
        are declared for their benefit.
        z%s does not implements(%s)N)r
Z
IBoxSenderrdZIBoxReceiverrZIResponderLocator�CommandLocatorZSimpleStringLocatorr�r�Z
implementedBy)r Z	interface�implementationr!r!r"�test_interfaceDeclarations�s






�
�z#AMPTests.test_interfaceDeclarationscCsFt�\}}}g}d}|�|��|j�|��|�|dd|�dS)z�
        Verify that a simple command can be sent and its response received with
        the simple low-level string-based API.
        rrr7N�r�r=r�r*r�r��r r�r�rz�L�HELLOr!r!r"�test_helloWorld�szAMPTests.test_helloWorldcCsFt�\}}}g}d}|�|��|j�|��|�|dd|�dS)z}
        Verify that mixed-case, underscored and dashed arguments are mapped to
        their python names properly.
        rrr7Nr�r�r!r!r"�test_wireFormatRoundTrip�sz!AMPTests.test_wireFormatRoundTripcCsftttd�\}}}g}d}d}|�||��|j�|��|�|dd|�|�|dd|�dS)zK
        Verify that unicode arguments can be encoded and decoded.
        �r�r�ruworሴldrr9r�N)r�r�r�r�r*r�r�)r r�r�rzr�r�Z
HELLO_UNICODEr!r!r"�test_helloWorldUnicode�s�zAMPTests.test_helloWorldUnicodecCs(t�\}}}|jddd�}|�|�dS)zm
        L{BoxDispatcher.callRemoteString} returns L{None} if C{requiresAnswer}
        is C{False}.
        �WTFF)rfN)r�r:rz)r r�r�rzZretr!r!r"�(test_callRemoteStringRequiresAnswerFalse�sz1AMPTests.test_callRemoteStringRequiresAnswerFalsecCs~t�\}}}g}dd�}|�d��|��|j�|��|�|��d�d}|�|��|j�|��|�|dd|�dS)	z�
        Verify that unknown commands using low-level APIs will be rejected with an
        error, but will NOT terminate the connection.
        cSs|�tj�dS�z:
            You can't propagate the error...
            �OK�rvr
ZUnhandledCommand��er!r!r"�clearAndAdd�sz4AMPTests.test_unknownCommandLow.<locals>.clearAndAddr�r�rrr7N)	r�r:r(r�r*r�r��popr=�r r�r�rzr�r�r�r!r!r"�test_unknownCommandLow�szAMPTests.test_unknownCommandLowcCs~t�\}}}g}dd�}|�t��|��|j�|��|�|��d�d}|�	|��|j�|��|�|dd|�dS)z�
        Verify that unknown commands using high-level APIs will be rejected with an
        error, but will NOT terminate the connection.
        cSs|�tj�dSr�r�r�r!r!r"r�
sz5AMPTests.test_unknownCommandHigh.<locals>.clearAndAddr�rrr7N)
r�r�rhr(r�r*r�r�r�r=r�r!r!r"�test_unknownCommandHighsz AMPTests.test_unknownCommandHighcCsLg}t��tjtjd���|j�|d�tj	�|�
dt|dj��dS)a
        It can be very confusing if you write some code which responds to a
        command, but gets the return value wrong.  Most commonly you end up
        returning None instead of a dictionary.

        Verify that if that happens, the framework logs a useful error.
        )rr�NoneN)
r�ZdispatchCommandr
r�rir]r(r*rv�BadLocalReturnZfailUnlessInrr�)r r�r!r!r"�test_brokenReturnValues��zAMPTests.test_brokenReturnValuecCsRtttd�\}}}g}d}|jt|dd��|j�|��|�|dd|�dS)z�
        Verify that unknown arguments are ignored, and not passed to a Python
        function which can't accept them.
        r�rsI'm not in the book!)r9Zbonusrr9N)r�r�r�rgr�r*r�r�r�r!r!r"�test_unknownArgument+s���zAMPTests.test_unknownArgumentcCsb|�ttt�d���t�|�ttt����t�|�ttt����t�|�dtt����dS)zS
        Verify that the various Box objects repr properly, for debugging.
        r�r�N)	r�r�rr
Z
_SwitchBox�strrkr��assertInr(r!r!r"�test_simpleReprs>szAMPTests.test_simpleReprscCs:tdd�}t��}||_|�t|�d|jt|�f�dS)zQ
        Verify that L{AMP} objects output their innerProtocol when set.
        Nr�z#<AMP inner <TestProto #%d> at 0x%x>)rr
r�Z
innerProtocolr�rr�id)r r�r�r!r!r"�test_innerProtocolInReprHs
��z!AMPTests.test_innerProtocolInReprcCs&t��}|�t|�dt|�f�dS)zh
        Verify that L{AMP} objects do not output 'inner' when no innerProtocol
        is set.
        z
<AMP at 0x%x>N)r
r�r�rr�r�r!r!r"�test_innerProtocolNotInReprUsz$AMPTests.test_innerProtocolNotInReprcCs|�ttt����t�dS)z;
        L{amp._TLSBox.__repr__} returns a string.
        N)r�r�rr
Z_TLSBoxr�r(r!r!r"�test_simpleSSLRepr^szAMPTests.test_simpleSSLReprcCs�t�\}}}d}|jtj|jdf|di�}|�|j�|�|j�|�|j	�|�
|j|�d��|�
tt|��t|��|�
dt|��dS)zl
        Verify that a key that is too long will immediately raise a synchronous
        exception.
        AHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHsHelloshi�asciir�N)r�r�r
rwr:r�rxryrzr{r�r��encoder�r�rr�r r�r�rzr�Ztlr!r!r"�test_keyTooLonggs��zAMPTests.test_keyTooLongcCs�t�\}}}dd}|�tj|j|�}|��|�|j�|�|j	�|�
|jd�|�|j
|�|�tt|��t|��|�dt|��|�dt|��dS)zs
        Verify that attempting to send value longer than 64k will immediately
        raise an exception.
        �Hir7r�r9N)r�r�r
rwr=r�r�rxr�ryr�r{ZfailUnlessIdenticalr�r�r�rrr�r!r!r"�test_valueTooLongyszAMPTests.test_valueTooLongcCsLtttd�\}}}g}d}|�|��|j�|��|�|dd|�dS)z�
        Verify that a simple command can be sent and its response received with
        the high-level value parsing API.
        r�rrr9N)r�r�r=r�r*r�r�r�r!r!r"�test_helloWorldCommand�s�zAMPTests.test_helloWorldCommandcCs\g}tttd�\}}}d}|�|��|j�|��|d�t�|�t	|dj
�d�dS)z�
        Verify that if a known error type is raised and handled, it will be
        properly relayed to the other end of the connection and translated into
        an exception, and no error will be logged.
        r��fuck yourr�N)r�r�r=r(r*r�rvrCr�r�r��r r�r�r�rzr�r!r!r"�test_helloErrorHandling�s�z AMPTests.test_helloErrorHandlingcCspg}tttd�\}}}d}|�|��|j�|��|���t�|�|��|j�|��|���t	j
�dS)a

        Verify that if a known, fatal error type is raised and handled, it will
        be properly relayed to the other end of the connection and translated
        into an exception, no error will be logged, and the connection will be
        terminated.
        r�r�N)r�r�r=r(r*r�r�rvrFrrur�r!r!r"�test_helloFatalErrorHandling�s�z%AMPTests.test_helloFatalErrorHandlingcCs�g}tttd�\}}}t}|�|��|j�|��|��}|�t	j
�|�|��|j�|��}|�tj�|�
|�t��dS)z�
        Verify that if an unknown error type is raised, it will be relayed to
        the other end of the connection and translated into an exception, it
        will be logged, and then the connection will be dropped.
        r�N)r�r�r�r=r(r*r�r�rvr
ZUnknownRemoteErrorrrur�r~r)r r�r�r�rzr�ZureZclr!r!r"�test_helloNoErrorHandling�s�z"AMPTests.test_helloNoErrorHandlingcCsptttd�\}}}g}|�t��|j�|��|�|g�|j�	�|��|�
��tj
�|j�i�|jS)z�
        Verify that a command that does not get answered until after the
        connection terminates will not cause any errors.
        r�)r�r�r�rlr(r*r�r�r&�loseConnectionr�rvrrur�r,�r r�r�rzr�r!r!r"�test_lateAnswer�s�
zAMPTests.test_lateAnswercCs<tttd�\}}}d}|jt|d�|��|�|j�dS)zG
        Verify that a command that requires no answer is run.
        r�rr8N)r�r�r�rer�r�r�)r r�r�rzr�r!r!r"�test_requiresNoAnswer�s�zAMPTests.test_requiresNoAnswercCs�g}tttd�\}}}d}|jt|d�|��|�|�tj��d}|jt	|d��
|j�|��|���
tj�|�|j�dS)z]
        Verify that commands sent after a failed no-answer request do not complete.
        r�r�r8rN)r�r�r�rer�r�r~r
�RemoteAmpErrorrSr(r*r�rvrrur�r�r�r!r!r"�test_requiresNoAnswerFail�s�z"AMPTests.test_requiresNoAnswerFailcCsHtttd�\}}}|jtdd�|��|�tj�}|�	t
|�d�dS)a+
        Verify that responders of requiresAnswer=False commands have to return
        a dictionary anyway.

        (requiresAnswer is a hint from the _client_ - the server may be called
        upon to answer commands in any case, if the client wants to know when
        they complete.)
        r�r7r8rN)r�r�r�r�rer�r~r
r�r�r)r r�r�rz�ler!r!r"�test_noAnswerResponderBadAnswers	�z(AMPTests.test_noAnswerResponderBadAnswercCs^tttd�\}}}g}|jtdd��|j�|��|�t	|�d�|�|t
ddd�g�dS)z�
        Verify that responders with requiresAnswer=False will actually respond
        if the client sets requiresAnswer=True.  In other words, verify that
        requiresAnswer is a hint honored only by the client.
        r�sHello!r8rsHello!-noanswerNr�)r�r�r�r�rSr�r*r�r�rr�r�r!r!r"�$test_noAnswerResponderAskedForAnswers�
�z-AMPTests.test_noAnswerResponderAskedForAnswercCs\tttd�\}}}g}|jtdd��|j�|��|���d�}|�	|ddigd�dS)zN
        Test encoding of an argument that uses the AmpList encoding.
        r��
)r�r�r�rN)
r�r�r�rmr�r*r�r��getr�)r r�r�rzr�rGr!r!r"�test_ampListCommand/s�zAMPTests.test_ampListCommandcCsRtttd�\}}}g}|jtdd��|j�|��|���d�}|�	|d�dS)z�
        Sending a command with an omitted AmpList argument that is
        designated as optional does not raise an InvalidSignature error.
        r��please)r�rbr�N�
r�r�r�rrr�r*r�r�r�r��r r�r�rzr�rbr!r!r"�test_optionalAmpListOmitted=s�z$AMPTests.test_optionalAmpListOmittedcCsZtttd�\}}}g}|jtdddigd��|j�|��|���d�}|�	|d�dS)	zV
        Sanity check that optional AmpList arguments are processed normally.
        r�r�rK�foo)r�r�rbzfoo acceptedNr�r�r!r!r"�test_optionalAmpListPresentLs���z$AMPTests.test_optionalAmpListPresentcCs|�tjt�dS)z~
        Verify that if we pass an invalid argument list (omitting an argument),
        an exception will be raised.
        N)r�r
�InvalidSignaturerSr(r!r!r"�test_failEarlyOnArgSending[sz#AMPTests.test_failEarlyOnArgSendingcsvt��}t|��t��}t|��t�fdd��fdd�d�\�}}��fdd�}����|�|�����j�dS)z�
        As a debugging aid, a protocol system should raise a
        L{ProtocolSwitched} exception when asked to switch a protocol that is
        already switched.
        cs�Sr$r!r!��serverProtor!r"r�mrIz4AMPTests.test_doubleProtocolSwitch.<locals>.<lambda>cs�Sr$r!r!��clientProtor!r"r�nrIr�cs��tj�j�d�_dS�NT)r�r
r�r��
testSucceededr")r�r r!r"r�osz4AMPTests.test_doubleProtocolSwitch.<locals>.switchedN)	rr�r�r�r�r�r�r�r�)r �serverDeferred�clientDeferredr�rzr�r!)r�r�r r�r"�test_doubleProtocolSwitchcs
�z"AMPTests.test_doubleProtocolSwitchFc
s$d�_t���|���t���|���t�fdd��fdd�d�\}}}|rbg}|�t��|j�|��}|r���	t
j|jd��fdd�����fd	d
�}	|�
|	�|���jdk	rΈj��j�|��|�r|r�|j�t
�dd
��n|j�i�|��|j��|�����j�dS)z�
        Verify that it is possible to switch to another protocol mid-connection and
        send data to it successfully.
        Fcs�Sr$r!r!r�r!r"r��rIz.AMPTests.test_protocolSwitch.<locals>.<lambda>cs�Sr$r!r!r�r!r"r��rIr�rcsR|\\}}\}}��|���|���d�|�t���d�|�t�d�_dS)NrIT)r�r�r�r�r�r�)�infoZ
serverSuccessZ
serverDataZ
clientSuccessZ
clientDatar(r!r"�cbConnsLost�s

z1AMPTests.test_protocolSwitch.<locals>.cbConnsLostcst���g����Sr$)r�DeferredListr�ry)r�r�r�r!r"�cbSwitch�s
��z.AMPTests.test_protocolSwitch.<locals>.cbSwitchNsSPURIOUSz,Here's some traffic in the form of an error.)r�rr�r�r�rlr(r*r�r�r
r�r=r�r�r�r,r�r��errbackr�r&r�r�)
r �switcher�spuriousTraffic�
spuriousErrorr�r�rzZwfdrZswitchDeferredr�r!)r�r�r�r r�r�r"r�ws@
�


�
zAMPTests.test_protocolSwitchcCs|jtd�S)z�
        Verify that protocol-switching even works if the value returned from
        the command that does the switch is deferred.
        )r�)r�r�r(r!r!r"�test_protocolSwitchDeferred�sz$AMPTests.test_protocolSwitchDeferredcs�d|_t��}||��t��}||��t�fdd��fdd�d�\}}}g}|jdd��|j�|��|���	t
�|�|j�|�d��
|j�|��|�|��d	d�d
S)z�
        Verify that if we try to switch protocols and it fails, the connection
        stays up and we can go back to speaking AMP.
        Fcs�Sr$r!r!r�r!r"r��rIz2AMPTests.test_protocolSwitchFail.<locals>.<lambda>cs�Sr$r!r!r�r!r"r��rIr�T)r�rr9N)r�rr�r�r�r(r*r�r�rvrGr�r=r�r�)r r�r�r�r�r�rzr�r!)r�r�r"�test_protocolSwitchFail�s 
�z AMPTests.test_protocolSwitchFailcCs|jdd�S)zs
        Verify that attempts to send traffic after a switch will not corrupt
        the nested protocol.
        T)r��r�r(r!r!r"�test_trafficAfterSwitch�sz AMPTests.test_trafficAfterSwitchcCs|jddd�S)zh
        Returning an error after a protocol switch should record the underlying
        error.
        T)r�r�r�r(r!r!r"�test_errorAfterSwitch�s�zAMPTests.test_errorAfterSwitchcCs�tttd�\}}}g}d}d}|�|��|j�|��|�|��d|�|�t	��|j�|��|�|��d|�|�|��
|j�|���tj
�dS)zt
        Verify that commands with a responseType of QuitBox will in fact
        terminate the connection.
        r�rr�r9r�N)r�r�r=r�r*r�r�r�r�rjr(rvrru)r r�r�rzr�r�ZGOODBYEr!r!r"�test_quitBoxQuits�s�zAMPTests.test_quitBoxQuitscCs�t�\}}}g}|j|_|jtddddd�|��|�t|�d�dtjfdd	d
dfD]\}}|�|d�	|�|�qX|d�	d
�|�|di�dS)z�
        Verify that the command dictionaries for a callRemoteN look correct
        after being serialized and parsed.
        �
hello test�mixed case arg testro�y�r9r�r�r�r�_command)r7r�)rYr�)rZro)r[r�r��_askN)
r�r*r�r�rSr�r�rr]r�)r r�r�rzr�r�r�r!r!r"�test_basicLiteralEmit�s$
��zAMPTests.test_basicLiteralEmitc
s�g�G�fdd�dtj�}t|d�\}}}|jtddddd���j�|��|�t	��d	�|��d
dt
dddd|j��ddd
�f�|��dt
ddd��dS)z�
        Verify that a call similar to basicLiteralEmit's is handled properly with
        high-level quoting and passing to Python methods, and that argument
        names are correctly handled.
        cs"eZdZ�fdd�Ze�e�dS)z:AMPTests.test_basicStructuredEmit.<locals>.StructuredHellocs��||f�tdd�S)N�aaar8)r*r�)r r�r��r�r!r"�hsz<AMPTests.test_basicStructuredEmit.<locals>.StructuredHello.hN)r1r2r3rrSr�r!rr!r"�StructuredHellosr)r�r�r�ror�r��rr!N)r9r�r�r�r�r�rVrr)r�r9)
r
r�r�r�rSr�r*r�r�rr�r&rN)r rr�r�rzr!rr"�test_basicStructuredEmits.
��
��z!AMPTests.test_basicStructuredEmitN)+r1r2r3r�r�r�r�r�r�r�r�r�r�r�r�r��skipSSL�skipr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr!r!r!r"r��sR




	
�
7	r�c@seZdZdd�ZdS)�!PretendRemoteCertificateAuthoritycCsdSr�r!r(r!r!r"�checkIsPretendRemote.sz6PretendRemoteCertificateAuthority.checkIsPretendRemoteN)r1r2r3r	r!r!r!r"r-src@s eZdZdZdd�Zdd�ZdS)�	IOSimCertrcGs|Sr$r!)r r�r!r!r"�options4szIOSimCert.optionscCs||kst�|jd7_dS)a
        This isn't a real certificate, and wouldn't work on a real socket, but
        iosim specifies a different API so that we don't have to do any crypto
        math to demonstrate that the right functions get called in the right
        places.
        rT)r�verifyCount�r Z	otherCertr!r!r"�iosimVerify7szIOSimCert.iosimVerifyN)r1r2r3rrrr!r!r!r"r
1sr
c@seZdZdd�ZdS)�OKCertcCs|��st�|Sr$)r	r�r r�r!r!r"rCszOKCert.optionsN)r1r2r3rr!r!r!r"rBsrc@seZdZdd�ZdS)�
GrumpyCertcCs|jd7_dS)NrF)rr
r!r!r"rHszGrumpyCert.iosimVerifyN)r1r2r3rr!r!r!r"rGsrc@seZdZdd�Zdd�ZdS)�
DroppyCertcCs
||_dSr$)�toDrop)r rr!r!r"r#MszDroppyCert.__init__cCs|jd7_|j��dS)NrT)rrr�r
r!r!r"rPs
zDroppyCert.iosimVerifyN)r1r2r3r#rr!r!r!r"rLsrc@s,eZdZdZdd�Zdd�Zej�e�dS)�SecurableProtoNcCst�gSr$)rr(r!r!r"�
verifyFactoryYszSecurableProto.verifyFactorycCs|��}|��}t||d�S)N��tls_localCertificate�tls_verifyAuthorities)�certFactoryrr�)r �certZverifyr!r!r"�
getTLSVars\s�zSecurableProto.getTLSVars)	r1r2r3rwrrr
�StartTLSr�r!r!r!r"rUsrc@s0eZdZdd�Zdd�Zdd�Zdd�ZeZd	S)
�TLSTestscs�tttd�\}}}t���fdd�|_|jtj�t�gd�g}|�t��	|j
�|��|��j
d�g}|�t��	|j
�|��|�|dddi�d	S)
z�
        Verify that starting TLS and succeeding at handshaking sends all the
        notifications to all the right places.
        r�cs�Sr$r!r!�Zokcr!r"r�qrIz+TLSTests.test_startingTLS.<locals>.<lambda>rrrr�TN)r�rrrr�r
rrrtr�r*r�r�r)r �cli�svrrzr�r!rr"�test_startingTLSgs&��zTLSTests.test_startingTLScsltttd�\}}}t���fdd�|_|jtj�t�gd�|��d|_	|j
tj|jtj�t�gd�dS)zz
        Verify that the protocol will complain if we attempt to renegotiate TLS,
        which we don't support.
        r�cs�Sr$r!r!rr!r"r��rIz1TLSTests.test_startTooManyTimes.<locals>.<lambda>rTN)r�rrrr�r
rrr�ZnoPeerCertificater�Z
OnlyOneTLS�r rr rzr!rr"�test_startTooManyTimes�s&���zTLSTests.test_startTooManyTimescspt��tttd�\}}}�fdd�|_|jtj�d�|��|��j	d�|�t
�}|��|�|tj
�dS)z�
        Verify that starting TLS and failing on both sides at handshaking sends
        notifications to all the right places and terminates the connection.
        r�cs�Sr$r!r!�ZbadCertr!r"r��rIz1TLSTests.test_negotiationFailed.<locals>.<lambda>�rrN)rr�rrr�r
rr�r�rrt�
assertFailurerZNativeOpenSSLError�r rr rzrJr!r$r"�test_negotiationFailed�s��
zTLSTests.test_negotiationFailedcsttttd�\}}}t|j���fdd�|_|jtj�d�|��|�	�j
d�|�t�}|��|�|t
j�dS)z�
        Verify that starting TLS and failing by way of a lost connection
        notices that it is probably an SSL problem.
        r�cs�Sr$r!r!�Z
droppyCertr!r"r��rIz:TLSTests.test_negotiationFailedByClosing.<locals>.<lambda>r%rN)r�rrr&rr�r
rr�r�rrtr&rZPeerVerifyErrorr'r!r)r"�test_negotiationFailedByClosing�s�

z(TLSTests.test_negotiationFailedByClosingN)	r1r2r3r!r#r(r*rrr!r!r!r"rfs
rc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�TLSNotAvailableTestszP
    Tests what happened when ssl is not available in current installation.
    cCstj|_dt_dS)z%
        Disable ssl in amp.
        N)r
rr(r!r!r"r�szTLSNotAvailableTests.setUpcCs|jt_dS)z%
        Restore ssl module.
        N)rr
r(r!r!r"�tearDown�szTLSNotAvailableTests.tearDowncsDtttd�\}}}t���fdd�|_|�|jtj�t�gd�t	�S)zg
        Check that callRemote raises an exception when called with a
        L{amp.StartTLS}.
        r�cs�Sr$r!r!rr!r"r��rIz;TLSNotAvailableTests.test_callRemoteError.<locals>.<lambda>r)
r�rrrr&r�r
rrrr"r!rr"�test_callRemoteError�s���z)TLSNotAvailableTests.test_callRemoteErrorcsnt�}t���fdd�|_t��}d|d<d|d<g}|j|_|�t��|�	|�|�
|dddd	�g�d
S)z|
        When a client with SSL enabled talks to a server without SSL, it
        should return a meaningful error.
        cs�Sr$r!r!rr!r"r��rIz@TLSNotAvailableTests.test_messageReceivedError.<locals>.<lambda>sStartTLSr�rr�s	TLS_ERRORsTLS not available)r&r%r'N)rrrr
r?r*r�rerr�r�)r r rAr�r!rr"�test_messageReceivedError�s 
��z.TLSNotAvailableTests.test_messageReceivedErrorN)r1r2r3r4rr,r-r.r!r!r!r"r+�s
r+c@seZdZdZdS)�InheritedErrorz2
    This error is used to check inheritance.
    NrEr!r!r!r"r/
sr/c@seZdZdZdS)�OtherInheritedErrorz<
    This is a distinct error for checking inheritance.
    NrEr!r!r!r"r0sr0c@seZdZdZediZdS)�BaseCommandz:
    This provides a command that will be subclassed.
    sINHERITED_ERRORN)r1r2r3r4r/rcr!r!r!r"r1sr1c@seZdZdZdS)�InheritedCommandz`
    This is a command which subclasses another command but does not override
    anything.
    NrEr!r!r!r"r2#sr2c@s&eZdZdZde��fgZediZdS)�AddErrorsCommandz]
    This is a command which subclasses another command but adds errors to the
    list.
    sothersOTHER_INHERITED_ERRORN)	r1r2r3r4r
r_rar0rcr!r!r!r"r3+sr3c@s"eZdZdZdd�Ze�e�dS)�NormalCommandProtocolz�
    This is a protocol which responds to L{BaseCommand}, and is used to test
    that inheritance does not interfere with the normal handling of errors.
    cCs
t��dSr$�r/r(r!r!r"�resp:szNormalCommandProtocol.respN)r1r2r3r4r6r1r�r!r!r!r"r45sr4c@s"eZdZdZdd�Ze�e�dS)�InheritedCommandProtocolz�
    This is a protocol which responds to L{InheritedCommand}, and is used to
    test that inherited commands inherit their bases' errors if they do not
    respond to any of their own.
    cCs
t��dSr$r5r(r!r!r"r6FszInheritedCommandProtocol.respN)r1r2r3r4r6r2r�r!r!r!r"r7@sr7c@s"eZdZdZdd�Ze�e�dS)�AddedCommandProtocolz�
    This is a protocol which responds to L{AddErrorsCommand}, and is used to
    test that inherited commands can add their own new types of errors, but
    still respond in the same way to their parents types of errors.
    cCs|rt��nt��dSr$)r0r/)r �otherr!r!r"r6RszAddedCommandProtocol.respN)r1r2r3r4r6r3r�r!r!r!r"r8Lsr8c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�CommandInheritanceTestszM
    These tests verify that commands inherit error conditions properly.
    c
Ks8t||d�\}}}|j|f|�}|�||�}	|��|	S)z~
        Check that the appropriate kind of error is raised when a given command
        is sent to a given protocol.
        r�)r�r�ZfailUnlessFailurer�)
r rrL�cmdr�r�r�rzrJZd2r!r!r"�
errorCheck`s�z"CommandInheritanceTests.errorCheckcCs|�ttt�S)zx
        Verify that errors specified in a superclass are respected normally
        even if it has subclasses.
        )r<r/r4r1r(r!r!r"�test_basicErrorPropagationms
�z2CommandInheritanceTests.test_basicErrorPropagationcCs|�ttt�S)zp
        Verify that errors specified in a superclass command are propagated to
        its subclasses.
        )r<r/r7r2r(r!r!r"�test_inheritedErrorPropagationvs
�z6CommandInheritanceTests.test_inheritedErrorPropagationcCs|jtttdd�S)z�
        Verify that new errors specified in a subclass of an existing command
        are honored even if the superclass defines some errors.
        T�r9)r<r0r8r3r(r!r!r"�test_inheritedErrorAdditions�z3CommandInheritanceTests.test_inheritedErrorAdditioncCs|jtttdd�S)z�
        Verify that errors specified in a command's superclass are respected
        even if that command defines new errors itself.
        Fr?)r<r/r8r3r(r!r!r"�test_additionWithOriginalError�s�z6CommandInheritanceTests.test_additionWithOriginalErrorN)	r1r2r3r4r<r=r>r@rAr!r!r!r"r:[s
			r:cCs"|�tjtj�|`|�|�dSr$)rvr�ConnectionLostrur/)rrLr!r!r"�_loseAndPass�srCc@s eZdZdZdd�Zdd�ZdS)�LiveFireBasez4
    Utility for connected reactor-using tests.
    cs�ddlm}t���_�j�j_t���_�j�j_t	�
��j_t	�
��j_|�d�j��_
���j
j�|�d�j
��j�j��_���jj��fdd�}t	��jj�jjg�}|�|�S)zB
        Create an amp server and connect a client to it.
        r)rz	127.0.0.1cs�jj�_�jj�_dSr$)�
clientFactoryr�r�
serverFactoryr )Zrlstr(r!r"�	getProtos�s
z%LiveFireBase.setUp.<locals>.getProtos)�twisted.internetrr
Z
ServerFactoryrFr��
ClientFactoryrEr�rr�r�Z	listenTCPZ
serverPortZ
addCleanupZ
stopListeningZ
connectTCPrcZportZ
clientConnZ
disconnectr�r�)r rrGZdlr!r(r"r�s(




�
�zLiveFireBase.setUpcCs`g}|j|jfD]:}|jdk	rt���t|�}|j|_|j�	�|�
|�qt�|��dd��S)zn
        Cleanup client and server connections, and check the error got at
        C{connectionLost}.
        NcSs|jjSr$)r�Z
subFailure)�firstr!r!r"r��rIz'LiveFireBase.tearDown.<locals>.<lambda>)rr r&rr�r(rCr�r/r�r*Z
gatherResults)r r�ZconnrJr!r!r"r,�s


�zLiveFireBase.tearDownN)r1r2r3r4rr,r!r!r!r"rD�srDcCs&ddl}|j�|d�|j��dS)Nr�
)�sys�stdoutr'r�)r�rLr!r!r"�show�srNcCsNddlm}|jdd�}|j��}|�|�}|�||dd�d�}|�|�}|S)NrrZshared)ZCNcSsdSr�r!)Zdnr!r!r"r��rIz tempSelfSigned.<locals>.<lambda>i��)rHrZDNZKeyPairZgenerateZcertificateRequestZsignCertificateRequestZnewCertificate)rZsharedDNr�ZcrZsscrdrr!r!r"�tempSelfSigned�s

�
rOc@s eZdZeZeZdd�ZeZdS)�LiveFireTLSTestscsNt��fdd��j_�fdd��j_��fdd�}�jjtj��gd��|�S)aH
        Using real, live TLS, actually negotiate a connection.

        This also looks at the 'peerCertificate' attribute's correctness, since
        that's actually loaded using OpenSSL calls, but the main purpose is to
        make sure that we didn't miss anything obvious in iosim about TLS
        negotiations.
        cs�gSr$r!r!�rr!r"r��rIz9LiveFireTLSTests.test_liveFireCustomTLS.<locals>.<lambda>cs�Sr$r!r!rQr!r"r��rIcs(������fdd�}�j�t��|�S)NcsT����jj�������jj�������jj�������jj���dSr$)r�rZhostCertificate�digestZpeerCertificater )Zrslt2rr!r"r��szHLiveFireTLSTests.test_liveFireCustomTLS.<locals>.secured.<locals>.pinged)rRrr�rtr�)Zrsltr��rr r�r"�secured�s	z8LiveFireTLSTests.test_liveFireCustomTLS.<locals>.securedr)	�tempcertr rrrr�r
rr��r rTr!rSr"�test_liveFireCustomTLS�s

��z'LiveFireTLSTests.test_liveFireCustomTLSN)	r1r2r3rr�r�rWrrr!r!r!r"rP�s rPc@s$eZdZdZdd�Zej�e�dS)�SlightlySmartTLSz_
    Specific implementation of server side protocol with different
    management of TLS.
    cCs
ttd�S)zS
        @return: the global C{tempcert} certificate as local certificate.
        r%)r�rUr(r!r!r"r	szSlightlySmartTLS.getTLSVarsN)r1r2r3r4rr
rr�r!r!r!r"rX	srXc@s eZdZeZeZdd�ZeZdS)�PlainVanillaLiveFireTestscs �fdd�}�j�tj��|�S)z�
        Verify that out of the box, we can start TLS to at least encrypt the
        connection, even if we don't have any certificates to use.
        cs�j�t�Sr$�rr�rtr"r(r!r"rT	szBPlainVanillaLiveFireTests.test_liveFireDefaultTLS.<locals>.secured)rr�r
rr�rVr!r(r"�test_liveFireDefaultTLS	sz1PlainVanillaLiveFireTests.test_liveFireDefaultTLSN)	r1r2r3r�r�r�r[rrr!r!r!r"rY	s	rYc@s eZdZeZeZdd�ZeZ	dS)�WithServerTLSVerificationTestscs&�fdd�}�jjtjtgd��|�S)zO
        Verify that anonymous clients can verify server certificates.
        cs�j�t�Sr$rZr"r(r!r"rT)	szMWithServerTLSVerificationTests.test_anonymousVerifyingClient.<locals>.secured)r)rr�r
rrUr�rVr!r(r"�test_anonymousVerifyingClient%	s
��z<WithServerTLSVerificationTests.test_anonymousVerifyingClientN)
r1r2r3r�r�rXr�r]rrr!r!r!r"r\!	s
r\c@s eZdZdZdd�Zdd�ZdS)�ProtocolIncludingArgumentz�
    An L{amp.Argument} which encodes its parser and serializer
    arguments *including the protocol* into its parsed and serialized
    forms.
    cCs||fS)z�
        Don't decode anything; just return all possible information.

        @return: A two-tuple of the input string and the protocol.
        r!)r �stringr
r!r!r"rO:	sz)ProtocolIncludingArgument.fromStringProtocCsdt|�t|�f}|�d�S)z�
        Encode identifying information about L{object} and protocol
        into a string for later verification.

        @type obj: L{object}
        @type protocol: L{amp.AMP}
        �%d:%dr�)r�r�)r �objr
�identr!r!r"�
toStringProtoB	sz'ProtocolIncludingArgument.toStringProtoN)r1r2r3r4rOrcr!r!r!r"r^3	sr^c@s(eZdZdZde�fgZde�fgZdS)�ProtocolIncludingCommandzf
    A command that has argument and response schemas which use
    L{ProtocolIncludingArgument}.
    �weirdN)r1r2r3r4r^rarbr!r!r!r"rdO	srdc@s@eZdZdZdd�Zee�Zdd�Zee�Zdd�Zee�ZdS)	�MagicSchemaCommandza
    A command which overrides L{parseResponse}, L{parseArguments}, and
    L{makeResponse}.
    cCs||f|_|S)z�
        Don't do any parsing, just jam the input strings and protocol
        onto the C{protocol.parseResponseArguments} attribute as a
        two-tuple. Return the original strings.
        )�parseResponseArguments)r rPr
r!r!r"�
parseResponse^	s
z MagicSchemaCommand.parseResponsecCs||f|_|S)z�
        Don't do any parsing, just jam the input strings and protocol
        onto the C{protocol.parseArgumentsArguments} attribute as a
        two-tuple. Return the original strings.
        )�parseArgumentsArguments)�clsrPr
r!r!r"�parseArgumentsi	s
z!MagicSchemaCommand.parseArgumentscCs||f|_|S)z�
        Don't do any serializing, just jam the input strings and protocol
        onto the C{protocol.makeArgumentsArguments} attribute as a
        two-tuple. Return the original strings.
        )�makeArgumentsArguments)rjrQr
r!r!r"�
makeArgumentst	s
z MagicSchemaCommand.makeArgumentsN)r1r2r3r4rh�classmethodrkrmr!r!r!r"rfY	srfc@s&eZdZdZdd�Ze�dd��dS)�NoNetworkProtocola�
    An L{amp.AMP} subclass which overrides private methods to avoid
    testing the network. It also provides a responder for
    L{MagicSchemaCommand} that does nothing, so that tests can test
    aspects of the interaction of L{amp.Command}s and L{amp.AMP}.

    @ivar parseArgumentsArguments: Arguments that have been passed to any
    L{MagicSchemaCommand}, if L{MagicSchemaCommand} has been handled by
    this protocol.

    @ivar parseResponseArguments: Responses that have been returned from a
    L{MagicSchemaCommand}, if L{MagicSchemaCommand} has been handled by
    this protocol.

    @ivar makeArgumentsArguments: Arguments that have been serialized by any
    L{MagicSchemaCommand}, if L{MagicSchemaCommand} has been handled by
    this protocol.
    cCs
t�|�S)zJ
        Return a Deferred which fires with the original strings.
        )rZsucceed)r r]rPrfr!r!r"�_sendBoxCommand�	sz!NoNetworkProtocol._sendBoxCommandcCsiSr$r!)r��weirdr!r!r"r��	rIzNoNetworkProtocol.<lambda>N)r1r2r3r4rprfr�r!r!r!r"ro�	sroc@seZdZdZdS)�MyBoxz!
    A unique dict subclass.
    NrEr!r!r!r"rr�	srrc@seZdZdZeZdS)�0ProtocolIncludingCommandWithDifferentCommandTypezN
    A L{ProtocolIncludingCommand} subclass whose commandType is L{MyBox}
    N)r1r2r3r4rrZcommandTyper!r!r!r"rs�	srsc@s�eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&S)'�CommandTestsz7
    Tests for L{amp.Argument} and L{amp.Command}.
    cCs|�ttjt����dS)zE
        L{Argument} instances provide L{amp.IArgumentType}.
        N)r�rr
Z
IArgumentType�Argumentr(r!r!r"�test_argumentInterface�	sz#CommandTests.test_argumentInterfacecCs2t�}d}d|i}|�t�||�d||fi�dS)z�
        There should be a class method of Command which accepts a
        mapping of argument names to serialized forms and returns a
        similar mapping whose values have been parsed via the
        Command's response schema.
        �whateverrerqN)r:r�rdrh�r r
r�rPr!r!r"�test_parseResponse�	s

�zCommandTests.test_parseResponsecs6t��d��jt�d�}���fdd�}|�|�|S)z�
        Making a remote call on a L{amp.Command} subclass which
        overrides the C{parseResponse} method should call that
        C{parseResponse} method to get the response.
        sweeoo�rqcs���jd�i�f�dS�Nrq)r�rgr���clientr Zthingyr!r"�gotResponse�	s
�zCCommandTests.test_callRemoteCallsParseResponse.<locals>.gotResponse)ror�rfr��r rbr~r!r|r"�!test_callRemoteCallsParseResponse�	s
z.CommandTests.test_callRemoteCallsParseResponsecCs2t�}d}d|i}|�t�||�d||fi�dS)z�
        There should be a class method of L{amp.Command} which accepts
        a mapping of argument names to serialized forms and returns a
        similar mapping whose values have been parsed via the
        command's argument schema.
        rwrerqN)r:r�rdrkrxr!r!r"�test_parseArguments�	s

�z CommandTests.test_parseArgumentscs@t����tj�}t��|t�d��}|����fdd��|S)z�
        Making a remote call on a L{amp.Command} subclass which
        overrides the C{parseArguments} method should call that
        C{parseArguments} method to get the arguments.
        rzcs���jd�i�f�Sr{)r�rir���argumentr
r r!r"r��	s
�z@CommandTests.test_responderCallsParseArguments.<locals>.<lambda>)ror�rfr]r:r�r�)r r�rbr!r�r"�!test_responderCallsParseArguments�	s�z.CommandTests.test_responderCallsParseArgumentscCsJt�}t�}d|i}dt|�t|�f}|�t�||�d|�d�i�dS)z�
        There should be a class method of L{amp.Command} which accepts
        a mapping of argument names to objects and returns a similar
        mapping whose values have been serialized via the command's
        argument schema.
        rqr`rer�N)r:r�r�rdrmr�)r r
r�rQrbr!r!r"�test_makeArguments�	s
�zCommandTests.test_makeArgumentscCs.t�}ddi}t�||�}|�t|�t�dS)z�
        L{amp.Command.makeArguments}'s return type should be the type
        of the result of L{amp.Command.commandType}.
        rqrwN)r:rsrmrfr�rr)r r
rQr�r!r!r"�!test_makeArgumentsUsesCommandType
s�z.CommandTests.test_makeArgumentsUsesCommandTypecs8t��t���jt�d�}���fdd�}|�|�|S)z�
        Making a remote call on a L{amp.Command} subclass which
        overrides the C{makeArguments} method should call that
        C{makeArguments} method to get the response.
        rzcs���jd�i�f�dSr{)r�rlr��r�r}r r!r"r~
s
�zCCommandTests.test_callRemoteCallsMakeArguments.<locals>.gotResponse)ror:r�rfr�rr!r�r"�!test_callRemoteCallsMakeArguments
s
z.CommandTests.test_callRemoteCallsMakeArgumentscCs"|�tjtjtdt�d�d�dS)z�
        L{Command.makeArguments} raises L{amp.InvalidSignature} if the objects
        dictionary passed to it includes a key which does not correspond to the
        Python identifier for a defined argument.
        r9)r9Z
bogusArgumentN)r�r
r�rSrmr�r:r(r!r!r"�test_extraArgumentsDisallowed#
s�z*CommandTests.test_extraArgumentsDisallowedc	Cs*|�tjtjtfddiddi��d�dS)a�
        If a command argument conflicts with a Python keyword, the
        untransformed argument name is not allowed as a key in the dictionary
        passed to L{Command.makeArguments}.  If it is supplied,
        L{amp.InvalidSignature} is raised.

        This may be a pointless implementation restriction which may be lifted.
        The current behavior is tested to verify that such arguments are not
        silently dropped on the floor (the previous behavior).
        r9Zrequired�printzprint valueN)r�r
r�rSrmr�r(r!r!r"�test_wireSpellingDisallowed/
s�z(CommandTests.test_wireSpellingDisallowedcCs$Gdd�dtj�}|�d|j�dS)zj
        A L{Command} subclass without a defined C{commandName} that's
        not a byte string.
        c@seZdZdZdS)zPCommandTests.test_commandNameDefaultsToClassNameAsByteString.<locals>.NewCommandz(
            A new command.
            NrEr!r!r!r"�
NewCommandF
sr�s
NewCommandN)r
�Commandr�r]�r r�r!r!r"�/test_commandNameDefaultsToClassNameAsByteStringA
sz<CommandTests.test_commandNameDefaultsToClassNameAsByteStringcCs.|�ttdtjfddi�}|�t|�d�dS)zq
        A L{Command} subclass cannot be defined with a C{commandName} that's
        not a byte string.
        r�r]ZFOOz2^Command names must be byte strings, got: u?'FOO'$N�r�r�r�r
r��assertRegexr��r rr!r!r"�!test_commandNameMustBeAByteStringN
s��z.CommandTests.test_commandNameMustBeAByteStringcCs0|�ttdtjfddgi�}|�t|�d�dS)zS
        A L{Command} subclass's C{arguments} must have byte string names.
        r�ra�r�Nz3^Argument names must be byte strings, got: u?'foo'$Nr�r�r!r!r"�/test_commandArgumentsMustBeNamedWithByteStringsZ
s��z<CommandTests.test_commandArgumentsMustBeNamedWithByteStringscCs0|�ttdtjfddgi�}|�t|�d�dS)zR
        A L{Command} subclass's C{response} must have byte string names.
        r�rbr�z3^Response names must be byte strings, got: u?'foo'$Nr�r�r!r!r"�.test_commandResponseMustBeNamedWithByteStringse
s��z;CommandTests.test_commandResponseMustBeNamedWithByteStringscCs(Gdd�dtj�}|�tdi|j�dS)zN
        A L{Command} subclass's C{errors} is coerced into a C{dict}.
        c@seZdZedfgZdS)zDCommandTests.test_commandErrorsIsConvertedToDict.<locals>.NewCommand�ZDEN)r1r2r3rrcr!r!r!r"r�t
sr�r�N)r
r�r�rrcr�r!r!r"�#test_commandErrorsIsConvertedToDictp
s
�z0CommandTests.test_commandErrorsIsConvertedToDictc	Cs4|�ttdtjfdtdfgi�}|�t|�d�dS)zX
        A L{Command} subclass's C{errors} must map exceptions to byte strings.
        r�rcr�z0^Error names must be byte strings, got: u?'foo'$N�r�r�r�r
r�rr�r�r�r!r!r"�5test_commandErrorsMustUseBytesForOnWireRepresentation|
s��zBCommandTests.test_commandErrorsMustUseBytesForOnWireRepresentationcCs(Gdd�dtj�}|�tdi|j�dS)zS
        A L{Command} subclass's C{fatalErrors} is coerced into a C{dict}.
        c@seZdZedfgZdS)zICommandTests.test_commandFatalErrorsIsConvertedToDict.<locals>.NewCommandr�N)r1r2r3rrdr!r!r!r"r��
sr�r�N)r
r�r�rrdr�r!r!r"�(test_commandFatalErrorsIsConvertedToDict�
s
�z5CommandTests.test_commandFatalErrorsIsConvertedToDictc	Cs4|�ttdtjfdtdfgi�}|�t|�d�dS)ze
        A L{Command} subclass's C{fatalErrors} must map exceptions to byte
        strings.
        r�rdr�z6^Fatal error names must be byte strings, got: u?'foo'$Nr�r�r!r!r"�:test_commandFatalErrorsMustUseBytesForOnWireRepresentation�
s��zGCommandTests.test_commandFatalErrorsMustUseBytesForOnWireRepresentationN)r1r2r3r4rvryr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r!r!r!r"rt�	s&

rtc@s eZdZdZdd�Zdd�ZdS)�ListOfTestsMixina�
    Base class for testing L{ListOf}, a parameterized zero-or-more argument
    type.

    @ivar elementType: Subclasses should set this to an L{Argument}
        instance.  The tests will make a L{ListOf} using this.

    @ivar strings: Subclasses should set this to a dictionary mapping some
        number of keys -- as BYTE strings -- to the correct serialized form
        for some example values. These should agree with what L{elementType}
        produces/accepts.

    @ivar objects: Subclasses should set this to a dictionary with the same
        keys as C{strings} -- as NATIVE strings -- and with values which are
        the lists which should serialize to the values in the C{strings}
        dictionary.
    cCsNt�|j�}t��}|jD] }|�|�d�||j��d�q|�||j	�dS)a�
        L{ListOf.toBox} extracts the list of objects from the C{objects}
        dictionary passed to it, using the C{name} key also passed to it,
        serializes each of the elements in that list using the L{Argument}
        instance previously passed to its initializer, combines the serialized
        results, and inserts the result into the C{strings} dictionary using
        the same C{name} key.
        r�N)
r
�ListOf�elementTyper�rQrRr��copyr�rP)r �
stringListrPr�r!r!r"�
test_toBox�
s	
�zListOfTestsMixin.test_toBoxcCsDt�|j�}i}|jD]}|�||j��|d�q|�||j�dS)�X
        L{ListOf.fromBox} reverses the operation performed by L{ListOf.toBox}.
        N)r
r�r�rP�fromBoxr�r�rQ)r r�rQr�r!r!r"�test_fromBox�
s

zListOfTestsMixin.test_fromBoxN)r1r2r3r4r�r�r!r!r!r"r��
sr�c@s8eZdZdZe��Zdddd�Zgdgddd	gd
�ZdS)�ListOfStringsTestsz:
    Tests for L{ListOf} combined with L{amp.String}.
    rI�foosbarbazquux��empty�single�multiplerirjsbazsquux��empty�single�multipleN)	r1r2r3r4r
r^r�rPrQr!r!r!r"r��
s��r�c@sTeZdZdZe��ZddZddddee�dd�Z	gd	gd
ddgegd
gd�Z
dS)�ListOfIntegersTestsz;
    Tests for L{ListOf} combined with L{amp.Integer}.
    l
�����]OS�t7s�
Xg�&}rIs10s120500sts-1)r�r�r�shugesnegativer�r�i�r�)r�r�r��huge�negativeN)r1r2r3r4r
rpr�r�rrPrQr!r!r!r"r��
s$��
��r�c@s8eZdZdZe��Zdddd�Zgdgddd	gd
�ZdS)�ListOfUnicodeTestsz;
    Tests for L{ListOf} combined with L{amp.Unicode}.
    rIr�s☃Helloworldr�r�u☃rSr	r�N)	r1r2r3r4r
r`r�rPrQr!r!r!r"r��
s��r�c@s�eZdZdZe��Zddddde�d����	d�d	e�d
����	d�d�Z
ge�d�ge�d
�e�d�ge�d�e�d�e�d�e�d�e�d�e�d�ge�d�e�d
�gd�ZdS)�ListOfDecimalTestsz;
    Tests for L{ListOf} combined with L{amp.Decimal}.
    rIs1.1sInfinity	-InfinitysC3.141E+5
0.000031413.141E-7	-3.141E+5-0.00003141	-3.141E-7sZ0e6r�sz1.5E-9)r�r�sextremes	scientistsengineerz1.1ZInfinityz	-Infinityz3.141E5z3.141e-5z3.141E-7z-3.141e5z	-3.141E-5z	-3.141e-7)r�r�ZextremeZ	scientistZengineerN)r1r2r3r4r
�Decimalr��decimalZ
to_eng_stringr�rPrQr!r!r!r"r�
s<����
�	�	��r�c@sPeZdZdZe��ZddiZde�d�e�d�e�d�e�d�giZ	d	d
�Z
dS)�ListOfDecimalNanTestszS
    Tests for L{ListOf} combined with L{amp.Decimal} for not-a-number values.
    snansNaN-NaNsNaN-sNaN�nan�NaNz-NaN�sNaNz-sNaNcCs�dd�}dd�}dd�}t�|j�}i}|jD]}|�||j��|d�q.|d}|�||d	�on||d	��|�||d
�o�||d
��|�||d�o�||d��|�||d�o�||d��dS)
r�cSsdt|�kodt|�kS)Nr�r��r��r�r!r!r"�is_qnanTsz3ListOfDecimalNanTests.test_fromBox.<locals>.is_qnancSsdt|�kS)Nr�r�r�r!r!r"�is_snanWsz3ListOfDecimalNanTests.test_fromBox.<locals>.is_snancSsdt|�kS)N�-r�r�r!r!r"�	is_signedZsz5ListOfDecimalNanTests.test_fromBox.<locals>.is_signedNr�rrrr.)r
r�r�rPr�r�r�)r r�r�r�r�rQr��nr!r!r"r�Ns
  z"ListOfDecimalNanTests.test_fromBoxN)r1r2r3r4r
r�r�rPr�rQr�r!r!r!r"r�;s���	r�c@seZdZdZdd�ZdS)�DecimalTestsz#
    Tests for L{amp.Decimal}.
    cCs<t��}|�t|jd�|�t|jd�|�t|jd�dS)z�
        L{amp.Decimal.toString} raises L{ValueError} if passed an object which
        is not an instance of C{decimal.Decimal}.
        �1.234�X9��v��?��N)r
r�r��
ValueErrorr��r r�r!r!r"�test_nonDecimalpszDecimalTests.test_nonDecimalN)r1r2r3r4r�r!r!r!r"r�lsr�c@s eZdZdZdd�Zdd�ZdS)�
FloatTestsz!
    Tests for L{amp.Float}.
    cCs<t��}|�t|jd�|�t|jd�|�t|jd�dS)zq
        L{amp.Float.toString} raises L{ValueError} if passed an object which
        is not a L{float}.
        r��1.234r�N)r
�Floatr�r�r�r�r!r!r"�
test_nonFloat�szFloatTests.test_nonFloatcCst��}|�|�d�d�dS)zY
        L{amp.Float.toString} returns a bytestring when it is given a L{float}.
        r�r�N)r
r�r�r�r�r!r!r"�
test_float�szFloatTests.test_floatN)r1r2r3r4r�r�r!r!r!r"r�|sr�c@seZdZdZe��Zdddddd�Zejdd	d
dddej	d�ejdd	d
ddde
d
dd�d�gejdd	d
ddde
d
dd�d�gejdd	d
ddde
d
dd�d�gejdd	d
ddde
ddd�d�gejdd	d
ddde
d
dd�d�ejdd	d
ddde
ddd�d�gd�ZdS)�ListOfDateTimeTestsz<
    Tests for L{ListOf} combined with L{amp.DateTime}.
    sD 2010-12-25T00:00:00.000000-00:00 2010-12-25T00:00:00.000000-00:00s" 2010-12-25T00:00:00.000000+01:00s" 2010-12-25T00:00:00.000000+03:30s" 2010-12-25T00:00:00.000000-05:00sD 2010-12-25T00:00:00.000000+03:19 2010-12-25T00:00:00.000000-06:59)s	christmasschristmas in euschristmas in iranschristmas in nycsprevious tests����r)�tzinfo�+rr.�r�����;)Z	christmaszchristmas in euzchristmas in iranzchristmas in nyczprevious testsN)r1r2r3r4r
�DateTimer�rP�datetime�utc�tzrQr!r!r!r"r��s*�������r�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�ListOfOptionalTestszo
    Tests to ensure L{ListOf} AMP arguments can be omitted from AMP commands
    via the 'optional' flag.
    cCs0t�t���}|�t|jdt��ddid�dS)zn
        L{ListOf.toBox} raises C{TypeError} when passed a value of L{None}
        for the argument.
        �omitted�omittedN)r
r�rpr�r�rRr��r r�r!r!r"�1test_requiredArgumentWithNoneValueRaisesTypeError�s�zEListOfOptionalTests.test_requiredArgumentWithNoneValueRaisesTypeErrorcCs>tjt��dd�}t��}|�d|ddid�|�|i�dS)z�
        L{ListOf.toBox} silently omits serializing any argument with a
        value of L{None} that is designated as optional for the protocol.
        TrUr�N)r
r�rpr�rRr�)r r�rPr!r!r"�)test_optionalArgumentWithNoneValueOmitted�sz=ListOfOptionalTests.test_optionalArgumentWithNoneValueOmittedcCs0t�t���}|�t|jdt��ddid�dS)z|
        L{ListOf.toBox} raises C{KeyError} if the argument's key is not
        present in the objects dictionary.
        �ommitedZsomeOtherKeyrN)r
r�rpr��KeyErrorrRr�r�r!r!r"�1test_requiredArgumentWithKeyMissingRaisesKeyError�s�zEListOfOptionalTests.test_requiredArgumentWithKeyMissingRaisesKeyErrorcCs.tjt��dd�}|�dt��ddid�dS)z�
        L{ListOf.toBox} silently omits serializing any argument designated
        as optional whose key is not present in the objects dictionary.
        TrUr�ssomeOtherKeyrN)r
r�rprRr�r�r!r!r"�*test_optionalArgumentWithKeyMissingOmitted�sz>ListOfOptionalTests.test_optionalArgumentWithKeyMissingOmittedcCs:tjt��dd�}i}|�di|d�|�|ddi�dS)z�
        L{ListOf.fromBox} correctly reverses the operation performed by
        L{ListOf.toBox} for optional arguments.
        TrUr�Nr�)r
r�rpr�r�)r r�rQr!r!r"�.test_omittedOptionalArgumentDeserializesAsNone�szBListOfOptionalTests.test_omittedOptionalArgumentDeserializesAsNoneN)	r1r2r3r4r�r�r�r�r�r!r!r!r"r��s	r�c@sHeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dS)�UNIXStringTransportar
    An in-memory implementation of L{interfaces.IUNIXTransport} which collects
    all data given to it for later inspection.

    @ivar _queue: A C{list} of the data which has been given to this transport,
        eg via C{write} or C{sendFileDescriptor}.  Elements are two-tuples of a
        string (identifying the destination of the data) and the data itself.
    cCs||_g|_dS)zp
        @param descriptorFuzz: An offset to apply to descriptors.
        @type descriptorFuzz: C{int}
        N)�_fuzz�_queue)r �descriptorFuzzr!r!r"r#szUNIXStringTransport.__init__cCs|j�d||jf�dS)N�fileDescriptorReceived)r�r*r�)r �
descriptorr!r!r"�sendFileDescriptor	s�z&UNIXStringTransport.sendFileDescriptorcCs|j�d|f�dS)Nr+)r�r*r�r!r!r"r'szUNIXStringTransport.writecCs|D]}|�|�qdSr$)r')r �seqr%r!r!r"�
writeSequencesz!UNIXStringTransport.writeSequencecCs|j�dtt���f�dS)Nr/)r�r*r	rrBr(r!r!r"r�sz"UNIXStringTransport.loseConnectioncCs
t�d�S)Nz/tmp/some-path�rZUNIXAddressr(r!r!r"rcszUNIXStringTransport.getHostcCs
t�d�S)Nz/tmp/another-pathr�r(r!r!r"rNszUNIXStringTransport.getPeerN)r1r2r3r4r#r�r'r�r�rcrNr!r!r!r"r��s		r�c@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�DescriptorTestsz�
    Tests for L{amp.Descriptor}, an argument type for passing a file descriptor
    over an AMP connection over a UNIX domain socket.
    cCs<d|_t|jd�|_t�t�t����|_|j�|j�dS)Nr.)r�)	�fuzzr�r&r
rdrr�r
rer(r!r!r"r,s�zDescriptorTests.setUpcCs�t��}|j�d�|j�d�|j�d�|�d|�d|j��|�d|�d|j��|�d|�d|j��|�i|jj�dS)a|
        L{Descriptor.fromStringProto} constructs a file descriptor value by
        extracting a previously received file descriptor corresponding to the
        wire value of the argument from the L{_DescriptorExchanger} state of the
        protocol passed to it.

        This is a whitebox test which involves direct L{_DescriptorExchanger}
        state inspection.
        r�r.r�0�1�2N)r
�
Descriptorr
r�r�rO�_descriptorsr�r!r!r"�test_fromStringProto4s"
���z$DescriptorTests.test_fromStringProtocCs�t��}|�d|�d|j��|�dd|jf|jj�d��|�d|�d|j��|�dd|jf|jj�d��|�d|�d|j��|�dd|jf|jj�d��|�i|jj	�d	S)
a=
        To send a file descriptor, L{Descriptor.toStringProto} uses the
        L{IUNIXTransport.sendFileDescriptor} implementation of the transport of
        the protocol passed to it to copy the file descriptor.  Each subsequent
        descriptor sent over a particular AMP connection is assigned the next
        integer value, starting from 0.  The base ten string representation of
        this value is the byte encoding of the argument.

        This is a whitebox test which involves direct L{_DescriptorExchanger}
        state inspection and mutation.
        �0rr�rrr6�2r�N)
r
r�r�rcr
r�r&r�r�r�r�r!r!r"�test_toStringProtoKs"���z"DescriptorTests.test_toStringProtoc
Cs�d}|�d�}i}d}||i}t��}|�|||��|j�t�t�t����}|j	j
D]}t||d�|dd��qXi}	|�||��|	|�|�
||j|	|�dS)z�
        L{amp.Descriptor.fromBox} can interpret an L{amp.AmpBox} constructed by
        L{amp.Descriptor.toBox} to reconstruct a file descriptor value.
        Zalphar��rrN)r�r
r�rRr�r
rdrr�r&r��getattrr�r�r�)
r rKZnameAsBytesrPr�ZsendObjectsr�ZreceiverZeventZreceiveObjectsr!r!r"�test_roundTripds(
��zDescriptorTests.test_roundTripN)r1r2r3r4rr�r�rr!r!r!r"r�'s
r�c
@sXeZdZdZdZeddd�Ze�dddddd	d
e�Zdd�Z	d
d�Z
dd�Zdd�ZdS)�
DateTimeTestszO
    Tests for L{amp.DateTime}, L{amp._FixedOffsetTZInfo}, and L{amp.utc}.
    s 9876-01-23T12:34:56.054321-01:23r�r�i�&r��"�8i1�cCst��}|�t|jd�dS)z�
        L{amp.DateTime.fromString} raises L{ValueError} when passed a string
        which does not represent a timestamp in the proper format.
        �abcN)r
r�r�r�r��r rJr!r!r"�test_invalidString�sz DateTimeTests.test_invalidStringcCs,t��}|�t|jt�dddddd��dS)z�
        L{amp.DateTime.toString} raises L{ValueError} when passed a naive
        datetime (a datetime with no timezone information).
        r�r�r�rN)r
r�r�r�r�r�rr!r!r"�test_invalidDatetime�s
�z"DateTimeTests.test_invalidDatetimecCs&t��}|�|j�}|�||j�dS)z�
        L{amp.DateTime.fromString} returns a C{datetime.datetime} with all of
        its fields populated from the string passed to it.
        N)r
r�r�r_r�r:�r r�r�r!r!r"�test_fromString�szDateTimeTests.test_fromStringcCs&t��}|�|j�}|�||j�dS)z�
        L{amp.DateTime.toString} returns a C{str} in the wire format including
        all of the information from the C{datetime.datetime} passed into it,
        including the timezone offset.
        N)r
r�r�r:r�r_r	r!r!r"�
test_toString�szDateTimeTests.test_toStringN)
r1r2r3r4r_r�r�r�r:rrr
rr!r!r!r"r�s	

rc@s0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�UTCTestsz
    Tests for L{amp.utc}.
    cCs|�tj�d�d�dS)z8
        L{amp.utc.tzname} returns C{"+00:00"}.
        Nz+00:00)r�r
r��tznamer(r!r!r"�test_tzname�szUTCTests.test_tznamecCs|�tj�d�t�d��dS)z:
        L{amp.utc.dst} returns a zero timedelta.
        Nr)r�r
r�Zdstr��	timedeltar(r!r!r"�test_dst�szUTCTests.test_dstcCs|�tj�d�t�d��dS)z@
        L{amp.utc.utcoffset} returns a zero timedelta.
        Nr)r�r
r�Z	utcoffsetr�rr(r!r!r"�test_utcoffset�szUTCTests.test_utcoffsetcCs|�ttddd�dS)z�
        L{amp._FixedOffsetTZInfo.fromSignHoursMinutes} raises L{ValueError} if
        passed an offset sign other than C{'+'} or C{'-'}.
        �?rN)r�r�r�r(r!r!r"�test_badSign�szUTCTests.test_badSignN)r1r2r3r4rrrrr!r!r!r"r�s
rc@s(eZdZdZdd�Zdd�Zdd�ZdS)	�RemoteAmpErrorTestsz*
    Tests for L{amp.RemoteAmpError}.
    cCs t�dd�}|�dt|��dS)z�
        L{amp.RemoteAmpError} renders the given C{errorCode} (C{bytes}) and
        C{description} into a native string.
        �BROKEN�Something has brokenz"Code<BROKEN>: Something has brokenN�r
r�r�r�r�r!r!r"�test_stringMessage�sz&RemoteAmpErrorTests.test_stringMessagecCs t�dd�}|�dt|��dS)z�
        When C{errorCode} contains non-ASCII characters, L{amp.RemoteAmpError}
        renders then as backslash-escape sequences.
        sBROKEN-�rz'Code<BROKEN-\xff>: Something has brokenNrr�r!r!r"�&test_stringMessageReplacesNonAsciiText�sz:RemoteAmpErrorTests.test_stringMessageReplacesNonAsciiTextcCs0ttd��}tjdd|d�}|�t|�d�dS)zs
        L{amp.RemoteAmpError} renders local errors with a "(local)" marker and
        a brief traceback.
        zSomething came looserr)Zlocalz}^Code<BROKEN> [(]local[)]: Something has broken
Traceback [(]failure with no frames[)]: <.+Exception.>: Something came loose
N)r	r�r
r�r�r�)r r�rr!r!r"�"test_stringMessageWithLocalFailure�s��z6RemoteAmpErrorTests.test_stringMessageWithLocalFailureN)r1r2r3r4rrrr!r!r!r"r�s		rz2This test case requires SSL support in the reactor)�r4Z
__future__rrr�r�Zzope.interfacerZzope.interface.verifyrrZtwisted.pythonrZtwisted.python.compatrZtwisted.python.failurer	Ztwisted.protocolsr
Z
twisted.trialrrHrr
rrrrZtwisted.testrZtwisted.test.proto_helpersrr�ImportErrorZ	supportedrZ_FixedOffsetTZInfoZfromSignHoursMinutesr�r�rr�r5r�rCrFrGrurHr�rSrergrhrirjrlrmrrrtZProtocolSwitchCommandrurIrvr�rr�r�r�r�r�r�r�r�ZTestCaser�r�r:r�r�r�r*r�r+r5r7r8rBr�r�r^r�rr
rrrrrr+r/r0r1r2r3r4r7r8r:rCrDrNrOrUrPrXrYr\r^rdrfror�rrrsrtr�r�r�r�r�r�r�r�r�r�ZIUNIXTransportr�Z
ITransportr�rrrZIReactorSSLr�ZskipMsgrr!r!r!r"�<module>s 
.H�
	
I)Y[	k<
6.
'

'
�	u/.1&;-[1#(
@ Telegram