%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/python3/dist-packages/twisted/names/test/__pycache__/
Upload File :
Create Path :
Current File : //lib/python3/dist-packages/twisted/names/test/__pycache__/test_rootresolve.cpython-312.pyc

�

Ϫ�f2d����dZddlmZddlmZddlmZmZmZm	Z	ddl
mZddlm
Z
mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZm Z dd	l!m"Z"dd
l#m$Z$ddl%m&Z&ddl'm(Z(dd
l)m*Z*m+Z+d�Z,d�Z-Gd�de+�Z.Gd�de/�Z0d�Z1Gd�de+�Z2gd�Z3ee�Gd�d��Z4eee4�Gd�de*�Z5Gd�d�Z6e(jne8d��Z9y )!z.
Test cases for Twisted.names' root resolver.
�)�implementer)�verifyClass)�Deferred�TimeoutError�
gatherResults�succeed)�IResolverSimple)�client�root)�CNAME�ENAME�HS�IN�NS�OK�A�Message�Name�Query�Record_A�Record_CNAME�	Record_NS�RRHeader)�DNSNameError�
ResolverError)�Resolver)�
MemoryReactor)�msg)�util)�SynchronousTestCase�TestCasec�,�|\}}}|djS)z�
    From the result of a L{Deferred} returned by L{IResolver.lookupAddress},
    return the payload of the first record in the answer section.
    r��payload��results�ans�auth�adds    �E/usr/lib/python3/dist-packages/twisted/names/test/test_rootresolve.py�
getOnePayloadr+&s��
�N�C��s��q�6�>�>��c�4�t|�j�S)z�
    From the result of a L{Deferred} returned by L{IResolver.lookupAddress},
    return the first IPv4 address from the answer section.
    )r+�
dottedQuad�r&s r*�
getOneAddressr0/s��
��!�,�,�.�.r,c��eZdZdZd�Zd�Zd�Zgggefd�Zdd�Z	d�Z
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zy)�RootResolverTestsz3
    Tests for L{twisted.names.root.Resolver}.
    c�`�t�}tg|��}|jtdtt
�dgd|�}|jj�\}}|j\\}}t�}	|	j|�|j|	jtdtt
�g�|j|	jg�|j|	jg�|j|	jg�g}
|j!|
j"�|j|
g�|	jdd�=d|	_|	jj#t'dt)d����|j*j-|	j/�d�|
d	S)
aK
        Invoke L{Resolver._query} and verify that it sends the correct DNS
        query.  Deliver a canned response to the query and return whatever the
        L{Deferred} returned by L{Resolver._query} fires with.

        @param filter: The value to pass for the C{filter} parameter to
            L{Resolver._query}.
        )�reactor�foo.example.com)�1.1.2.3i)�N��	5.8.13.21r#r)rr�_queryrrr�udpPorts�popitem�_sentPacketsr�fromStr�assertEqual�queries�answers�	authority�
additional�addCallback�append�answerrr�	_protocol�datagramReceived�toStr)�self�filterr4�resolver�d�
portNumber�	transport�packet�address�message�responses           r*�
_queryTestzRootResolverTests._queryTest<sg�� �/���B��0���O�O��$�a��,�/@�.A�5�&�
��
!(� 0� 0� 8� 8� :��
�I�(�4�4��	�&�'��)�������	
������5�1C�Q��+K�*L�M�������"�-�����*�*�B�/�����+�+�R�0���	�
�
�h�o�o�&�����2�&�
�O�O�A�����������'��+�1F�G�	
�	���,�,�W�]�]�_�>O�P���{�r,c
���|jd�\}}}|j|tdtdd����g�|j|g�|j|g�y)a)
        L{Resolver._query} accepts a L{Query} instance and an address, issues
        the query, and returns a L{Deferred} which fires with the response to
        the query.  If a true value is passed for the C{filter} parameter, the
        result is a three-tuple of lists of records.
        Tr5r9r��ttlr#N)rTr?rr)rJrFrBrCs    r*�test_filteredQueryz$RootResolverTests.test_filteredQuerygsa��)-����(=�%��	�:�����X�0�(�;�TU�:V�W�X�	
�	
����B�'�����R�(r,c
�`�|jd�}|j|t�|j|jg�|j|j
t
dtdd����g�|j|jg�|j|jg�y)z�
        Similar to L{test_filteredQuery}, but for the case where a false value
        is passed for the C{filter} parameter.  In this case, the result is a
        L{Message} instance.
        Fr5r9rrVr#N)
