+
    Dfj2d                        R t ^ RIHt ^ RIHt ^ RIHtHtHtH	t	 ^ RI
Ht ^ RIHtHt ^ RIHtHtHtHtHtHtHtHtHtHtHtHtHtHt ^ RIHtH t  ^ RI!H"t" ^ R	I#H$t$ ^ R
I%H&t& ^ RI'H(t( ^ RI)H*t*H+t+ R t,R t- ! R R]+4      t. ! R R]/4      t0R t1 ! R R]+4      t2. ROt3]! ]4       ! R R4      4       t4]! ]]44        ! R R]*4      t5 ! R R4      t6](Pn                  ! ]8RR7      t9R# ) 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                2    V w  rpV^ ,          P                   # )z
From the result of a L{Deferred} returned by L{IResolver.lookupAddress},
return the payload of the first record in the answer section.
payloadresultsansauthadds   &   E/usr/lib/python3/dist-packages/twisted/names/test/test_rootresolve.pygetOnePayloadr*   &   s    
 NCsq6>>    c                4    \        V 4      P                  4       # )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)   getOneAddressr/   /   s    
 !,,..r+   c                      a  ] tR t^7t o RtR tR tR t. . . ]3R lt	RR lt
R tR tR	 tR
 tR tR tR tR tR tR tR tR tRtV tR# )RootResolverTestsz+
