
    Vh7                         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 iB l                )	listranger   r
   int2b128writegetvalueb1282intassertEqual)self	funkylistixvys         O/home/dcms/DCMS/lib/python3.12/site-packages/twisted/spread/test/test_banana.pytest_int2b128zMathTests.test_int2b128   s    q#5t$%&5'*+, j 	  	#A	AOOAqww'

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)$OO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 4TWW =>dhh(&*nn#fdmm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(    0D0D 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&dgg..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 2DHH4H4H#N+D6: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#dgg..01e,dkk3/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    $$ qy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    
 $$&&,,dhh.B.BH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 4q 89X&''""$ 4 4 9:&,,dhh.C.CW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    
 ""$&,,dhh.B.BG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 4q 89W%''""$ 4 4 9:&,,dhh.C.CW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"dgg..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#dgg..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$dgg..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4LX!}-D	
 	S!dgg..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4LX!}-DKK!OKK!OKK"
 	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)     dO 	(DHH!!$'	(r   c                 ^    d}| j                  t        j                  | j                  |       y )Ns   rU   r
   rV   r   r   r   s     r   test_oversizedListzBananaTests.test_oversizedList  #    *&,,dii>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	HH!!+.!! 		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     	[)dgg..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]3Wz5IJY]3Wz5IJY]3Wz5IJ0Y]3W~5MNY]3W~5MNY]3W~5MN,
Y]3Wz5IJY]3Wz5IJY]35PQ0Y]3W~5MNY]3W~5MNY]3W~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'    
 	-txx/D/DdFVFV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     	dhh&d../djj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    
 	dhh&(DHH$9$94;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    
 	dhh&TZZ())477+;+;+=>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CfllRK&MFLL0M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    
 -&,,fmm[I  	y11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6x 6r   