rT�assertIsInstancerr?r@rArrrBrC)rJrRs  r*�test_unfilteredQueryz&RootResolverTests.test_unfilteredQueryus����/�/�%�(�����g�w�/�������"�-�����O�O�
�(�(�;�A�2N�
O�P�	
�	
����*�*�B�/�����+�+�R�0r,c� �t|��}|j|f|j|f|j|ffD]O\}}|j	|D��	cgc]-\}}	t||	jt|	dt�|	����/c}	}��Q|Scc}	}w)a�
        Create a L{Message} suitable for use as a response to a query.

        @param answers: A C{list} of two-tuples giving data for the answers
            section of the message.  The first element of each tuple is a name
            for the L{RRHeader}.  The second element is the payload.
        @param authority: A C{list} like C{answers}, but for the authority
            section of the response.
        @param additional: A C{list} like C{answers}, but for the
            additional section of the response.
        @param rCode: The response code the message will be created with.

        @return: A new L{Message} initialized with the given values.
        )�rCode�CLASSr#)	rrArBrC�extendr�TYPE�getattrr)
rJrArBrCr]rS�section�data�name�records
          r*�_respondzRootResolverTests._respond�s�����'��
�
�
�w�'�
�
�
��+�
�
 �
 �*�-�
�	�M�G�T�

�N�N�
+/�	�'��v���f�k�k�7�6�7�B�+G�QW���
�	����s�2B
c�B���dg}t||�}��fd�}||_|S)a�
        Create and return a new L{root.Resolver} modified to resolve queries
        against the record data represented by C{servers}.

        @param serverResponses: A mapping from dns server addresses to
            mappings.  The inner mappings are from query two-tuples (name,
            type) to dictionaries suitable for use as **arguments to
            L{_respond}.  See that method for details.
        r6c���td|j�d|���|D]I}	�|}||jj|jf}t	�j
di|���cSy#t$rY�XwxYw)NzQuery for QNAME z at �)rrd�KeyError�typerrf)	�query�serverAddresses�timeoutrK�addr�server�recordsrJ�serverResponsess	       ��r*rlz-RootResolverTests._getResolver.<locals>.query�s�����"�5�:�:�,�d�?�2E�F�G�'�
9���,�T�2�F�!������%�*�*�!<�=���}�t�}�}�7�w�7�8�8�

9�� ����s�A,�,	A8�7A8)rr:)rJrr�maximumQueries�rootsrLrls``    r*�_getResolverzRootResolverTests._getResolver�s+�������E�>�2��	9� ����r,c�(�dtfdtd�fgdtd�fgd�idtfddtd�fgiid�}|j|�}|j	d�}|jt�|j|jd�|S)a
        L{root.Resolver.lookupAddress} looks up the I{A} records for the
        specified hostname by first querying one of the root servers the
        resolver was created with and then following the authority delegations
        until a result is received.
        r5�ns1.example.com�34.55.89.144�rBrCrA�10.0.0.1)�r6�5)rxr|�rrrru�
lookupAddressrDr0r?�rJ�serversrLrMs    r*�test_lookupAddressz$RootResolverTests.test_lookupAddress�s���$�Q�'�#5�y�AS�7T�"U�!V�$6���8P�#Q�"R�*��$�Q�'��!3�X�j�5I� J�K�*�#�
���$�$�W�-���"�"�#5�6��	�
�
�m�$�	�
�
�d�&�&�
�3��r,c�n�td�}t|_dtfd|fgdt	d�fgdtd�fgd�idtfddtd�fgiid�}|j|�}|j
d�}|jt�|j|jtd��|S)	z�
        If a response includes a record with a class different from the one
        in the query, it is ignored and lookup continues until a record with
        the right class is found.
        rzr5rw�10.0.0.2)rArBrCrA�10.0.0.3)r{�r�r|)
