%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /usr/lib/python3/dist-packages/twisted/runner/test/__pycache__/
Upload File :
Create Path :
Current File : //usr/lib/python3/dist-packages/twisted/runner/test/__pycache__/test_procmon.cpython-312.pyc

�

Ϫ�fd����dZddlZddlmZmZmZddlmZddlm	Z	ddl
mZddlm
Z
ddlmZmZdd	lmZGd
�d�ZGd�d
e	e�ZGd�dej*�ZGd�dej.�Zy)z&
Tests for L{twisted.runner.procmon}.
�N)�ProcessDone�ProcessExitedAlready�ProcessTerminated)�Clock)�
MemoryReactor)�globalLogPublisher)�Failure)�LoggingProtocol�ProcessMonitor)�unittestc�8�eZdZdZdZdZdZ				dd�Zd�Zd�Z	y)�DummyProcessa 
    An incomplete and fake L{IProcessTransport} implementation for testing how
    L{ProcessMonitor} behaves when its monitored processes exit.

    @ivar _terminationDelay: the delay in seconds after which the DummyProcess
        will appear to exit when it receives a TERM signal
    �Nc��||_||_||_||_||_||_||_||_|	|_|
|_	y�N)
�proto�_reactor�_executable�_args�_environment�_path�_uid�_gid�_usePTY�	_childFDs)�self�reactor�
executable�args�environment�pathr�uid�gid�usePTY�childFDss           �B/usr/lib/python3/dist-packages/twisted/runner/test/test_procmon.py�__init__zDummyProcess.__init__ sL����
���
�%�����
�'�����
���	���	����!���c���|jdfdd�}|j�
t��||vr5||\}}|jj	||j
|�|_yy)a�
        A partial implementation of signalProcess which can only handle TERM and
        KILL signals.
         - When a TERM signal is given, the dummy process will appear to exit
           after L{DummyProcess._terminationDelay} seconds with exit code 0
         - When a KILL signal is given, the dummy process will appear to exit
           immediately with exit code 1.

        @param signalID: The signal name or number to be issued to the process.
        @type signalID: C{str}
        r�rr)�TERM�KILLN)�_terminationDelay�pidrr�	callLater�processEnded�_signalHandler)r�signalID�params�delay�statuss     r&�
signalProcesszDummyProcess.signalProcess9sk�� �1�1�1�5�v�F���8�8��&�(�(��v��"�8�,�M�E�6�"&�-�-�"9�"9��t�(�(�&�#�D��r(c��d|_ttd�}|jj	t|||���y)zC
        Deliver the process ended event to C{self.proto}.
        Nr*)r.rrrr0r	)rr5�	statusMaps   r&r0zDummyProcess.processEndedPs>������ �
�	�	
�
�
����(9�	�&�(9�&�(A� B�Cr()NNrN)
�__name__�
__module__�__qualname__�__doc__r.rr-r'r6r0�r(r&rrs7����C��E���
����"�2�.	Dr(rc�,�eZdZdZd�Zdidddddfd�Zy)�DummyProcessReactorz�
    @ivar spawnedProcesses: a list that keeps track of the fake process
        instances built by C{spawnProcess}.
    @type spawnedProcesses: C{list}
    c�f�tj|�tj|�g|_yr)rr'r�spawnedProcesses�rs r&r'zDummyProcessReactor.__init__cs$�����t�$�
���t�� "��r(r=Nrc
��t||||||||||	�
}
|j|
�|jj|
�|
S)zz
        Fake L{reactor.spawnProcess}, that logs all the process
        arguments and returns a L{DummyProcess}.
        )r�makeConnectionrA�append)r�processProtocolrr�envr!r"r#r$r%�procs           r&�spawnProcessz DummyProcessReactor.spawnProcessisU��"�����������
��	�&�&�t�,����$�$�T�*��r()r9r:r;r<r'rIr=r(r&r?r?\s(���#���
�����r(r?c���eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d �Z"d!�Z#y")#�ProcmonTestsz&
    Tests for L{ProcessMonitor}.
    c��t�|_t|j��|_d|j_d|j_d|j_y)zL
        Create an L{ProcessMonitor} wrapped around a fake reactor.
        �r��
N)r?rr�pm�minRestartDelay�maxRestartDelay�	thresholdrBs r&�setUpzProcmonTests.setUp�sB��+�,��� ����6���"#�����"$���������r(c���|jjdddgddi��t|j�}|jd|�|jd|�|jd|�y	)
z+
        Repr includes all details
        �foo�arg1�arg2rrN�r"r#rG�1�2N)rP�
addProcess�repr�assertIn�r�representations  r&�test_reprLooksGoodzProcmonTests.test_reprLooksGood�s]��	
�����5�6�6�"2��q�b��I��d�g�g����
�
�e�^�,��
�
�c�>�*��
�
�c�>�*r(c��|jjdddgi��t|j�}|jd|�|jd|�y)z�
        Repr does not include unneeded details.

        Values of attributes that just mean "inherit from launching
        process" do not appear in the repr of a process.
        rVrWrX)rG�(�)N)rPr\r]�assertNotInr_s  r&�test_simpleReprLooksGoodz%ProcmonTests.test_simpleReprLooksGood�sO��	
�����5�6�6�"2���;��d�g�g�������n�-�����n�-r(c��|jjdddgddi��|j|jj�ddddgddifi�y)	zW
        The list of monitored processes must be included in the pickle state.
        rVrWrXrrNrY�	processesN)rPr\�assertEqual�__getstate__rBs r&�test_getStateIncludesProcessesz+ProcmonTests.test_getStateIncludesProcesses�s_��	
�����5�6�6�"2��q�b��I�����G�G� � �"�;�/�%�6�6�:J�A�q�RT�9U�1V�	
r(c�X�|jd|jj��y)z~
        The private L{ProcessMonitor._reactor} instance variable should not be
        included in the pickle state.
        rN)rerPrjrBs r&�test_getStateExcludesReactorz)ProcmonTests.test_getStateExcludesReactor�s!��
	
����T�W�W�%9�%9�%;�<r(c���|jjdddgddi��|j|jji�|j|jjdddgddifi�|jj�|jjd�|jt|jjj��dg�y)	z�
        L{ProcessMonitor.addProcess} only starts the named program if
        L{ProcessMonitor.startService} has been called.
        rVrWrXrrNrYrN)
rPr\ri�	protocolsrh�startServicer�advance�list�keysrBs r&�test_addProcesszProcmonTests.test_addProcess�s���
	
�����5�6�6�"2��q�b��I�������*�*�B�/�������*�*�U�f�f�5E�q�!�R�4P�,Q�R������������Q������d�g�g�/�/�4�4�6�7�%��Ar(c	��|jjdddgddi��|jt|jjdddgddi��y)z|
        L{ProcessMonitor.addProcess} raises a C{KeyError} if a process with the
        given name already exists.
        rVrWrXrrNrYN)rPr\�assertRaises�KeyErrorrBs r&� test_addProcessDuplicateKeyErrorz-ProcmonTests.test_addProcessDuplicateKeyError�sX��
	
�����5�6�6�"2��q�b��I�����d�g�g�(�(�%�&�&�1A�q�a�UW�	�	
r(c��ddi}|jj�|jjddgdd|��|jj	d�|j|jjdj|�y)	z�
        L{ProcessMonitor.addProcess} takes an C{env} parameter that is passed to
        L{IReactorProcess.spawnProcess}.
        �KEY�valuerVrrNrYrN)rPrpr\rrqrirAr)r�fakeEnvs  r&�test_addProcessEnvzProcmonTests.test_addProcessEnv�st��
�'�"�������������5�5�'�q�a�W��E������Q��������6�6�q�9�F�F��Pr(c��|jj�|jjddgd��|jj	d�|j|jjdjd�y)z�
        L{ProcessMonitor.addProcess} takes an C{cwd} parameter that is passed
        to L{IReactorProcess.spawnProcess}.
        rVz	/mnt/lala)�cwdrN)rPrpr\rrqrirArrBs r&�test_addProcessCwdzProcmonTests.test_addProcessCwd�sf��
	
�����������5�5�'�{��;������Q��������6�6�q�9�?�?��Mr(c�d�|jj�|jjddg�|jt	|jj
�d�|jj
d�|jt	|jj
�d�y)zm
        L{ProcessMonitor.removeProcess} removes the process from the public
        processes list.
        rVrrN)rPrpr\ri�lenrh�
removeProcessrBs r&�test_removeProcesszProcmonTests.test_removeProcess�sz��
	
�����������5�5�'�*�����T�W�W�.�.�/��3������e�$�����T�W�W�.�.�/��3r(c��|jj�|jt|jjd�y)zz
        L{ProcessMonitor.removeProcess} raises a C{KeyError} if the given
        process name isn't recognised.
        rVN)rPrprvrwr�rBs r&�!test_removeProcessUnknownKeyErrorz.ProcmonTests.test_removeProcessUnknownKeyError�s0��
	
