
    h                     ^    S r SSKrSSKJr  SSKJr   " S S5      rS rS r " S	 S
\5      r	g)zt
Tests for miscellaneous behaviors of the top-level L{twisted} package (ie, for
the code in C{twisted/__init__.py}.
    N)
ModuleType)TestCasec                   0    \ rS rSrSrS rS rS rS rSr	g)	SetAsideModule   z
L{SetAsideModule} is a context manager for temporarily removing a module
from C{sys.modules}.

@ivar name: The name of the module to remove.
c                     Xl         g N)name)selfr
   s     `/root/1688_scrapy/alibaba-scraper/venv/lib/python3.13/site-packages/twisted/test/test_twisted.py__init__SetAsideModule.__init__   s    	    c                 $   [        [        R                  R                  5       5       VVs0 s H;  u  p#X R                  :X  d%  UR                  U R                  S-   5      (       d  M9  X#_M=     nnnU H  n[        R                  U	 M     U$ s  snnf )z
Find the given module and all of its hierarchically inferior modules in
C{sys.modules}, remove them from it, and return whatever was found.
.)listsysmodulesitemsr
   
startswith)r   r
   
moduleNamemoduler   s        r   	_unimportSetAsideModule._unimport   s     )-S[[->->-@(A
(A$ii':+@+@S+Q J(A 	 

 DD! 
s   8B'Bc                 D    U R                  U R                  5      U l        g r	   )r   r
   r   )r   s    r   	__enter__SetAsideModule.__enter__+   s    ~~dii0r   c                     U R                  U R                  5        [        R                  R	                  U R                  5        g r	   )r   r
   r   r   update)r   excTypeexcValue	tracebacks       r   __exit__SetAsideModule.__exit__.   s(    tyy!4<<(r   )r   r
   N)
__name__
__module____qualname____firstlineno____doc__r   r   r   r#   __static_attributes__ r   r   r   r      s    1)r   r   c                 ^    0 n[        SX5        [        R                  R                  U5        g)a  
Take a mapping defining a package and turn it into real C{ModuleType}
instances in C{sys.modules}.

Consider these example::

    a = {"foo": "bar"}
    b = {"twisted": {"__version__": "42.6"}}
    c = {"twisted": {"plugin": {"getPlugins": stub}}}

C{_install(a)} will place an item into C{sys.modules} with C{"foo"} as the
key and C{"bar" as the value.

C{_install(b)} will place an item into C{sys.modules} with C{"twisted"} as
the key.  The value will be a new module object.  The module will have a
C{"__version__"} attribute with C{"42.6"} as the value.

C{_install(c)} will place an item into C{sys.modules} with C{"twisted"} as
the key.  The value will be a new module object with a C{"plugin"}
attribute.  An item will also be placed into C{sys.modules} with the key
C{"twisted.plugin"} which refers to that module object.  That module will
have an attribute C{"getPlugins"} with a value of C{stub}.

@param modules: A mapping from names to definitions of modules.  The names
    are native strings like C{"twisted"} or C{"unittest"}.  Values may be
    arbitrary objects.  Any value which is not a dictionary will be added to
    C{sys.modules} unmodified.  Any dictionary value indicates the value is
    a new module and its items define the attributes of that module.  The
    definition of this structure is recursive, so a value in the dictionary
    may be a dictionary to trigger another level of processing.

@return: L{None}
N)_makePackagesr   r   r   )r   results     r   _installr/   3   s&    D F$(KKvr   c                    0 n[        UR                  5       5       H  u  pEU cQ  [        U[        5      (       a6  [	        U5      nUR
                  R                  [        XeU5      5        XbU'   MS  XRU'   MY  [        U[        5      (       aZ  [	        U R                  S-   U-   5      nUR
                  R                  [        XeU5      5        XbU R                  S-   U-   '   XcU'   M  XSU'   M     U$ )a  
Construct module objects (for either modules or packages).

@param parent: L{None} or a module object which is the Python package
    containing all of the modules being created by this function call.  Its
    name will be prepended to the name of all created modules.

@param attributes: A mapping giving the attributes of the particular module
    object this call is creating.

@param result: A mapping which is populated with all created module names.
    This is suitable for use in updating C{sys.modules}.

@return: A mapping of all of the attributes created by this call.  This is
    suitable for populating the dictionary of C{parent}.

@see: L{_install}.
r   )	r   r   
isinstancedictr   __dict__r   r-   r%   )parent
attributesr.   attrsr
   valuer   s          r   r-   r-   Z   s    & EJ,,./>%&&#D)&&}VF'KL%t$t%&&#FOOc$9D$@A&&}VF'KL7=v,t34$d#d 0  Lr   c                   *    \ rS rSrSrS rS rS rSrg)MakePackagesTests   z\
Tests for L{_makePackages}, a helper for populating C{sys.modules} with
fictional modules.
c                 b    0 n[        S[        SS9U5        U R                  U[        SS95        g)zy
A non-C{dict} value in the attributes dictionary passed to L{_makePackages}
is preserved unchanged in the return value.
Nreactor)r<   )r-   r2   assertEqualr   r   s     r   test_nonModule MakePackagesTests.test_nonModule   s/    
 dD3W=$y"9:r   c           	         0 n[        S[        [        SS9S9U5        U R                  U[        5        U R                  US   [        5        U R	                  SUS   R
                  5        U R	                  SUS   R                  5        g)z
A C{dict} value in the attributes dictionary passed to L{_makePackages}
is turned into a L{ModuleType} instance with attributes populated from
the items of that C{dict} value.
N123versiontwistedrF   )r-   r2   assertIsInstancer   r=   r%   rD   r>   s     r   test_moduleWithAttribute*MakePackagesTests.test_moduleWithAttribute   sz     dDe)<=wGgt,gi0*=GI$6$?$?@	 2 : :;r   c                    0 n[        S[        [        [        SS9S9S9U5        U R                  U[        5        U R                  US   [        5        U R	                  SUS   R
                  5        U R                  US   R                  [        5        U R	                  SUS   R                  R
                  5        U R	                  SUS   R                  R                  5        g)z
Processing of the attributes dictionary is recursive, so a C{dict} value
it contains may itself contain a C{dict} value to the same effect.
N321rC   )webrE   rF   ztwisted.web)r-   r2   rG   r   r=   r%   rL   rD   r>   s     r   test_packageWithModule(MakePackagesTests.test_packageWithModule   s    
 dD$u2E)FGQgt,gi0*=GI$6$?$?@gi044jA	(:(>(>(G(GH	 2 6 6 > >?r   r+   N)	r%   r&   r'   r(   r)   r?   rH   rM   r*   r+   r   r   r9   r9      s    
;<@r   r9   )
r)   r   typesr   twisted.trial.unittestr   r   r/   r-   r9   r+   r   r   <module>rQ      s:      +
) )B$N$N(@ (@r   