rrr^rrrur~rDr+r?)rJ�badClassr�rLrMs     r*�test_lookupChecksClassz(RootResolverTests.test_lookupChecksClass�s����J�'�����$�Q�'�!3�X� >�?�#5�y�AS�7T�"U�!V�$6���8L�#M�"N�*��$�Q�'��!3�X�j�5I� J�K�*��

���$�$�W�-���"�"�#5�6��	�
�
�m�$�	�
�
�d�&�&���(<�=��r,c�:�dtfddtd�fgidtfddtd�fgiidtfddtd�fgiid�}|j|�}|j	d�}|jt�|j|jd�|S)z�
        If an intermediate response includes no glue records for the
        authorities, separate queries are made to find those addresses.
        r5rBsns1.example.orgrArzr�)r{)rzr|r}rs    r*�test_missingGluez"RootResolverTests.test_missingGlue�s���$�Q�'��#5�y�AS�7T�"U�!V�*�$�Q�'��!3�X�j�5I� J�K�*��$�Q�'��!3�X�j�5I� J�K�*��
�� �$�$�W�-���"�"�#5�6��	�
�
�m�$�	�
�
�d�&�&�
�3��r,c��ddtfdtiii}|j|�}|jd�}|j	|t
�S)z�
        If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred}
        which fails with L{DNSNameError}.
        r{r5r])rr
rur~�
assertFailurerrs    r*�test_missingNamez"RootResolverTests.test_missingNames[��
�#�Q�'��U�*��
���$�$�W�-���"�"�#5�6���!�!�!�\�2�2r,c��ddtfiii}|j|�}|jd�}|j|t�S)z�
        If a query is responded to with no answers or nameserver records, the
        L{Deferred} returned by L{Resolver.lookupAddress} fires with
        L{ResolverError}.
        r{�example.com)rrur~r�rrs    r*�test_answerlessz!RootResolverTests.test_answerlesssR��
���#�R��
��
�$�$�W�-���"�"�>�2���!�!�!�]�3�3r,c���ddtfddtd�fgidtfdtiii}|j|�}|j	d�}|j|t�S)z�
        If there is an error resolving the nameserver in a delegation response,
        the L{Deferred} returned by L{Resolver.lookupAddress} fires with that
        error.
        r{r�rBrwr])rrr
rur~r�rrs    r*�test_delegationLookupErrorz,RootResolverTests.test_delegationLookupError.s|��
���#��>�9�=O�3P�"Q�!R�&�$�Q�'��U�*�	�	
���$�$�W�-���"�"�>�2���!�!�!�\�2�2r,c��ddtfddtd�fgidtfiii}|j|�}|jd�}|j	|t
�S)z�
        If there are no records in the response to a lookup of a delegation
        nameserver, the L{Deferred} returned by L{Resolver.lookupAddress} fires
        with L{ResolverError}.
        r{r�rBrw)rrrur~r�rrs    r*�test_delegationLookupEmptyz,RootResolverTests.test_delegationLookupEmptyBst��
���#��>�9�=O�3P�"Q�!R�&�$�Q�'��	�
���$�$�W�-���"�"�>�2���!�!�!�]�3�3r,c	��ddtfdtidtfddtd�fgiii}|j	|�}|jd�}d�}|j
|�|j
|jtd��|S)z�
        L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except
        it queries for I{NS} records instead of I{A} records.
        r{r�r]rArwc�@�|\}}}|djjS�Nr)r$rdr%s    r*�
