Ë
    ojé7  ã                   óî   — d dl Z d dlmZ d dlmZ d dlmZmZ d dlm	Z	 d dl
mZ d dlmZ d dlmZ d d	lmZ d
Z G d„ de«      Zd„ Zd„ Z G d„ de«      Z G d„ de«      Z G d„ de«      Z G d„ de«      Zy)é    N)Úpartial)ÚBytesIO)ÚmainÚprotocol)ÚStringTransport)Úfailure)Ú	iterbytes)Úbanana)ÚTestCasel   ÿÿÿÿ c                   ó   — e Zd Zd„ Zy)Ú	MathTestsc                 ó^  — t        t        dd«      «      t        t        dd«      «      z   t        t        dd«      «      z   dgz   }|D ]c  }t        «       }t        j                  ||j
                  «       |j                  «       }t        j                  |«      }| j                  ||«       Œe y )Nr   éd   iè  iL  i@B i¤B l                )	ÚlistÚranger   r
   Úint2b128ÚwriteÚgetvalueÚb1282intÚassertEqual)ÚselfÚ	funkylistÚiÚxÚvÚys         úA/usr/lib/python3/dist-packages/twisted/spread/test/test_banana.pyÚtest_int2b128zMathTests.test_int2b128   sœ   € ä”�q˜#“ÓÜ”5˜˜tÓ$Ó%ñ&ä”5˜ 'Ó*Ó+ñ,ð ˆjñð 	ð ò 	#ˆAÜ“	ˆAÜ�O‰O˜A˜qŸw™wÔ'Ø—