���������(�D�G�G�$9�$9�5�Ar(c�6�|jjddg�|jjd�|j|jjdt
�|j
d|jjj��y)a
        When a process has been started, an instance of L{LoggingProtocol} will
        be added to the L{ProcessMonitor.protocols} dict and the start time of
        the process will be recorded in the L{ProcessMonitor.timeStarted}
        dictionary.
        rVN)	rPr\�startProcess�assertIsInstanceror
r^�timeStartedrsrBs r&�test_startProcesszProcmonTests.test_startProcess�sl��	
�����5�5�'�*������U�#����d�g�g�/�/��6��H��
�
�e�T�W�W�0�0�5�5�7�8r(c���|jjddg�|jjd�|j|jjd��y)zr
        L{ProcessMonitor.startProcess} silently returns if the named process is
        already started.
        rVN)rPr\r��assertIsNonerBs r&�test_startProcessAlreadyStartedz,ProcmonTests.test_startProcessAlreadyStarted
sI��
	
�����5�5�'�*������U�#����$�'�'�.�.�u�5�6r(c�Z�|jt|jjd�y)zy
        L{ProcessMonitor.startProcess} raises a C{KeyError} if the given
        process name isn't recognised.
        rVN)rvrwrPr�rBs r&� test_startProcessUnknownKeyErrorz-ProcmonTests.test_startProcessUnknownKeyErrors ��
	
���(�D�G�G�$8�$8�%�@r(c��|jj�|jjddg�|jd|jj�dx}|jjdj
_|jj|jj�|jjd�|jj|�|jjd�|j|jj�|jjd�y)zm
        L{ProcessMonitor.stopProcess} immediately sends a TERM signal to the
        named process.
        rVrrN)rPrpr\r^ro�	transportr-rrqrS�stopProcessri�secondsr�)r�	timeToDies  r&�"test_stopProcessNaturalTerminationz/ProcmonTests.test_stopProcessNaturalTerminations���
	
�����������5�5�'�*��
�
�e�T�W�W�.�.�/�LM�L�	�D�G�G�%�%�e�,�6�6�H�	
�����T�W�W�.�.�/������E�"�	
�����Y�'�
	
�����Q��	
������-�-�/����1D�1D�U�1K�Lr(c�|�|jj�|jjddg�|jd|jj�|j
j
|jj�|jjdj}|jjdz|_
|jjd�|j
j
|jjdz
�|jd|jjd�|j
j
d�|j
jddg�|j|j
j�|jjd�y)z�
        L{ProcessMonitor.stopProcess} kills a process which fails to terminate
        naturally within L{ProcessMonitor.killTime} seconds.
        rVrgrN)rPrpr\r^rorrqrSr��killTimer-r�rir��pumpr�)rrHs  r&�test_stopProcessForcedKillz'ProcmonTests.test_stopProcessForcedKill8s9��
	
�����������5�5�'�*��
�
�e�T�W�W�.�.�/������T�W�W�.�.�/��w�w� � ��'�1�1��!%���!1�!1�A�!5��������E�"�	
�����T�W�W�-�-��1�2�����d�g�g�1�1�%�8�9������Q��	
�����1�a�&�!�������-�-�/����1D�1D�U�1K�Lr(c�Z�|jt|jjd�y)zx
        L{ProcessMonitor.stopProcess} raises a C{KeyError} if the given process
        name isn't recognised.
        rVN)rvrwrPr�rBs r&�test_stopProcessUnknownKeyErrorz,ProcmonTests.test_stopProcessUnknownKeyErrorUs ��
	
���(�D�G�G�$7�$7��?r(c��|jjddg�|j|jjd��y)z�
        L{ProcessMonitor.stopProcess} silently returns if the named process
        is already stopped. eg Process has crashed and a restart has been
        rescheduled, but in the meantime, the service is stopped.
        rVN)rPr\r�r�rBs r&�test_stopProcessAlreadyStoppedz+ProcmonTests.test_stopProcessAlreadyStopped\s7��	
�����5�5�'�*����$�'�'�-�-�e�4�5r(c�>�g}|jtj|j�tj|j�|j
j
ddg�|j
j�|jjd�|jd|j
j�|jj|j
j�|j
jdjd�|jt|�d�|dd}|dd}|dd}|dd}|j|d	�|j|d
�|j|d�|j|d�y)
zS
        Getting a complete output line on stdout generates a log message.
        rVr�
hello world!
r�
log_namespace�stream�tag�line�%twisted.runner.procmon.ProcessMonitor�stdout�hello world!N)�
addCleanupr�removeObserverrE�addObserverrPr\rprrqr^rorS�outReceived�assertEqualsr��r�events�	namespacer�r�r�s      r&�test_outputReceivedCompleteLinez,ProcmonTests.test_outputReceivedCompleteLinee�K�������*�9�9�6�=�=�I��&�&�v�}�}�5������5�5�'�*������������Q���
�
�e�T�W�W�.�.�/������T�W�W�.�.�/������%� �,�,�->�?����#�f�+�q�)��1�I�o�.�	����8�$���Q�i�����a�y�� �����)�%L�M����&�(�+����#�u�%����$��/r(c�>�g}|jtj|j�tj|j�|j
j
ddg�|j
j�|jjd�|jd|j
j�|jj|j
j�|j
jdjd�|jt|�d�|dd}|dd}|dd}|dd}|j|d	�|j|d
�|j|d�|j|d�y)
zS
        Getting a complete output line on stderr generates a log message.
        rVrr�rr�r�r�r�r��stderrr�N)r�rr�rEr�rPr\rprrqr^rorS�errReceivedr�r�r�s      r&�!test_ouputReceivedCompleteErrLinez.ProcmonTests.test_ouputReceivedCompleteErrLine�r�r(c�B�g}|jtj|j�tj|j�|j
j
ddg�|j
j�|jjd�|jd|j
j�|jj|j
j�|j
jdjd�|jt|�d�|d}|d}|d}|d}|d}|j|d	�|j|d
�|j|d�|j|t!d��y)
zN
        Getting invalid UTF-8 results in the repr of the raw message
        rVrs�hello world!
rr�r�r�r�r�r�s
�hello world!N)r�rr�rEr�rPr\rprrqr^rorSr�r�r�r])rr��messager�r�r��outputs       r&�*test_outputReceivedCompleteLineInvalidUTF8z7ProcmonTests.test_outputReceivedCompleteLineInvalidUTF8�sH�������*�9�9�6�=�=�I��&�&�v�}�}�5������5�5�'�*������������Q���
�
�e�T�W�W�.�.�/������T�W�W�.�.�/������%� �,�,�-B�C����#�f�+�q�)���)���O�,�	���"���e�n���������)�%L�M����&�(�+����#�u�%����&�$�':�";�<r(c���g}|jtj|j�tj|j�|j
j
ddg�|j
j�|jjd�|jd|j
j�|jj|j
j�|j
jdjd�|jt|�d�|j
jdj!t#t%d���|jt|�d�|dd}|dd}|dd}|dd}|j|d	�|j|d
�|j|d�|j|d�y)
zM
        Getting partial line results in no events until process end
        rVrshello world!rr�r�r�r�r�r�r�N)r�rr�rEr�rPr\rprrqr^rorSr�r�r�r0r	rr�s      r&�test_outputReceivedPartialLinez+ProcmonTests.test_outputReceivedPartialLine�s��������*�9�9�6�=�=�I��&�&�v�}�}�5������5�5�'�*������������Q���
�
�e�T�W�W�.�.�/������T�W�W�.�.�/������%� �,�,�_�=����#�f�+�q�)������%� �-�-�g�k�!�n�.E�F����#�f�+�q�)��1�I�o�.�	����8�$���Q�i�����a�y�� �����)�%L�M����&�(�+����#�u�%����$��/r(c��|jjddg�|jj�|jj	d�|jd|jj�|jj	|jj�|jjdjttd���|jd|jj�|jj	d�|jd|jj�y)z�
        L{ProcessMonitor.connectionLost} should immediately restart a process
        if it has been running longer than L{ProcessMonitor.threshold} seconds.
        rVrN)rPr\rprrqr^rorSr0r	rrerBs r&�#test_connectionLostLongLivedProcessz0ProcmonTests.test_connectionLostLongLivedProcess�s���
	
