403Webshell
Server IP : 167.99.254.82  /  Your IP : 216.73.216.188
Web Server : Apache
System : Linux host.techisquad.com 5.15.0-190-generic #200-Ubuntu SMP Fri Aug 7 15:06:04 UTC 2026 x86_64
User : pawluxera ( 1011)
PHP Version : 8.1.34
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/twisted/internet/test/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :

[ Back ]     

Current File : /lib/python3/dist-packages/twisted/internet/test/__pycache__/test_resolver.cpython-310.pyc
o

�b�L�@s�dZddlmZddlmZmZmZmZmZm	Z	m
Z
mZmZddl
mZmZddlmZddlmZddlmZmZmZddlmZmZmZdd	lmZmZdd
lm Z m!Z!ddl"m#Z#ddl$m%Z%dd
l&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,ddl-m.Z/Gdd�de,�Z0dd�Z1dd�Z2Gdd�d�Z3ee)�Gdd�d��Z4Gdd�de/�Z5Gdd�de/�Z6ee*�Gdd�d��Z7Gd d!�d!e/�Z8Gd"d#�d#e!�Z9Gd$d%�d%e/�Z:d&S)'zh
Tests for implementations of L{IHostnameResolver} and their interactions with
reactor implementations.
�)�defaultdict)	�AF_INET�AF_INET6�	AF_UNSPEC�
EAI_NONAME�IPPROTO_TCP�
SOCK_DGRAM�SOCK_STREAM�gaierror�getaddrinfo)�Lock�local)�implementer)�verifyObject)�
LockWorker�Team�createMemoryWorker)�ComplexResolverSimplifier�GAIResolver�SimpleResolverComplexifier)�IPv4Address�IPv6Address)�PluggableResolverMixin�ReactorBase)�Deferred)�DNSLookupError)�IHostnameResolver�IReactorPluggableNameResolver�IResolutionReceiver�IResolverSimple)�
ThreadPool)�SynchronousTestCasec@�eZdZdZdd�ZdS)�DeterministicThreadPoolz6
    Create a deterministic L{ThreadPool} object.
    cCs"d|_d|_d|_g|_||_dS)zE
        Create a L{DeterministicThreadPool} from a L{Team}.
        �N)�min�max�name�threads�_team)�self�team�r,�E/usr/lib/python3/dist-packages/twisted/internet/test/test_resolver.py�__init__4s

z DeterministicThreadPool.__init__N)�__name__�
__module__�__qualname__�__doc__r.r,r,r,r-r#/�r#cs4t�\�}tttt�t���fdd�dd���|fS)z�
    Create a deterministic threadpool.

    @return: 2-tuple of L{ThreadPool}, 0-argument C{work} callable; when
        C{work} is called, do the work.
    cs�S�Nr,r,��workerr,r-�<lambda>I�z#deterministicPool.<locals>.<lambda>cSsdSr4r,r,r,r,r-r7Ir8)rr#rrrr
)�doerr,r5r-�deterministicPool?s
 ��r:cs&t�\�}G�fdd�d�}|�|fS)z�
    Create a deterministic L{IReactorThreads}

    @return: a 2-tuple consisting of an L{IReactorThreads}-like object and a
        0-argument callable that will perform one unit of work invoked via that
        object's C{callFromThread} method.
    cseZdZ�fdd�ZdS)z(deterministicReactorThreads.<locals>.CFTcs�����fdd��dS)Ncs��i���Sr4r,r,��a�f�kr,r-r7[szIdeterministicReactorThreads.<locals>.CFT.callFromThread.<locals>.<lambda>)�do)r*r=r<r>r5r;r-�callFromThreadZsz7deterministicReactorThreads.<locals>.CFT.callFromThreadN)r/r0r1r@r,r5r,r-�CFTYsrA)r)r9rAr,r5r-�deterministicReactorThreadsOs

