ó
    ×›‘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     Ú]C:\Users\psant\Downloads\Noiseback\school\venv\Lib\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Ñ$�ØŸi™iÓ'¨:×+@Ñ+@ÀÇÁÈ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   € Ø—~‘~ d§i¡iÓ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(   € Ø�‰�t—y‘yÔ!Ü�‰×Ñ˜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Ü�$˜Ô(Ü‡K�K×Ñ�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Ó)�Ø—‘×&Ñ&¤}°VÀFÓ'KÔLØ%�t“à$�t“ä˜%¤×&Ñ&Ü# F§O¡O°cÑ$9¸DÑ$@ÓA�Ø—‘×&Ñ&¤}°VÀFÓ'KÔLØ7=�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/   € ð
 ˆÜ�dœD¨Ñ3°WÔ=Ø×Ñ˜¤$¨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   € ð ˆÜ�dœD¬°eÑ)<Ñ=¸wÔGØ×Ñ˜g¤tÔ,Ø×Ñ˜g iÑ0´*Ô=Ø×Ñ˜ G¨IÑ$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Á   € ð
 ˆÜ�dœD¬´$¸uÑ2EÑ)FÑGÈÔQØ×Ñ˜g¤tÔ,Ø×Ñ˜g iÑ0´*Ô=Ø×Ñ˜ G¨IÑ$6×$?Ñ$?Ô@Ø×Ñ˜g iÑ0×4Ñ4´jÔ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   