�����5�5�'�*������������Q���
�
�e�T�W�W�.�.�/������T�W�W�.�.�/������%� �-�-�g�k�!�n�.E�F�������� 1� 1�2������Q���
�
�e�T�W�W�.�.�/r(c��|jjddg�|jj�|jj	d�|jjd�|j
d|jj�|jjd}|j|j��|jj	|jjdjj�|j|j��|jd|jj�y)z�
        L{ProcessMonitor.connectionLost} cancels a scheduled process killer and
        deletes the DelayedCall from the L{ProcessMonitor.murder} list.
        rVrN)rPr\rprrqr�r^�murder�
assertTrue�activeror�r-�assertFalsere)r�delayedCalls  r&�test_connectionLostMurderCancelz,ProcmonTests.test_connectionLostMurderCancel�s���
	
�����5�5�'�*������������Q�������E�"��
�
�e�T�W�W�^�^�,��g�g�n�n�U�+������*�*�,�-������T�W�W�.�.�u�5�?�?�Q�Q�R�����+�+�-�.����������/r(c��|jj�|jjddg�|jd|jj�|jjdj
j
d�|jj|jjdj
j�|jd|jj�y)z�
        L{ProcessMonitor.connectionLost} removes the corresponding
        ProcessProtocol instance from the L{ProcessMonitor.protocols} list.
        rVr,N)rPrpr\r^ror�r6rrqr-rerBs r&�#test_connectionLostProtocolDeletionz0ProcmonTests.test_connectionLostProtocolDeletion�s���
	
�����������5�5�'�*��
�
�e�T�W�W�.�.�/������%� �*�*�8�8��@������T�W�W�.�.�u�5�?�?�Q�Q�R�������� 1� 1�2r(c��d|j_d|j_|jj�|jj	ddg�|j|jjd|jj�|jj|jjdz
�|jjdjttd���|j|jjd|jj�y)z}
        L{ProcessMonitor.connectionLost} will wait at least minRestartDelay s
        and at most maxRestartDelay s
        rN�rVrrN)rPrQrRrpr\rir4rrqrSror0r	rrBs r&�%test_connectionLostMinMaxRestartDelayz2ProcmonTests.test_connectionLostMinMaxRestartDelay	s���
#$�����"#����������������5�5�'�*���������u�-�t�w�w�/F�/F�G������T�W�W�.�.��2�3������%� �-�-�g�k�!�n�.E�F���������u�-�t�w�w�/F�/F�Gr(c��|jj�|jjddg�|jj	|jj
dz
�|j
d|jj�|j|jjd|jj�|jjdjttd���|j|jjd|jjdz�y)z|
        L{ProcessMonitor.connectionLost} doubles the restart delay each time
        the process dies too quickly.
        rVrrrNN)rPrpr\rrqrSr^rorir4rQr0r	rrBs r&�&test_connectionLostBackoffDelayDoublesz3ProcmonTests.test_connectionLostBackoffDelayDoubless���
	
�����������5�5�'�*������T�W�W�.�.��2�3��
�
�e�T�W�W�.�.�/���������u�-�t�w�w�/F�/F�G������%� �-�-�g�k�!�n�.E�F���������u�-�t�w�w�/F�/F��/J�Kr(c���|jjddg�|jj�|jj	d�|jd|jj�y)zP
        L{ProcessMonitor.startService} starts all monitored processes.
        rVrN)rPr\rprrqr^rorBs r&�test_startServicezProcmonTests.test_startService'sT��	
�����5�5�'�*������������Q���
�
�e�T�W�W�.�.�/r(c��|jjddg�|jjddg�|jj�|jj	|jj
�|j
d|jj�|j
d|jj�|jj	d�|jj�|jj	|jjdz�|ji|jj�y)zT
        L{ProcessMonitor.stopService} should stop all monitored processes.
        rV�barrN)rPr\rprrqrSr^ro�stopServicer�rirBs r&�test_stopServicezProcmonTests.test_stopService2s���	
�����5�5�'�*������5�5�'�*������������T�W�W�.�.�/��
�
�e�T�W�W�.�.�/��
�
�e�T�W�W�.�.�/������Q��������	
�����T�W�W�-�-��1�2�����T�W�W�.�.�/r(c���|jjddg�|jj�|jj	d�|jj�|jj	d�t
|jj�}|j�}|j|g�|j|j�y)zR
        L{ProcessMonitor.restartAll} succeeds when there is one process.
        rVrN)rPr\rprrq�
restartAllrrrA�popr�r�r.)rrh�	myProcesss   r&�!test_restartAllRestartsOneProcessz.ProcmonTests.test_restartAllRestartsOneProcessHs���	
�����5�5�'�*������������Q��������	
�����Q������6�6�7�	��M�M�O�	����)�R�(����)�-�-�(r(c���|jjddg�|jj�|jj	|jj
�|j
d|jj�|jj	d�|jjdjttd���|j|jjdj��|jj�|j|jjdj��y)ze
        L{ProcessMonitor.stopService} should cancel any scheduled process
        restarts.
        rVrrN)rPr\rprrqrSr^ror0r	rr��restartr�r�r�rBs r&�test_stopServiceCancelRestartsz+ProcmonTests.test_stopServiceCancelRestartsXs���
	
�����5�5�'�*������������T�W�W�.�.�/��
�
�e�T�W�W�.�.�/������Q�������%� �-�-�g�k�!�n�.E�F����������.�5�5�7�8����������������/�6�6�8�9r(c��d|j_d|j_|jj�|jj	ddg�|j
j
d�|jjd�|j
j
d�|jj�|j
j
d�|j|jji�y)ze
        L{ProcessMonitor.stopService} should cancel all scheduled process
        restarts.
        �rVr�N)rPrSrQrpr\rrqr�r�rirorBs r&�(test_stopServiceCleanupScheduledRestartsz5ProcmonTests.test_stopServiceCleanupScheduledRestartsls���
�����"#����������������5�5�'�*������Q�������E�"������Q�������������Q��	
������*�*�B�/r(N)$r9r:r;r<rTrarfrkrmrtrxr}r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r=r(r&rKrK�s�����+�
.�
�=�
B�
�	Q�N�	4�B�
9�7�A�M�<M�:@�6�0�60�6=�80�:0�(0�*
3�H� L�	0�0�,)� :�(0r(rKc�(�eZdZdZd�Zd�Zd�Zd�Zy)�DeprecationTestszQ
    Tests that check functionality that should be deprecated is deprecated.
    c�X�t�|_t|j��|_y)z5
        Create reactor and process monitor.
        rMN)r?rrrPrBs r&rTzDeprecationTests.setUp�s��+�,��� ����6��r(c�T�|jjddg�|jj}|jt	|�d�|j�}d}|D]%}|j
|dt�d|dvs�$d}�'|j|dt|����y	)
a
        _Process.toTuple is deprecated.

        When getting the deprecated processes property, the actual
        data (kept in the class _Process) is converted to a tuple --
        which produces a DeprecationWarning per process so converted.
        rVrF�category�toTupler�Tzno tuple deprecation found:N)
rPr\rhr�r��
flushWarnings�assertIs�DeprecationWarningr�r])r�myprocesses�warnings�foundToTuple�warnings     r&�test_toTuplezDeprecationTests.test_toTuple�s���	
�����5�5�'�*��g�g�'�'�����#�k�*�A�.��%�%�'�����	$�G��M�M�'�*�-�/A�B��G�I�.�.�#��	$�	
����(C�D��N�CS�&T�Ur(c���|jj}|j|i�|j�}|j	d�}|j|dt�|j|g�y)a
        Accessing L{ProcessMonitor.processes} results in deprecation warning

        Even when there are no processes, and thus no process is converted
        to a tuple, accessing the L{ProcessMonitor.processes} property
        should generate its own DeprecationWarning.
        rr�N)rPrhr�r�r�r�r�)r�myProcessesr��firsts    r&�test_processeszDeprecationTests.test_processes�sb���g�g�'�'�����+�r�*��%�%�'�����Q����
�
�e�J�'�);�<����(�B�'r(c��tj|j�|j�}|D]}|j	|dt
��y)zO
        Pickling an L{ProcessMonitor} results in deprecation warnings
        r�N)�pickle�dumpsrPr�r�r�)rr�r�s   r&�
test_getstatezDeprecationTests.test_getstate�sG��	���T�W�W���%�%�'���	C�G��M�M�'�*�-�/A�B�	Cr(N)r9r:r;r<rTr�r�r�r=r(r&r�r��s���7�V�&
(�Cr(r�)r<r��twisted.internet.errorrrr�twisted.internet.taskr�twisted.internet.testingr�twisted.loggerr�twisted.python.failurer	�twisted.runner.procmonr
r�
twisted.trialrrr?�TestCaserK�SynchronousTestCaser�r=r(r&�<module>r�sn����W�W�'�2�-�*�B�"�GD�GD�T,�-��,�^v0�8�$�$�v0�r6C�x�3�3�6Cr(

Zerion Mini Shell 1.0