‘
“ˆAÜ—‘ Ó"ˆAØ×Ñ˜Q Õ"ñ	#ó    N)Ú__name__Ú
__module__Ú__qualname__r   © r   r   r   r      s   „ ó#r   r   c                 ó(   —  | j                   |«       y)zÜ
    Dictate a Banana dialect to use.

    @param protocol: A L{banana.Banana} instance which has not yet had a
        dialect negotiated.

    @param dialect: A L{bytes} instance naming a Banana dialect to select.
    N)Ú_selectDialect)r   Údialects     r   ÚselectDialectr'   #   s   € ð €H×Ñ˜GÕ$r   c                 ó¬   — t        «       } | «       } |j                  |«       |j                  «         |j                  |«       |j	                  «       S )a«  
    Banana encode an object using L{banana.Banana.sendEncoded}.

    @param bananaFactory: A no-argument callable which will return a new,
        unconnected protocol instance to use to do the encoding (this should
        most likely be a L{banana.Banana} instance).

    @param obj: The object to encode.
    @type obj: Any type supported by Banana.

    @return: A L{bytes} instance giving the encoded form of C{obj}.
    )r   ÚmakeConnectionÚclearÚsendEncodedÚvalue)ÚbananaFactoryÚobjÚ	transportr
   s       r   Úencoder0   2   sJ   € ô  Ó!€IÙ‹_€FØ€F×Ñ˜)Ô$Ø‡O�OÔà€F×Ñ�sÔØ�?‰?ÓÐr   c                   ó:   — e Zd ZdZej
                  Zd„ Zd„ Zd„ Z	y)ÚBananaTestBasezn
    The base for test classes. It defines commonly used things and sets up a
    connection for testing.
    c                 ó\  — t        «       | _        | j                  «       | _        | j                  j	                  t        j                  | j                  «      «       t        | j                  d«       | j                  | j                  _	        t        t        | j                  «      | _        y )Ns   none)r   ÚioÚencClassÚencr)   r   ÚFileWrapperr'   Ú	putResultÚexpressionReceivedr   r0   ©r   s    r   ÚsetUpzBananaTestBase.setUpP   si   € Ü“)ˆŒØ—=‘=“?ˆŒØ�‰×Ñ¤× 4Ñ 4°T·W±WÓ =Ô>Ü�d—h‘h Ô(Ø&*§n¡nˆ�‰Ô#Üœf d§m¡mÓ4ˆ�r   c                 ó   — || _         y)z¨
        Store an expression received by C{self.enc}.

        @param result: The object that was received.
        @type result: Any type supported by Banana.
        N)Úresult)r   r=   s     r   r8   zBananaTestBase.putResultX   s   € ð ˆ�r   c                 ó€   — | j                   j                  t        j                  t        j
                  «      «       | ` y ©N)r6   ÚconnectionLostr   ÚFailurer   ÚCONNECTION_DONEr:   s    r   ÚtearDownzBananaTestBase.tearDowna   s(   € Ø�‰×Ñ¤§¡´×0DÑ0DÓ EÔFØ‰Hr   N)
r    r!   r"   Ú__doc__r
   ÚBananar5   r;   r8   rC   r#   r   r   r2   r2   H   s!   „ ñð
 �}‰}€Hò5òór   r2   c                   óš   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zy)ÚBananaTestsz
    General banana tests.
    c                 óÂ   — | j                   j                  d«       | j                   j                  | j                  j	                  «       «       | j
                  dk(  sJ ‚y )Ns   hello)r6   r+   ÚdataReceivedr4   r   r=   r:   s    r   Útest_stringzBananaTests.test_stringk   sE   € Ø�‰×Ñ˜XÔ&Ø�‰×Ñ˜dŸg™g×.Ñ.Ó0Ô1Ø�{‰{˜hÒ&Ð&Ñ&r   c                 ó(   — | j                  dd«       y)z”
        Banana does not support unicode.  ``Banana.sendEncoded`` raises
        ``BananaError`` if called with an instance of ``unicode``.
        Úhellozbuiltins.strN)Ú_unsupportedTypeTestr:   s    r   Útest_unsupportedUnicodez#BananaTests.test_unsupportedUnicodep   s   € ð
 	×!Ñ! '¨>Õ:r   c                 ó0   — | j                  t        d«       y)zÀ
        Banana does not support arbitrary builtin types like L{type}.
        L{banana.Banana.sendEncoded} raises L{banana.BananaError} if called
        with an instance of L{type}.
        zbuiltins.typeN)rM   Útyper:   s    r   Útest_unsupportedBuiltinTypez'BananaTests.test_unsupportedBuiltinTypew   s   € ð 	×!Ñ!¤$¨Õ8r   c                 óF   — | j                  t        «       t        dz   «       y)zæ
        Banana does not support arbitrary user-defined types (such as those
        defined with the ``class`` statement).  ``Banana.sendEncoded`` raises
        ``BananaError`` if called with an instance of such a type.
        z
.MathTestsN)rM   r   r    r:   s    r   Útest_unsupportedUserTypez$BananaTests.test_unsupportedUserType€   s   € ð 	×!Ñ!¤)£+¬x¸,Ñ/FÕGr   c                 ó¬   — | j                  t        j                  | j                  j                  |«      }| j                  d|› d�t        |«      «       y)aû  
        Assert that L{banana.Banana.sendEncoded} raises L{banana.BananaError}
        if called with the given object.

        @param obj: Some object that Banana does not support.
        @param name: The name of the type of the object.

        @raise: The failure exception is raised if L{Banana.sendEncoded} does
            not raise L{banana.BananaError} or if the message associated with the
            exception is not formatted to include the type of the unsupported
            object.
        zBanana cannot send z objectsN)ÚassertRaisesr
   ÚBananaErrorr6   r+   ÚassertInÚstr)r   r.   ÚnameÚexcs       r   rM   z BananaTests._unsupportedTypeTestˆ   sD   € ð ×Ñ¤× 2Ñ 2°D·H±H×4HÑ4HÈ#ÓNˆØ�‰Ð+¨D¨6°Ð:¼CÀ»HÕEr   c                 ó  — | j                   j                  d«       | j                   j                  | j                  j	                  «       «       | j                  | j                  d«       | j                  | j                  t        «       y)z×
        A positive integer less than 2 ** 32 should round-trip through
        banana without changing value and should come out represented
        as an C{int} (regardless of the type which was encoded).
        i§'  N)	r6   r+   rI   r4   r   r   r=   ÚassertIsInstanceÚintr:   s    r   Útest_intzBananaTests.test_int˜   s]   € ð 	�‰×Ñ˜UÔ#Ø�‰×Ñ˜dŸg™g×.Ñ.Ó0Ô1Ø×Ñ˜Ÿ™ eÔ,Ø×Ñ˜dŸk™k¬3Õ/r   c                 óV   — | j                   j                  }|dz  }d|z  dz
  }|dz   }|S )Né   é   é   )r6   ÚprefixLimit)r   ÚbytesÚbitsÚlargestÚsmallests        r   Ú_getSmallestzBananaTests._getSmallest£   s7   € à—‘×$Ñ$ˆð �q‰yˆà�T‘'˜A‘+ˆà˜Q‘;ˆØˆr   c                 óŽ   — | j                  «       }| j                  t        j                  | j                  j
                  |«       y)zz
        Test that a long above the implementation-specific limit is rejected
        as too large to be encoded.
        N)rh   rU   r
   rV   r6   r+   )r   rg   s     r   Útest_encodeTooLargeLongz#BananaTests.test_encodeTooLargeLong¯   s4   € ð
 ×$Ñ$Ó&ˆØ×Ñœ&×,Ñ,¨d¯h©h×.BÑ.BÀHÕMr   c                 óö  — | j                  «       }| j                  j                  | j                  j                  dz  «       | j                  j	                  |«       | j
                  j                  «       }| j
                  j                  d«       | j                  j                  | j                  j                  dz  «       | j                  t        j                  | j                  j                  |«       y)zz
        Test that a long above the implementation specific limit is rejected
        as too large to be decoded.
        ra   r   N)rh   r6   ÚsetPrefixLimitrc   r+   r4   r   ÚtruncaterU   r
   rV   rI   )r   rg   Úencodeds      r   Útest_decodeTooLargeLongz#BananaTests.test_decodeTooLargeLong·   s¬   € ð
 ×$Ñ$Ó&ˆØ�‰×Ñ §¡× 4Ñ 4°qÑ 8Ô9Ø�‰×Ñ˜XÔ&Ø—'‘'×"Ñ"Ó$ˆØ�‰×Ñ˜ÔØ�‰×Ñ §¡× 4Ñ 4¸Ñ 9Ô:à×Ñœ&×,Ñ,¨d¯h©h×.CÑ.CÀWÕMr   c                 ó$   — | j                  «        S r?   )rh   r:   s    r   Ú_getLargestzBananaTests._getLargestÅ   s   € Ø×!Ñ!Ó#Ð#Ð#r   c                 óŽ   — | j                  «       }| j                  t        j                  | j                  j
                  |«       y)zƒ
        Test that a negative long below the implementation-specific limit is
        rejected as too small to be encoded.
        N)rq   rU   r
   rV   r6   r+   )r   rf   s     r   Útest_encodeTooSmallLongz#BananaTests.test_encodeTooSmallLongÈ   s4   € ð
 ×"Ñ"Ó$ˆØ×Ñœ&×,Ñ,¨d¯h©h×.BÑ.BÀGÕLr   c                 óö  — | j                  «       }| j                  j                  | j                  j                  dz  «       | j                  j	                  |«       | j
                  j                  «       }| j
                  j                  d«       | j                  j                  | j                  j                  dz  «       | j                  t        j                  | j                  j                  |«       y)zƒ
        Test that a negative long below the implementation specific limit is
        rejected as too small to be decoded.
        ra   r   N)rq   r6   rl   rc   r+   r4   r   rm   rU   r
   rV   rI   )r   rf   rn   s      r   Útest_decodeTooSmallLongz#BananaTests.test_decodeTooSmallLongÐ   s¬   € ð
 ×"Ñ"Ó$ˆØ�‰×Ñ §¡× 4Ñ 4°qÑ 8Ô9Ø�‰×Ñ˜WÔ%Ø—'‘'×"Ñ"Ó$ˆØ�‰×Ñ˜ÔØ�‰×Ñ §¡× 4Ñ 4¸Ñ 9Ô:à×Ñœ&×,Ñ,¨d¯h©h×.CÑ.CÀWÕMr   c                 óØ   — | j                   j                  d«       | j                   j                  | j                  j	                  «       «       | j                  | j                  d«       y )Ni÷  ©r6   r+   rI   r4   r   r   r=   r:   s    r   Útest_integerzBananaTests.test_integerÞ   sG   € Ø�‰×Ñ˜TÔ"Ø�‰×Ñ˜dŸg™g×.Ñ.Ó0Ô1Ø×Ñ˜Ÿ™ dÕ+r   c                 óØ   — | j                   j                  d«       | j                   j                  | j                  j	                  «       «       | j                  | j                  d«       y )Ni	üÿÿrw   r:   s    r   Útest_negativezBananaTests.test_negativeã   sG   € Ø�‰×Ñ˜UÔ#Ø�‰×Ñ˜dŸg™g×.Ñ.Ó0Ô1Ø×Ñ˜Ÿ™ eÕ,r   c                 óØ   — | j                   j                  d«       | j                   j                  | j                  j	                  «       «       | j                  | j                  d«       y )Ng     ¸�@rw   r:   s    r   Ú
test_floatzBananaTests.test_floatè   sG   € Ø�‰×Ñ˜VÔ$Ø�‰×Ñ˜dŸg™g×.Ñ.Ó0Ô1Ø×Ñ˜Ÿ™ fÕ-r   c           	      ó   — ddddgddgddd	d
dggdgg g}| j                   j                  |«       | j                   j                  | j                  j	                  «       «       | j                  | j                  |«       y )Nrb   ra   é   é   ç     €>@çš™™™™D@é   ó   sixó   sevenó   eighté	   é
   rw   ©r   Úfoos     r   Ú	test_listzBananaTests.test_listí   s}   € àØØ�ˆFØ�4ˆLØØ�X ¨!˜}Ð-ØˆDØð	
ˆð 	�‰×Ñ˜SÔ!Ø�‰×Ñ˜dŸg™g×.Ñ.Ó0Ô1Ø×Ñ˜Ÿ™ cÕ*r   c                 óV  — ddddgddgddd	d
dggdgt         j                  dz  t         j                  dz  t         j                  dz  g
}| j                  j                  |«       | j	                  | j
                  j                  «       «       | j                  | j                  |«       y)zj
        Test feeding the data byte per byte to the receiver. Normally
        data is not split.
        rb   ra   r~   r   r€   r�   r‚   rƒ   r„   r…   r†   r‡   éþÿÿÿN)	ÚsysÚmaxsizer6   r+   Úfeedr4   r   r   r=   rˆ   s     r   Útest_partialzBananaTests.test_partialü   s˜   € ð ØØ�ˆFØ�4ˆLØØ�X ¨!˜}Ð-ØˆDä�K‰K˜!‰OÜ�K‰K˜!‰OÜ�K‰K˜"Ñð
ˆð 	�‰×Ñ˜SÔ!Ø�	‰	�$—'‘'×"Ñ"Ó$Ô%Ø×Ñ˜Ÿ™ cÕ*r   c                 óZ   — t        |«      D ]  }| j                  j                  |«       Œ y)z‡
        Feed the data byte per byte to the receiver.

        @param data: The bytes to deliver.
        @type data: L{bytes}
        N)r	   r6   rI   )r   ÚdataÚbytes      r   r�   zBananaTests.feed  s)   € ô ˜d“Oò 	(ˆDØ�H‰H×!Ñ! $Õ'ñ	(r   c                 ó^   — d}| j                  t        j                  | j                  |«       y )Ns   €©rU   r
   rV   r�   ©r   r’   s     r   Útest_oversizedListzBananaTests.test_oversizedList  ó#   € Ø*ˆà×Ñœ&×,Ñ,¨d¯i©i¸Õ>r   c                 ó^   — d}| j                  t        j                  | j                  |«       y )Ns   ‚r•   r–   s     r   Útest_oversizedStringz BananaTests.test_oversizedString!  r˜   r   c                 ór   — d}	 | j                   j                  |«       y # t        j                  $ r Y y w xY w)Ns       €)r6   rI   r
   rV   )r   ÚcrashStrings     r   Útest_crashStringzBananaTests.test_crashString&  s6   € Ø1ˆð	à�H‰H×!Ñ! +Õ.øÜ×!Ñ!ò 	Ùð	ús   „   6µ6c                 óØ   — | j                   j                  d«       | j                   j                  | j                  j	                  «       «       | j                  | j                  d«       y )Né   €rw   r:   s    r   Útest_crashNegativeLongz"BananaTests.test_crashNegativeLong9  sI   € ð 	�‰×Ñ˜[Ô)Ø�‰×Ñ˜dŸg™g×.Ñ.Ó0Ô1Ø×Ñ˜Ÿ™ kÕ2r   c                 ó¾  — d}d}d}| j                  | j                  |dz
  «      d|z   «       | j                  | j                  |dz
  «      d|z   «       | j                  | j                  |dz
  «      d	|z   «       d
}| j                  | j                  |dz   «      d|z   «       | j                  | j                  |dz   «      d|z   «       | j                  | j                  |dz   «      d|z   «       d}| j                  | j                  |dz   «      d|z   «       | j                  | j                  |dz   «      d	|z   «       | j                  | j                  |dz   «      d«       d}| j                  | j                  |dz
  «      d|z   «       | j                  | j                  |dz
  «      d|z   «       | j                  | j                  |dz
  «      d|z   «       y)zÇ
        Test that integers below the maximum C{INT} token size cutoff are
        serialized as C{INT} or C{NEG} and that larger integers are
        serialized as C{LONGINT} or C{LONGNEG}.
        iÿÿÿrŸ   s   �ra   ó   }rb   ó   ~r   ó   s      …ó    ó   r~   ó   s   ƒs       ƒs      †ó   N)r   r0   )r   Ú	baseIntInÚ	baseNegInÚ
baseIntOutÚbaseLongIntOutÚ
baseNegOutÚbaseLongNegOuts          r   Útest_sizedIntegerTypesz"BananaTests.test_sizedIntegerTypesE  s¶  € ð  ˆ	Øˆ	à,ˆ
Ø×Ñ˜Ÿ™ Y°¡]Ó3°W¸zÑ5IÔJØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸zÑ5IÔJØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸zÑ5IÔJà0ˆØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸~Ñ5MÔNØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸~Ñ5MÔNØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸~Ñ5MÔNà,ˆ
Ø×Ñ˜Ÿ™ Y°¡]Ó3°W¸zÑ5IÔJØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸zÑ5IÔJØ×Ñ˜Ÿ™ Y°¡]Ó3Ð5PÔQà0ˆØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸~Ñ5MÔNØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸~Ñ5MÔNØ×Ñ˜Ÿ™ Y°¡]Ó3°W¸~Ñ5MÕNr   N)r    r!   r"   rD   rJ   rN   rQ   rS   rM   r^   rh   rj   ro   rq   rs   ru   rx   rz   r|   rŠ   r�   r�   r—   rš   r�   r    r¯   r#   r   r   rG   rG   f   s�   „ ñò'ò
;ò9òHòFò 	0ò
òNòNò$òMòNò,ò
-ò
.ò
+ò+ò,(ò?ò
?ò
ò&
3óOr   rG   c                   ó°   — e Zd ZdZdZ eej                  j                  e   f«      ej                  z   Z
 ed«      ej                  z   Zd„ Zd„ Zd„ Zd„ Zy)	ÚDialectTestsz2
    Tests for Banana's handling of dialects.
    s   remote)éz   c                 ón   — | j                  t        | j                  j                  | j                  «       y)z|
        If no dialect has been selected and a PB VOCAB item is received,
        L{NotImplementedError} is raised.
        N)rU   ÚNotImplementedErrorr6   rI   ÚlegalPbItemr:   s    r   Útest_dialectNotSetzDialectTests.test_dialectNotSetl  s'   € ð
 	×ÑÔ-¨t¯x©x×/DÑ/DÀd×FVÑFVÕWr   c                 óÆ   — t        | j                  d«       | j                  j                  | j                  «       | j	                  | j
                  | j                  «       y)zS
        If the PB dialect has been selected, a PB VOCAB item is accepted.
        ó   pbN)r'   r6   rI   rµ   r   r=   Úvocabr:   s    r   Útest_receivePbzDialectTests.test_receivePbs  sB   € ô 	�d—h‘h Ô&Ø�‰×Ñ˜d×.Ñ.Ô/Ø×Ñ˜Ÿ™ d§j¡jÕ1r   c                 óš   — t        | j                  d«       | j                  t        | j                  j                  | j
                  «       y)zž
        If the PB dialect has been selected and an unrecognized PB VOCAB item
        is received, L{banana.Banana.dataReceived} raises L{KeyError}.
        r¸   N)r'   r6   rU   ÚKeyErrorrI   ÚillegalPbItemr:   s    r   Útest_receiveIllegalPbz"DialectTests.test_receiveIllegalPb{  s4   € ô
 	�d—h‘h Ô&Ø×Ñœ( D§H¡H×$9Ñ$9¸4×;MÑ;MÕNr   c                 óâ   — t        | j                  d«       | j                  j                  | j                  «       | j	                  | j
                  | j                  j                  «       «       y)zl
        if pb dialect is selected, the sender must be able to send things in
        that dialect.
        r¸   N)r'   r6   r+   r¹   r   rµ   r4   r   r:   s    r   Útest_sendPbzDialectTests.test_sendPbƒ  sK   € ô
 	�d—h‘h Ô&Ø�‰×Ñ˜TŸZ™ZÔ(Ø×Ñ˜×)Ñ)¨4¯7©7×+;Ñ+;Ó+=Õ>r   N)r    r!   r"   rD   r¹   rd   r
   rE   ÚoutgoingVocabularyÚVOCABrµ   r½   r¶   rº   r¾   rÀ   r#   r   r   r±   r±   c  s[   „ ñð €EÙ˜Ÿ™×9Ñ9¸%Ñ@ÐBÓCÀfÇlÁlÑR€KÙ˜&“M F§L¡LÑ0€MòXò2òOó?r   r±   c                   ó   — e Zd ZdZd„ Zy)ÚGlobalCoderTestszM
    Tests for the free functions L{banana.encode} and L{banana.decode}.
    c                 ó´   — d}| j                  t        j                  t        j                  |«       d}| j	                  t        j                  |«      d«       y)zJ
        Calls to L{banana.decode} are independent of each other.
        sB   …s   �rb   N)rU   r
   rV   Údecoder   )r   ÚundecodableÚ	decodables      r   Útest_statelessDecodez%GlobalCoderTests.test_statelessDecode’  sE   € ð
 -ˆØ×Ñœ&×,Ñ,¬f¯m©m¸[ÔIð  ˆ	Ø×ÑœŸ™ yÓ1°1Õ5r   N)r    r!   r"   rD   rÉ   r#   r   r   rÄ   rÄ   �  s   „ ñó6r   rÄ   )r�   Ú	functoolsr   r4   r   Útwisted.internetr   r   Útwisted.internet.testingr   Útwisted.pythonr   Útwisted.python.compatr	   Útwisted.spreadr
   Útwisted.trial.unittestr   Ú_maxintr   r'   r0   r2   rG   r±   rÄ   r#   r   r   ú<module>rÒ      ss   ðó
 Ý Ý ç +Ý 4Ý "Ý +Ý !Ý +à
€ô#�ô #ò %òô,�Xô ô<zO�.ô zOôz'?�>ô '?ôT6�xõ 6r   