getOneNamez<RootResolverTests.test_lookupNameservers.<locals>.getOneNamefs!��$�N�C��s��q�6�>�>�&�&�&r,)	rr
rrru�lookupNameserversrDr?r)rJr�rLrMr�s     r*�test_lookupNameserversz(RootResolverTests.test_lookupNameserversTs���
���#��U�&� ��$����;M�1N� O�P�'�	�	
���$�$�W�-���&�&�~�6��	'�	
�
�
�j�!�	�
�
�d�&�&��-?�(@�A��r,c�Z�ddtfddtd�fdtd�fgiii}|j|�}|j	d�}|jd��|j|jtdttd���tdttd���g�|S)z�
        If a I{CNAME} record is encountered as the answer to a query for
        another record type, that record is returned as the answer.
        r{r�rA�example.netz10.0.0.7c��|dSr�rir/s r*�<lambda>z<RootResolverTests.test_returnCanonicalName.<locals>.<lambda>�
��g�a�j�r,r#�	rrrrur~rDr?rrrs    r*�test_returnCanonicalNamez*RootResolverTests.test_returnCanonicalNamens���
���#��'��n�)E�F�'��*�)=�>� �&��	
���$�$�W�-���"�"�>�2��	�
�
�0�1�	�
�
��������^�8T�U����H�Z�4H�I�
�	
��r,c�n�ddtfddtd�fgidtfddtd�fgiii}|j|�}|j	d�}|jd��|j|jtdttd���tdttd���g�|S)z�
        If no record of the requested type is included in a response, but a
        I{CNAME} record for the query name is included, queries are made to
        resolve the value of the I{CNAME}.
        r{r�rAr�z10.0.0.5c��|dSr�rir/s r*r�z<RootResolverTests.test_followCanonicalName.<locals>.<lambda>�r�r,r#r�rs    r*�test_followCanonicalNamez*RootResolverTests.test_followCanonicalName�s���
���#����n�1M� N�O�&� ��#����*�1E� F�G�&�	�	
���$�$�W�-���"�"�>�2��	�
�
�0�1�	�
�
��������^�8T�U����H�Z�4H�I�
�	
��r,c��ddtfddtd�fdtd�fgiii}|j|�}|jd�}|j	|t
�S)z�
        If there is a cycle between I{CNAME} records in a response, this is
        detected and the L{Deferred} returned by the lookup method fails
        with L{ResolverError}.
        r{r�rAr�)rrrur~r�rrs    r*�test_detectCanonicalNameLoopz.RootResolverTests.test_detectCanonicalNameLoop�sw��
���#��'��n�)E�F�'��n�)E�F� �&��	
���$�$�W�-���"�"�>�2���!�!�!�]�3�3r,c��dtfddtd�fgidtfddtd�fgiidtfdtd�fgdtd�fgd�idtfddtd	�fgiid
�}|j|d�}|j	|jd�t�}|j|d�}|jd�}|jt�|j|jtd	��t||g�S)
z�
        L{Resolver.lookupAddress} won't issue more queries following
        delegations than the limit passed to its initializer.
        r�rBrwrAr�sns2.example.comr�ryz10.0.0.4)r{r�)r�r|��)rrrrur�r~rrDr+r?r)rJr��failer�failD�	succeeder�succeedDs      r*�test_boundedQueriesz%RootResolverTests.test_boundedQueries�s:�� ��#��>�9�=O�3P�"Q�!R�&�
$�Q�'��!3�X�j�5I� J�K�*��  ��#�#1�9�=O�3P�"Q�!R�$6���8L�#M�"N�&�	� ��#����*�1E� F�G�&��-
��B�"�"�7�A�.���"�"�6�#7�#7��#G��W���%�%�g�q�1�	��*�*�>�:�����]�+����T�-�-�x�
�/C�D��e�X�.�/�/r,N)�
)�__name__�
__module__�__qualname__�__doc__rTrXr[rrfrur�r�r�r�r�r�r�r�r�r�r�r�rir,r*r2r27sh���)�V)�1�  "�R�B�b��>�4�4�8�63� 
4�3�(4�$�4�6�84�(.0r,r2c��eZdZdZd�Zy)�ResolverFactoryArgumentszf
    Raised by L{raisingResolverFactory} with the *args and **kwargs passed to
    that function.
    c� �||_||_y)z�
        Store the supplied args and kwargs as attributes.

        @param args: Positional arguments.
        @param kwargs: Keyword arguments.
        N��args�kwargs)rJr�r�s   r*�__init__z!ResolverFactoryArguments.__init__�s����	���r,N)r�r�r�r�r�rir,r*r�r��s���
r,r�c��t||��)a=
    Raise a L{ResolverFactoryArguments} exception containing the
    positional and keyword arguments passed to resolverFactory.

    @param args: A L{list} of all the positional arguments supplied by
        the caller.

    @param kwargs: A L{list} of all the keyword arguments supplied by
        the caller.
    )r�r�s  r*�raisingResolverFactoryr��s��#�4��
0�0r,c�"�eZdZdZd�Zd�Zd�Zy)� RootResolverResolverFactoryTestsz6
    Tests for L{root.Resolver._resolverFactory}.
    c�h�tdgt��}|j|jt�y)z�
        L{root.Resolver.__init__} accepts a C{resolverFactory}
        argument and assigns it to C{self._resolverFactory}.
        N)�hints�resolverFactory)rr��assertIs�_resolverFactory�rJ�rs  r*�#test_resolverFactoryArgumentPresentzDRootResolverResolverFactoryTests.test_resolverFactoryArgumentPresents(��

�D�6�3I�J���
�
�a�(�(�*@�Ar,c�r�tdg��}|j|jtj�y)z�
        L{root.Resolver.__init__} sets L{client.Resolver} as the
        C{_resolverFactory} if a C{resolverFactory} argument is not
        supplied.
        N)r�)rr�r�r
r�s  r*�"test_resolverFactoryArgumentAbsentzCRootResolverResolverFactoryTests.test_resolverFactoryArgumentAbsents(��
�D�6�"���
�
�a�(�(�&�/�/�:r,c���t�}tdgt|��}|jt|j
d�}|j
d|dgd�f|j|jf�y)zy
        L{root.Resolver._resolverFactory} is supplied with C{reactor} and
        C{servers} keyword arguments.
        �192.0.2.101)r�r�r4zexample.comri)r�r|)r4r�N)	�objectrr��assertRaisesr�r~r?r�r�)rJ�dummyReactorr��es    r*�)test_resolverFactoryOnlyExpectedArgumentszJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArgumentssj��
�x��� �/�2� �
��
���6�����W�����
�\�7J�6K�L�M�
�V�V�Q�X�X��	
r,N)r�r�r�r�r�r�r�rir,r*r�r�	s���B�;�
r,r�)
za.root-servers.netzb.root-servers.netzc.root-servers.netzd.root-servers.netze.root-servers.netzf.root-servers.netzg.root-servers.netzh.root-servers.netzi.root-servers.netzj.root-servers.netzk.root-servers.netzl.root-servers.netzm.root-servers.netc��eZdZdZd�Zd�Zy)�StubResolverz�
    An L{IResolverSimple} implementer which traces all getHostByName
    calls and their deferred results. The deferred results can be
    accessed and fired synchronously.
    c� �g|_g|_y)z�
        @type calls: L{list} of L{tuple} containing C{args} and
            C{kwargs} supplied to C{getHostByName} calls.
        @type pendingResults: L{list} of L{Deferred} returned by
            C{getHostByName}.
        N)�calls�pendingResults)rJs r*r�zStubResolver.__init__Ls����
� ��r,c��|jj||f�t�}|jj|�|S)al
        A fake implementation of L{IResolverSimple.getHostByName}

        @param args: A L{list} of all the positional arguments supplied by
           the caller.

        @param kwargs: A L{list} of all the keyword arguments supplied by
           the caller.

        @return: A L{Deferred} which may be fired later from the test
            fixture.
        )r�rErr�)rJr�r�rMs    r*�
getHostByNamezStubResolver.getHostByNameVs:��	
�
�
���4��.�)��J�����"�"�1�%��r,N)r�r�r�r�r�r�rir,r*r�r�Ds���!�r,r�c�:�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
y	)
�BootstrapTestsz%
    Tests for L{root.bootstrap}
    c�~�tjt��}|j|tj�y)zl
        L{root.bootstrap} returns an object which is initially a
        L{root.DeferredResolver}.
        N)r�	bootstrapr�rZ�DeferredResolver)rJ�deferredResolvers  r*�test_returnsDeferredResolverz+BootstrapTests.test_returnsDeferredResolverqs,��
 �>�>�,�.�9�����.��0E�0E�Fr,c��t�}tj|�|j|jt
D�cgc]}|fif��	c}�ycc}w)z�
        The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup
        the IP addresses of the 13 root name servers.
        N)r�rr�r?r��ROOT_SERVERS)rJ�stubResolver�ss   r*�test_resolves13RootServersz)BootstrapTests.test_resolves13RootServersysA��
$�~�����|�$�����+�+�,�-O�Q��t�R�j�-O�P��-Os�A
c��t�}tj|�}|jD]}|j	d��|j|t�y)z�
        The L{root.DeferredResolver} initially returned by L{root.bootstrap}
        becomes a L{root.Resolver} when the supplied resolver has successfully
        looked up all root hints.
        r�N)r�rr�r��callbackrZr�rJr�r�rMs    r*�test_becomesResolverz#BootstrapTests.test_becomesResolver�sL��$�~���>�>�,�7���,�,�	&�A�
�J�J�}�%�	&����.��9r,c���t�}tj|�}|jD]}|j	d��|j|jdgdz�y)z�
        The L{root.Resolver} which eventually replaces L{root.DeferredResolver}
        is supplied with the IP addresses of the 13 root servers.
        r��
N)r�rr�r�r�r?r�r�s    r*�test_resolverReceivesRootHintsz-BootstrapTests.test_resolverReceivesRootHints�sY��
$�~���>�>�,�7���,�,�	&�A�
�J�J�}�%�	&����)�/�/�-��2�1E�Fr,c����t�}tj|��t|j�}t|�}|D]}|j
d��|jt����fd�}|j|�y)z�
        The L{root.Resolver} is eventually created, even if some of the root
        hint lookups fail. Only the working root hint IP addresses are supplied
        to the L{root.Resolver}.
        r�c�F���j�jdgdz�y)Nr���r?r���resr�rJs ��r*�
checkHintszFBootstrapTests.test_continuesWhenSomeRootHintsFail.<locals>.checkHints�s!������-�3�3�m�_�r�5I�Jr,N)
r�rr��iterr��nextr��errbackr�addBoth�rJr�r&�d1rMr�r�s`     @r*�#test_continuesWhenSomeRootHintsFailz2BootstrapTests.test_continuesWhenSomeRootHintsFail�sq���$�~���>�>�,�7���|�2�2�3��
�'�]���	&�A�
�J�J�}�%�	&�
�
�
�<�>�"�	K�	�
�
�:�r,c�f���t�}tj|��t|j�}t|�}|D]}|j
t���|j
t����fd�}|j|��j�jt�y)z�
        The L{root.Resolver} is eventually created, even if all of the root hint
        lookups fail. Pending and new lookups will then fail with
        AttributeError.
        c�>���j�jg�y�Nr�r�s ��r*r�zEBootstrapTests.test_continuesWhenAllRootHintsFail.<locals>.checkHints�s������-�3�3�R�8r,N)r�rr�r�r�r�r�rr��
addCleanup�flushLoggedErrorsr�s`     @r*�"test_continuesWhenAllRootHintsFailz1BootstrapTests.test_continuesWhenAllRootHintsFail�s����$�~���>�>�,�7���|�2�2�3��
�'�]���	&�A�
�I�I�l�n�%�	&�
�
�
�<�>�"�	9�	�
�
�:������.�.��=r,c���t�}tj|t��}|jD]}|jd��|j
|jt�y)z�
        L{root.bootstrap} accepts a C{resolverFactory} argument which is passed
        as an argument to L{root.Resolver} when it has successfully looked up
        root hints.
        )r�r�N)r�rr�r�r�r�r�r�r�s    r*�test_passesResolverFactoryz)BootstrapTests.test_passesResolverFactory�s[��$�~���>�>��*@�
���,�,�	&�A�
�J�J�}�%�	&�	
�
�
�&�7�7�9O�Pr,N)r�r�r�r�r�r�r�r�r�r�r�rir,r*r�r�ls.���G�Q�
:�	G��&>�*Qr,r�c��eZdZdZd�Zy)�StubDNSDatagramProtocolz�
    A do-nothing stand-in for L{DNSDatagramProtocol} which can be used to avoid
    network traffic in tests where that kind of thing doesn't matter.
    c��t�Sr�)r)rJ�a�kws   r*rlzStubDNSDatagramProtocol.query�s
���z�r,N)r�r�r�r�rlrir,r*rr�s���
r,rzbtwisted.names.root.retry is deprecated since Twisted 10.0.  Use a Resolver object for retry logic.)�categoryrRN):r��zope.interfacer�zope.interface.verifyr�twisted.internet.deferrrrr�twisted.internet.interfacesr	�
twisted.namesr
r�twisted.names.dnsrr
rrrrrrrrrrrr�twisted.names.errorrr�twisted.names.rootr�twisted.names.test.test_utilr�twisted.python.logr�
twisted.trialr�twisted.trial.unittestr r!r+r0r2�	Exceptionr�r�r�r�r�r�r�suppress�DeprecationWarning�_retrySuppressionrir,r*�<module>rs����'�-�Q�Q�7�&����� <�'�6�"��@��/�p0��p0�f
�y��"1�'
�x�'
�T��"
�_��!�!��!�H�O�\�*�cQ�(�cQ�L��"�D�M�M�
�	+��r,

Zerion Mini Shell 1.0