Tests for L{twisted.names.root.Resolver}.
c                `   \        4       p\        . VR7      pVP                  \        R\        \
        4      R.RV4      pVP                  P                  4       w  rVVP                  w  w  rx\        4       p	V	P                  V4       V P                  V	P                  \        R\        \
        4      .4       V P                  V	P                  . 4       V P                  V	P                  . 4       V P                  V	P                  . 4       . p
VP!                  V
P"                  4       V P                  V
. 4       V	P                  R ^V	n        V	P                  P#                  \'        R\)        R4      R7      4       VP*                  P-                  V	P/                  4       R4       V
^ ,          # )a  
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:NNN	5.8.13.21r"   )1.1.2.3i  )   )r   r   _queryr   r   r   udpPortspopitem_sentPacketsr   fromStrassertEqualqueriesanswers	authority
additionaladdCallbackappendanswerr   r   	_protocoldatagramReceivedtoStr)selffilterr3   resolverd
portNumber	transportpacketaddressmessageresponses   &&         r)   
_queryTestRootResolverTests._queryTest<   sc     /B0OO$a,/@.A5&

 !( 0 0 8 8 :
 (44	&) 	51CQ+K*LM"-**B/++R0	hoo&2& OOA'+1FG	
 	,,W]]_>OP{r+   c                    V P                  R4      w  rpV P                  V\        R\        R^ R7      R7      .4       V P                  V. 4       V P                  V. 4       R# )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.
Tr4   r5   ttlr"   N)rR   r=   r   r   )rH   rD   r@   rA   s   &   r)   test_filteredQuery$RootResolverTests.test_filteredQueryg   s_     )-(=%:X0(;TU:VWX	
 	B'R(r+   c                b   V P                  R4      pV P                  V\        4       V P                  VP                  . 4       V P                  VP
                  \        R\        R^ R7      R7      .4       V P                  VP                  . 4       V P                  VP                  . 4       R# )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.
Fr4   r5   rU   r"   N)
rR   assertIsInstancer   r=   r>   r?   r   r   r@   rA   )rH   rP   s   & r)   test_unfilteredQuery&RootResolverTests.test_unfilteredQueryu   s     //%(gw/"-OO((;A2NOP	
 	**B/++R0r+   c                "   \        VR7      pVP                  V3VP                  V3VP                  V33 FO  w  rgTP	                  V UU	u. uF,  w  r\        WP                  \        V	R\        4      V	R7      NK.  	  up	p4       KQ  	  V# u up	pi )aK  
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"   )	r   r?   r@   rA   extendr   TYPEgetattrr   )
rH   r?   r@   rA   r^   rQ   sectiondatanamerecords
   &&&&&     r)   _respondRootResolverTests._respond   s     'w'+  *-
MG
 NN
 +/	 +/ kk767B+GQW +/	
 s   2Bc                @   a a R.p\        W24      pV V3R lpWTn        V# )ah  
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.
r6   c                   < \        R V P                   RV: 24       V FP  p SV,          pYPP                  P                  T P                  3,          p\	        SP
                  ! R/ TB 4      u # 	  R#   \         d     Kd  i ; i)zQuery for QNAME z at N )r   re   KeyErrortyper   rg   )	queryserverAddressestimeoutrI   addrserverrecordsrH   serverResponsess	   &&&&   r)   rn   -RootResolverTests._getResolver.<locals>.query   s}    "5::,d?2EFG',T2F !%**!<=t}}7w788 (   s   	A66BB)r   r8   )rH   rt   maximumQueriesrootsrJ   rn   s   ff&   r)   _getResolverRootResolverTests._getResolver   s'     E2	9  r+   c           	     ,   RR\         3RR\        R4      3.RR\        R4      3.//R	R\         3RR\        R4      3.///pV P                  V4      pVP	                  R4      pVP                  \        4       VP                  V P                  R4       V# )
z
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.
r4   r@      ns1.example.comrA   34.55.89.144r?   10.0.0.1r6   5   )r|   r   r   r   r   rx   lookupAddressrB   r/   r=   rH   serversrJ   rK   s   &   r)   test_lookupAddress$RootResolverTests.test_lookupAddress   s     #Q'#5yAS7T"U!V $68P#Q"R* !#Q'!3Xj5I JK*#
 $$W-""#56	m$	d&&
3r+   c                t   \        R4      p\        Vn        R	R\        3RRV3.RR\	        R4      3.RR\        R4      3.//R
R\        3RR\        R4      3.///pV P                  V4      pVP                  R4      pVP                  \        4       VP                  V P                  \        R4      4       V# )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.
r}   r4   r?   r@   r{   rA   10.0.0.210.0.0.3r~   r   r   )
r   r   r_   r   r   rx   r   rB   r*   r=   )rH   badClassr   rJ   rK   s   &    r)   test_lookupChecksClass(RootResolverTests.test_lookupChecksClass   s     J'#Q'!3X >?#5yAS7T"U!V $68L#M"N* #Q'!3Xj5I JK*
 $$W-""#56	m$	d&&(<=r+   c           	     <   RR\         3RR\        R4      3./R\         3RR\        R4      3.//RR\         3RR\        R4      3.///pV P                  V4      pVP	                  R4      pVP                  \        4       VP                  V P                  R4       V# )	z~
If an intermediate response includes no glue records for the
authorities, separate queries are made to find those addresses.
r4   r@   s   ns1.example.orgr?   r}   r   r~   )r}   r   r   r   s   &   r)   test_missingGlue"RootResolverTests.test_missingGlue   s     #Q'#5yAS7T"U!V* $Q'!3Xj5I JK* #Q'!3Xj5I JK*
  $$W-""#56	m$	d&&
3r+   c                    RR\         3R\        ///pV P                  V4      pVP                  R4      pV P	                  V\
        4      # )zi
If a name is missing, L{Resolver.lookupAddress} returns a L{Deferred}
which fails with L{DNSNameError}.
r4   r^   r~   )r   r   rx   r   assertFailurer   r   s   &   r)   test_missingName"RootResolverTests.test_missingName  s[     #Q'U*
 $$W-""#56!!!\22r+   c                    RR\         3/ //pV P                  V4      pVP                  R4      pV P                  V\        4      # )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}.
   example.comr~   )r   rx   r   r   r   r   s   &   r)   test_answerless!RootResolverTests.test_answerless  sR     #R

 $$W-"">2!!!]33r+   c                    RR\         3RR\        R4      3./R\         3R\        ///pV P                  V4      pVP	                  R4      pV P                  V\        4      # )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@   r{   r^   r~   )r   r   r   rx   r   r   r   r   s   &   r)   test_delegationLookupError,RootResolverTests.test_delegationLookupError.  s|     #>9=O3P"Q!R& $Q'U*		
 $$W-"">2!!!\22r+   c                    RR\         3RR\        R4      3./R\         3/ //pV P                  V4      pVP                  R4      pV P	                  V\
        4      # )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@   r{   r~   )r   r   rx   r   r   r   r   s   &   r)   test_delegationLookupEmpty,RootResolverTests.test_delegationLookupEmptyB  st     #>9=O3P"Q!R& $Q'	
 $$W-"">2!!!]33r+   c           	        RR\         3R\        /R\        3RR\        R4      3.///pV P	                  V4      pVP                  R4      pR pVP                  V4       VP                  V P                  \        R4      4       V# )z
L{Resolver.lookupNameservers} is like L{Resolver.lookupAddress}, except
it queries for I{NS} records instead of I{A} records.
r   r^   r?   r{   c                 F    V w  rpV^ ,          P                   P                  #     )r#   re   r$   s   &   r)   
getOneName<RootResolverTests.test_lookupNameservers.<locals>.getOneNamef  s    $NCsq6>>&&&r+   r~   )	r   r   r   r   rx   lookupNameserversrB   r=   r   )rH   r   rJ   rK   r   s   &    r)   test_lookupNameservers(RootResolverTests.test_lookupNameserversT  s     #U&  $;M1N OP'		
 $$W-&&~6	' 	
j!	d&&-?(@Ar+   c                Z   RR\         3RR\        R4      3R\        R4      3.///pV P                  V4      pVP	                  R4      pVP                  R 4       VP                  V P                  \        R\        \        R4      R7      \        R\         \        R4      R7      .4       V# )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?      example.netz10.0.0.7c                     V ^ ,          # r   rk   r.   s   &r)   <lambda><RootResolverTests.test_returnCanonicalName.<locals>.<lambda>      gajr+   r"   r~   	r   r   r   rx   r   rB   r=   r   r   r   s   &   r)   test_returnCanonicalName*RootResolverTests.test_returnCanonicalNamen  s     #'n)EF'*)=> &	
 $$W-"">2	01	^8TUHZ4HI	
 r+   c                n   RR\         3RR\        R4      3./R\         3RR\        R4      3.///pV P                  V4      pVP	                  R4      pVP                  R 4       VP                  V P                  \        R\        \        R4      R7      \        R\         \        R4      R7      .4       V# )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?   r   z10.0.0.5c                     V ^ ,          # r   rk   r.   s   &r)   r   <RootResolverTests.test_followCanonicalName.<locals>.<lambda>  r   r+   r"   r~   r   r   s   &   r)   test_followCanonicalName*RootResolverTests.test_followCanonicalName  s     #n1M NO&  #*1E FG&		
 $$W-"">2	01	^8TUHZ4HI	
 r+   c                    RR\         3RR\        R4      3R\        R4      3.///pV P                  V4      pVP                  R4      pV P	                  V\
        4      # )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?   r   r~   )r   r   rx   r   r   r   r   s   &   r)   test_detectCanonicalNameLoop.RootResolverTests.test_detectCanonicalNameLoop  sw     #'n)EF'n)EF &	
 $$W-"">2!!!]33r+   c                   R
R\         3RR\        R4      3./R\         3RR\        R4      3.//RR\         3RR\        R4      3.RR\        R4      3.//RR\         3RR\        R	4      3.///pV P                  V^4      pV P	                  VP                  R4      \        4      pV P                  V^4      pVP                  R4      pVP                  \        4       VP                  V P                  \        R	4      4       \        W5.4      # )zt
L{Resolver.lookupAddress} won't issue more queries following
delegations than the limit passed to its initializer.
r   r@   r{   r?   r   s   ns2.example.comrA   r   z10.0.0.4r~   r   )r   r   )r   r   r   rx   r   r   r   rB   r*   r=   r   )rH   r   failerfailD	succeedersucceedDs   &     r)   test_boundedQueries%RootResolverTests.test_boundedQueries  sJ      #>9=O3P"Q!R&
 $Q'!3Xj5I JK*   #>9=O3P"Q!R $68L#M"N&	 #*1E FG&-
B ""7A.""6#7#7#GW%%gq1	**>:]+T--x
/CDe.//r+   rk   N)
   )__name__
__module____qualname____firstlineno____doc__rR   rW   r[   r   rg   rx   r   r   r   r   r   r   r   r   r   r   r   r   __static_attributes____classdictcell____classdict__s   @r)   r1   r1   7   sp     )V)1   "RBb >44863 43(4$4684(.0 .0r+   r1   c                   *   a  ] tR tRt o RtR tRtV tR# )ResolverFactoryArgumentsi  zZ
Raised by L{raisingResolverFactory} with the *args and **kwargs passed to
that function.
c                    Wn         W n        R# )zy
Store the supplied args and kwargs as attributes.

@param args: Positional arguments.
@param kwargs: Keyword arguments.
Nargskwargs)rH   r   r   s   &&&r)   __init__!ResolverFactoryArguments.__init__  s     	r+   r   N)r   r   r   r   r   r   r   r   r   s   @r)   r   r     s     
 r+   r   c                     \        W4      h)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                   6   a  ] tR tRt o RtR tR tR tRtV t	R# ) RootResolverResolverFactoryTestsi	  z.
Tests for L{root.Resolver._resolverFactory}.
c                j    \        R.\        R7      pV P                  VP                  \        4       R# )zm
L{root.Resolver.__init__} accepts a C{resolverFactory}
argument and assigns it to C{self._resolverFactory}.
N)hintsresolverFactory)r   r   assertIs_resolverFactoryrH   rs   & r)   #test_resolverFactoryArgumentPresentDRootResolverResolverFactoryTests.test_resolverFactoryArgumentPresent  s(    
 D63IJa((*@Ar+   c                t    \        R.R7      pV P                  VP                  \        P                   4       R# )z
L{root.Resolver.__init__} sets L{client.Resolver} as the
C{_resolverFactory} if a C{resolverFactory} argument is not
supplied.
N)r   )r   r   r   r	   r   s   & r)   "test_resolverFactoryArgumentAbsentCRootResolverResolverFactoryTests.test_resolverFactoryArgumentAbsent  s(     D6"a((&//:r+   c                    \        4       p\        R.\        VR7      pV P                  \        VP
                  R4      pV P                  RRVRR./3VP                  VP                  34       R# )	za
L{root.Resolver._resolverFactory} is supplied with C{reactor} and
C{servers} keyword arguments.
192.0.2.101)r   r   r3   zexample.comr3   r   Nrk   )r   r   )	objectr   r   assertRaisesr   r   r=   r   r   )rH   dummyReactorr   es   &   r)   )test_resolverFactoryOnlyExpectedArgumentsJRootResolverResolverFactoryTests.test_resolverFactoryOnlyExpectedArguments  sn    
 x /2 
 6W)\97J6KLMVVQXX	
r+   rk   N)
r   r   r   r   r   r   r   r   r   r   r   s   @r)   r   r   	  s     B;
 
r+   r   c                   0   a  ] tR tRt o RtR tR tRtV tR# )StubResolveriD  z
An L{IResolverSimple} implementer which traces all getHostByName
calls and their deferred results. The deferred results can be
accessed and fired synchronously.
c                "    . V n         . V n        R# )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)rH   s   &r)   r   StubResolver.__init__L  s     
 r+   c                    V P                   P                  W34       \        4       pV P                  P                  V4       V# )a,  
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   rC   r   r   )rH   r   r   rK   s   &*, r)   getHostByNameStubResolver.getHostByNameV  s8     	

4.)J""1%r+   r   N)	r   r   r   r   r   r   r   r   r   r   s   @r)   r   r   D  s     ! r+   r   c                   N   a  ] tR tRt o RtR tR tR tR tR t	R t
R	 tR
tV tR# )BootstrapTestsil  z
Tests for L{root.bootstrap}
c                    \         P                  ! \        4       4      pV P                  V\         P                  4       R# )zT
L{root.bootstrap} returns an object which is initially a
L{root.DeferredResolver}.
N)r
   	bootstrapr   rZ   DeferredResolver)rH   deferredResolvers   & r)   test_returnsDeferredResolver+BootstrapTests.test_returnsDeferredResolverq  s,    
  >>,.9.0E0EFr+   c                    \        4       p\        P                  ! V4       T P                  VP                  \
         Uu. uF  q"3/ 3NK	  	  up4       R# u upi )zv
The L{IResolverSimple} supplied to L{root.bootstrap} is used to lookup
the IP addresses of the 13 root name servers.
N)r   r
   r   r=   r   ROOT_SERVERS)rH   stubResolverss   &  r)   test_resolves13RootServers)BootstrapTests.test_resolves13RootServersy  sC    
 $~|$++,-O,QtRj,-OP-Os   A
c                    \        4       p\        P                  ! V4      pVP                   F  pVP	                  R4       K  	  V P                  V\        4       R# )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   r
   r   r   callbackrZ   r   rH   r   r   rK   s   &   r)   test_becomesResolver#BootstrapTests.test_becomesResolver  sG     $~>>,7,,AJJ}% -.9r+   c                    \        4       p\        P                  ! V4      pVP                   F  pVP	                  R4       K  	  V P                  VP                  R.^,          4       R# )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   r
   r   r   r  r=   r   r  s   &   r)   test_resolverReceivesRootHints-BootstrapTests.test_resolverReceivesRootHints  sT    
 $~>>,7,,AJJ}% -)//-21EFr+   c                   a a \        4       p\        P                  ! V4      o\        VP                  4      p\        V4      pV F  pVP                  R4       K  	  VP                  \        4       4       VV 3R lpVP                  V4       R# )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                 P   < SP                  SP                  R .^,          4       R# )r   Nr=   r   resr   rH   s   &r)   
checkHintsFBootstrapTests.test_continuesWhenSomeRootHintsFail.<locals>.checkHints  s!    -33m_r5IJr+   N)
r   r
   r   iterr   nextr  errbackr   addBothrH   r   r%   d1rK   r  r   s   f     @r)   #test_continuesWhenSomeRootHintsFail2BootstrapTests.test_continuesWhenSomeRootHintsFail  sl     $~>>,7|223']AJJ}% 


<>"	K 	

:r+   c                p  a a \        4       p\        P                  ! V4      o\        VP                  4      p\        V4      pV F  pVP                  \        4       4       K  	  VP                  \        4       4       VV 3R lpVP                  V4       S P                  S P                  \        4       R# )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                 @   < SP                  SP                  . 4       R # Nr  r  s   &r)   r  EBootstrapTests.test_continuesWhenAllRootHintsFail.<locals>.checkHints  s    -33R8r+   N)r   r
   r   r  r   r  r  r   r  
addCleanupflushLoggedErrorsr  s   f     @r)   "test_continuesWhenAllRootHintsFail1BootstrapTests.test_continuesWhenAllRootHintsFail  s     $~>>,7|223']AIIln% 


<>"	9 	

:..=r+   c                    \        4       p\        P                  ! V\        R7      pVP                   F  pVP                  R4       K  	  V P                  VP                  \        4       R# )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   r
   r   r   r   r  r   r   r  s   &   r)   test_passesResolverFactory)BootstrapTests.test_passesResolverFactory  sV     $~>>*@
 ,,AJJ}% - 	&779OPr+   rk   N)r   r   r   r   r   r   r   r  r  r  r  r!  r   r   r   s   @r)   r   r   l  s7     GQ
:	G&>*Q Qr+   r   c                   *   a  ] tR tRt o RtR tRtV tR# )StubDNSDatagramProtocoli  z
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                    \        4       # r  )r   )rH   akws   &*,r)   rn   StubDNSDatagramProtocol.query  s
    zr+   rk   N)r   r   r   r   r   rn   r   r   r   s   @r)   r$  r$    s     
 r+   r$  zbtwisted.names.root.retry is deprecated since Twisted 10.0.  Use a Resolver object for retry logic.)categoryrP   N)za.root-servers.netzb.root-servers.netzc.root-servers.netzd.root-servers.netze.root-servers.netzf.root-servers.netzg.root-servers.netzh.root-servers.netzi.root-servers.netzj.root-servers.netzk.root-servers.netzl.root-servers.netzm.root-servers.net):r   zope.interfacer   zope.interface.verifyr   twisted.internet.deferr   r   r   r   twisted.internet.interfacesr   twisted.namesr	   r
   twisted.names.dnsr   r   r   r   r   r   r   r   r   r   r   r   r   r   twisted.names.errorr   r   twisted.names.rootr   twisted.names.test.test_utilr   twisted.python.logr   twisted.trialr   twisted.trial.unittestr   r    r*   r/   r1   	Exceptionr   r   r   r   r   r   r$  suppressDeprecationWarning_retrySuppressionrk   r+   r)   <module>r:     s    ' - Q Q 7 &     < ' 6 "  @/p0 p0fy "1'
x '
T" _! ! !H O\ *cQ( cQL  MM	+ r+   