
    Vh                     ^    d Z ddlZddlmZ ddlmZ  G d d      Zd Zd Z G d	 d
e      Z	y)zt
Tests for miscellaneous behaviors of the top-level L{twisted} package (ie, for
the code in C{twisted/__init__.py}.
    N)
ModuleType)TestCasec                   (    e Zd ZdZd Zd Zd Zd Zy)SetAsideModulez
    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                     || _         y N)name)selfr	   s     I/home/dcms/DCMS/lib/python3.12/site-packages/twisted/test/test_twisted.py__init__zSetAsideModule.__init__   s	    	    c                    t        t        j                  j                               D ci c]5  \  }}|| j                  k(  s|j                  | j                  dz         r||7 }}}|D ]  }t        j                  |=  |S c c}}w )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   	_unimportzSetAsideModule._unimport   s     )-S[[->->-@(A
$Vdii':+@+@S+Q 
 

  	"DD!	"
s   :Bc                 D    | j                  | j                        | _        y r   )r   r	   r   )r
   s    r   	__enter__zSetAsideModule.__enter__+   s    ~~dii0r   c                     | j                  | j                         t        j                  j	                  | j                         y r   )r   r	   r   r   update)r
   excTypeexcValue	tracebacks       r   __exit__zSetAsideModule.__exit__.   s(    tyy!4<<(r   N)__name__
__module____qualname____doc__r   r   r   r    r   r   r   r      s    1)r   r   c                 `    i }t        d| |       t        j                  j                  |       y)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                    i }t        |j                               D ]  \  }}| Mt        |t              r7t	        |      }|j
                  j                  t        |||             |||<   O|||<   Ut        |t              r\t	        | j                  dz   |z         }|j
                  j                  t        |||             ||| j                  dz   |z   <   |||<   |||<    |S )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,,./ $e>%&#D)&&}VUF'KL%t$t%&#FOOc$9D$@A&&}VUF'KL7=v,t34$d#d$  Lr   c                   "    e Zd ZdZd Zd Zd Zy)MakePackagesTestszh
    Tests for L{_makePackages}, a helper for populating C{sys.modules} with
    fictional modules.
    c                 n    i }t        dt        d      |       | j                  |t        d             y)z
        A non-C{dict} value in the attributes dictionary passed to L{_makePackages}
        is preserved unchanged in the return value.
        Nreactor)r4   )r&   r+   assertEqualr
   r   s     r   test_nonModulez MakePackagesTests.test_nonModule   s/    
 dD3W=$y"9:r   c                 $   i }t        dt        t        d            |       | j                  |t               | j                  |d   t               | j	                  d|d   j
                         | j	                  d|d   j                         y)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twistedr=   )r&   r+   assertIsInstancer   r5   r    r;   r6   s     r   test_moduleWithAttributez*MakePackagesTests.test_moduleWithAttribute   sz     dDe)<=wGgt,gi0*=GI$6$?$?@	 2 : :;r   c           
         i }t        dt        t        t        d                  |       | j                  |t               | j                  |d   t               | j	                  d|d   j
                         | j                  |d   j                  t               | j	                  d|d   j                  j
                         | j	                  d|d   j                  j                         y)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321r:   )webr<   r=   ztwisted.web)r&   r+   r>   r   r5   r    rB   r;   r6   s     r   test_packageWithModulez(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   N)r    r!   r"   r#   r7   r?   rC   r$   r   r   r2   r2      s    
;<@r   r2   )
r#   r   typesr   twisted.trial.unittestr   r   r(   r&   r2   r$   r   r   <module>rF      s:      +
) )B$N$N(@ (@r   