rBc@s4eZdZdZdd�Zddd�Zeeedfdd	�Z	d
S)�FakeAddrInfoGetterz/
    Test object implementing getaddrinfo.
    cCsg|_tt�|_dS)z1
        Create a L{FakeAddrInfoGetter}.
        N)�callsr�list�results�r*r,r,r-r.eszFakeAddrInfoGetter.__init__rcCs4|j�||||||f�|j|}|r|Sttd��)a�
        Mock for L{socket.getaddrinfo}.

        @param host: see L{socket.getaddrinfo}

        @param port: see L{socket.getaddrinfo}

        @param family: see L{socket.getaddrinfo}

        @param socktype: see L{socket.getaddrinfo}

        @param proto: see L{socket.getaddrinfo}

        @param flags: see L{socket.getaddrinfo}

        @return: L{socket.getaddrinfo}
        z,nodename nor servname provided, or not known)rD�appendrFr
r)r*�host�port�family�socktype�proto�flagsrFr,r,r-rls


zFakeAddrInfoGetter.getaddrinfo�cCs|j|�|||||f�dS)a�
        Add a result for a given hostname.  When this hostname is resolved, the
        result will be a L{list} of all results C{addResultForHost} has been
        called with using that hostname so far.

        @param host: The hostname to give this result for.  This will be the
            next result from L{FakeAddrInfoGetter.getaddrinfo} when passed this
            host.

        @type canonname: native L{str}

        @param sockaddr: The resulting socket address; should be a 2-tuple for
            IPv4 or a 4-tuple for IPv6.

        @param family: An C{AF_*} constant that will be returned from
            C{getaddrinfo}.

        @param socktype: A C{SOCK_*} constant that will be returned from
            C{getaddrinfo}.

        @param proto: An C{IPPROTO_*} constant that will be returned from
            C{getaddrinfo}.

        @param canonname: A canonical name that will be returned from
            C{getaddrinfo}.
        @type canonname: native L{str}
        N)rFrH)r*rI�sockaddrrKrLrM�	canonnamer,r,r-�addResultForHost�s$z#FakeAddrInfoGetter.addResultForHostN)rrrr)
r/r0r1r2r.rrr	rrRr,r,r,r-rC`s
�rCc@s8eZdZdZdZdZdd�Zdd�Zdd�Zd	d
�Z	dS)�ResultHolderzI
    A resolution receiver which holds onto the results it received.
    FcCs
||_dS)z>
        Create a L{ResultHolder} with a L{UnitTest}.
        N)�	_testCase)r*�testCaser,r,r-r.��
zResultHolder.__init__cCsd|_||_g|_dS)zg
        Hostname resolution began.

        @param hostResolution: see L{IResolutionReceiver}
        TN)�_started�_resolution�
_addresses)r*�hostResolutionr,r,r-�resolutionBegan�s
zResultHolder.resolutionBegancCs|j�|�dS)z^
        An address was resolved.

        @param address: see L{IResolutionReceiver}
        N)rYrH)r*�addressr,r,r-�addressResolved�szResultHolder.addressResolvedcCs
d|_dS)z2
        Hostname resolution is complete.
        TN)�_endedrGr,r,r-�resolutionComplete�rVzResultHolder.resolutionCompleteN)
r/r0r1r2rWr^r.r[r]r_r,r,r,r-rS�s
rSc@r")�HelperTestsz?
    Tests for error cases of helpers used in this module.
    cCsDt�\|_|_dd�}|j�|�|��|�t|�t��d�dS)zq
        L{DeterministicThreadPool} will log any exceptions that its "thread"
        workers encounter.
        cSsddS)Nr$rr,r,r,r,r-�divideByZero�sz9HelperTests.test_logErrorsInThreads.<locals>.divideByZeror$N)r:�pool�doThreadWork�callInThread�assertEqual�len�flushLoggedErrors�ZeroDivisionError)r*rar,r,r-�test_logErrorsInThreads�s
z#HelperTests.test_logErrorsInThreadsN)r/r0r1r2rir,r,r,r-r`�r3r`c@s`eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dS)�HostnameResolutionTestsz(
    Tests for hostname resolution.
    csDt�\�_�_t�\�_�_t��_t�j�fdd��jj	��_
dS)z*
        Set up a L{GAIResolver}.
        c��jSr4�rbr,rGr,r-r7��z/HostnameResolutionTests.setUp.<locals>.<lambda>N)r:rbrcrB�reactor�
doReactorWorkrC�getterrr�resolverrGr,rGr-�setUp�s
�zHostnameResolutionTests.setUpcCs�t|�}|j�dd�|j�|d�}|�|j|�|�|jd�|�|j	d�|�
�|��|�|j	d�|�|jt
ddd�g�dS)	z�
        Resolving an individual hostname that results in one address from
        getaddrinfo results in a single call each to C{resolutionBegan},
        C{addressResolved}, and C{resolutionComplete}.
        �sample.example.com)�4.3.2.1rTF�TCPrtrN)rSrprRrq�resolveHostName�assertIsrXrerWr^rcrorYr�r*�receiver�
resolutionr,r,r-�test_resolveOneHost�sz+HostnameResolutionTests.test_resolveOneHostc	Cs�t|�}d}d}|jjddd||ftd�|j�|d�}|�|j|�|�|j	d�|�|j
d�|��|��|�|j
d�|�|j
td	dd||�g�d
S)a
        Resolving an individual hostname that results in one address from
        getaddrinfo results in a single call each to C{resolutionBegan},
        C{addressResolved}, and C{resolutionComplete}; C{addressResolved} will
        receive an L{IPv6Address}.
        r$�rs�::1r)rKTFruN)rSrprRrrqrvrwrXrerWr^rcrorYr)r*ry�flowInfo�scopeIDrzr,r,r-�test_resolveOneIPv6Host	s ��z/HostnameResolutionTests.test_resolveOneIPv6HostcCsbt|�}|j�|d�}|�|j|�|��|��|�|jd�|�|j	d�|�|j
g�dS)a

        Resolving a hostname that results in C{getaddrinfo} raising a
        L{gaierror} will result in the L{IResolutionReceiver} receiving a call
        to C{resolutionComplete} with no C{addressResolved} calls in between;
        no failure is logged.
        rsTN)rSrqrvrwrXrcrorerWr^rYrxr,r,r-�
test_gaierror!sz%HostnameResolutionTests.test_gaierrorcCs`t|�}|jj|d|d�}|�|j|�|��|��|jjd\}}}}}	}
|�	||�dS)z�
        Verify that the given set of address types results in the given C{AF_}
        constant being passed to C{getaddrinfo}.

        @param addrTypes: iterable of L{IAddress} implementers

        @param expectedAF: an C{AF_*} constant
        rs)�addressTypesrN)
rSrqrvrwrXrcrorprDre)r*�	addrTypes�
expectedAFryrzrIrJrKrLrMrNr,r,r-�_resolveOnlyTest1s	�z(HostnameResolutionTests._resolveOnlyTestcC�|�tgt�dS)z�
        When passed an C{addressTypes} parameter containing only
        L{IPv4Address}, L{GAIResolver} will pass C{AF_INET} to C{getaddrinfo}.
        N)r�rrrGr,r,r-�test_resolveOnlyIPv4D�z,HostnameResolutionTests.test_resolveOnlyIPv4cCr�)z�
        When passed an C{addressTypes} parameter containing only
        L{IPv6Address}, L{GAIResolver} will pass C{AF_INET6} to C{getaddrinfo}.
        N)r�rrrGr,r,r-�test_resolveOnlyIPv6Kr�z,HostnameResolutionTests.test_resolveOnlyIPv6cCs |�ttgt�|�dt�dS)z�
        When passed an C{addressTypes} parameter containing both L{IPv4Address}
        and L{IPv6Address} (or the default of C{None}, which carries the same
        meaning), L{GAIResolver} will pass C{AF_UNSPEC} to C{getaddrinfo}.
        N)r�rrrrGr,r,r-�test_resolveBothRsz(HostnameResolutionTests.test_resolveBothc
Cs�t|�}|jj|ddd�t|�}|jj|ddd�|��|��|��|��|jjd\}}}}}}|jjd\}}}}	}}|�|t�|�|	t	�dS)z�
        When passed a C{transportSemantics} paramter, C{'TCP'} (the value
        present in L{IPv4Address.type} to indicate a stream transport) maps to
        C{SOCK_STREAM} and C{'UDP'} maps to C{SOCK_DGRAM}.
        �example.comru)�transportSemantics�UDPrr$N)
rSrqrvrcrorprDrer	r)
r*ry�	receiver2rIrJrK�	socktypeTrMrN�	socktypeUr,r,r-�#test_transportSemanticsToSocketType[s�z;HostnameResolutionTests.test_transportSemanticsToSocketTypec	Cs�t|�}d}d}ttfD]}|jjddd||ft|d�|jjddt|d�q|j�|d�|�	�|�
�|j\}}}}|�|j
d�|�|j
d�|�|j
d	�|�|j
d	�d
S)z�
        When L{GAIResolver} receives a C{SOCK_DGRAM} result from
        C{getaddrinfo}, it returns a C{'TCP'} L{IPv4Address} or L{IPv6Address};
        if it receives C{SOCK_STREAM} then it returns a C{'UDP'} type of same.
        r$r|r�r}r)rKrL)z	127.0.0.3rrur�N)rSr	rrprRrrrqrvrcrorYre�type)	r*ryr~rrL�stream4�stream6�dgram4�dgram6r,r,r-�test_socketTypeToAddressTypeps*
��z4HostnameResolutionTests.test_socketTypeToAddressTypeN)r/r0r1r2rrr{r�r�r�r�r�r�r�r�r,r,r,r-rj�s	rjc@s"eZdZdZdd�Zddd�ZdS)	�SillyResolverSimplez6
    Trivial implementation of L{IResolverSimple}
    cCs
g|_dS)zd
        Create a L{SillyResolverSimple} with a queue of requests it is working
        on.
        N)�	_requestsrGr,r,r-r.�s
zSillyResolverSimple.__init__r,cCs|j�t��|jdS)z�
        Implement L{IResolverSimple.getHostByName}.

        @param name: see L{IResolverSimple.getHostByName}.

        @param timeout: see L{IResolverSimple.getHostByName}.

        @return: see L{IResolverSimple.getHostByName}.
        ���)r�rHr)r*r'�timeoutr,r,r-�
getHostByName�s

z!SillyResolverSimple.getHostByNameN)r,)r/r0r1r2r.r�r,r,r,r-r��sr�c@s8eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�ZdS)
�LegacyCompatibilityTestsz�
    Older applications may supply an object to the reactor via
    C{installResolver} that only provides L{IResolverSimple}.
    L{SimpleResolverComplexifier} is a wrapper for an L{IResolverSimple}.
    cCs�t�}t|�}t|�}|�|jd�|�|d�|�|jd�|�|jd�|�|jg�|jd�	d�|�|jt
ddd�g�|�|jd�dS)z�
        L{SimpleResolverComplexifier} translates C{resolveHostName} into
        L{IResolutionReceiver.addressResolved}.
        Fr�Tr�192.168.1.1ruN)r�rrSrerWrvr^rYr��callbackr�r*�simple�complexryr,r,r-�test_success�sz%LegacyCompatibilityTests.test_successcCs�t�}t|�}t|�}|�|jd�|�|d�|�|jd�|�|jd�|�|jg�|jd�	t
d��|�|jd�|�|jg�dS)z�
        L{SimpleResolverComplexifier} translates a known error result from
        L{IResolverSimple.resolveHostName} into an empty result.
        Fr�Tr�nopeN)r�rrSrerWrvr^rYr��errbackrr�r,r,r-�test_failure�sz%LegacyCompatibilityTests.test_failurecCs�t�}t|�}t|�}|�|jd�|�|d�|�|jd�|�|jd�|�|jg�|jd�	t
d��|�t|�t
��d�|�|jd�|�|jg�dS)z�
        L{SimpleResolverComplexifier} translates an unknown error result from
        L{IResolverSimple.resolveHostName} into an empty result and a logged
        error.
        Fr�Tr�zowr$N)
r�rrSrerWrvr^rYr�r�rhrfrgr�r,r,r-�
test_error�sz#LegacyCompatibilityTests.test_errorcs�t�\�_�_t�\�_�_t��_t�j�fdd��jj	��_
t�j
�}�j�dd�|�
d�}|�
d�}����������������|�jt�����|�d�dS)z�
        L{ComplexResolverSimplifier} translates an L{IHostnameResolver} into an
        L{IResolverSimple} for applications that still expect the old
        interfaces to be in place.
        crkr4rlr,rGr,r-r7�rmz:LegacyCompatibilityTests.test_simplifier.<locals>.<lambda>r�)�192.168.3.4��znx.example.comr�N)r:rbrcrBrnrorCrprrrqrrRr�re�failureResultOfr�r�successResultOf)r*�simpleResolver�success�failurer,rGr-�test_simplifier�s �


z(LegacyCompatibilityTests.test_simplifiercCs�t�}t|�}t|�}|�|dd�|�|jd�|�|jd�|�|jg�|jd�	d�|�|jt
ddd�g�|�|jd�dS)	z�
        L{SimpleResolverComplexifier} preserves the C{port} argument passed to
        C{resolveHostName} in its returned addresses.
        r�r�TFrr�ruN)r�rrSrvrerWr^rYr�r�rr�r,r,r-�test_portNumber�sz(LegacyCompatibilityTests.test_portNumberN)	r/r0r1r2r�r�r�r�r�r,r,r,r-r��sr�c@r")�JustEnoughReactorzT
    Just enough subclass implementation to be a valid L{ReactorBase} subclass.
    cCsdS)z
        Do nothing.
        Nr,rGr,r,r-�installWakerr8zJustEnoughReactor.installWakerN)r/r0r1r2r�r,r,r,r-r�r3r�c@s(eZdZdZdd�Zdd�Zdd�ZdS)	�ReactorInstallationTestsz�
    Tests for installing old and new resolvers onto a
    L{PluggableResolverMixin} and L{ReactorBase} (from which all of Twisted's
    reactor implementations derive).
    cCs,t�}tt|�tt|j�tt|j�dS)z�
        L{PluggableResolverMixin} (and its subclasses) implement both
        L{IReactorPluggableNameResolver} and L{IReactorPluggableResolver}.
        N)rrrrrqr�nameResolver�r*rnr,r,r-�test_interfaceCompliances
z1ReactorInstallationTests.test_interfaceCompliancecCs>t�}t�}tt|�|��|�|jt�|�|jj	|�dS)zf
        L{PluggableResolverMixin} will wrap an L{IResolverSimple} in a
        complexifier.
        N)
rr�rr�installResolver�assertIsInstancer�rrw�_simpleResolver)r*rn�itr,r,r-�test_installingOldStyleResolver(s
z8ReactorInstallationTests.test_installingOldStyleResolvercCsXt�}|�|jt�|�|jjt�|�|jt�|�|jj	|�|�|jj
|j�dS)zD
        L{ReactorBase} defaults to using a L{GAIResolver}.
        N)r�r�r�rrw�_getaddrinforrqr�_reactor�
_nameResolverr�r,r,r-�test_defaultToGAIResolver3sz2ReactorInstallationTests.test_defaultToGAIResolverN)r/r0r1r2r�r�r�r,r,r,r-r�s

r�N);r2�collectionsr�socketrrrrrrr	r
r�	threadingrr
�zope.interfacer�zope.interface.verifyr�twisted._threadsrrr�twisted.internet._resolverrrr�twisted.internet.addressrr�twisted.internet.baserr�twisted.internet.deferr�twisted.internet.errorr�twisted.internet.interfacesrrrr�twisted.python.threadpoolr �twisted.trial.unittestr!�UnitTestr#r:rBrCrSr`rjr�r�r�r�r,r,r,r-�<module>s:,L'&d

Youez - 2016 - github.com/yon3zu
LinuXploit