Ë
    ojd  ã                   óð   — d Z ddlZddlmZmZmZ ddlmZ ddlm	Z	 ddl
mZ ddlmZ ddlmZmZ dd	lmZ  G d
„ d«      Z G d„ de	e«      Z G d„ dej*                  «      Z G d„ dej.                  «      Zy)z&
Tests for L{twisted.runner.procmon}.
é    N)ÚProcessDoneÚProcessExitedAlreadyÚProcessTerminated)ÚClock)ÚMemoryReactor)ÚglobalLogPublisher)ÚFailure)ÚLoggingProtocolÚProcessMonitor)Úunittestc                   ó8   — e Zd ZdZdZdZdZ	 	 	 	 dd„Zd„ Zd„ 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__zDummyProcess.__init__    sL   € ð ˆŒ
àˆŒØ%ˆÔØˆŒ
Ø'ˆÔØˆŒ
ØˆŒ	ØˆŒ	ØˆŒØ!ˆ�ó    c                 óÄ   — | j                   dfddœ}| j                  €
t        «       ‚||v r5||   \  }}| j                  j	                  || j
                  |«      | _        yy)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   ©r   r   )ÚTERMÚKILLN)Ú_terminationDelayÚpidr   r   Ú	callLaterÚprocessEndedÚ_signalHandler)r   ÚsignalIDÚparamsÚdelayÚstatuss        r&   ÚsignalProcesszDummyProcess.signalProcess9   sk   € ð  ×1Ñ1°1Ð5¸vÑFˆà�8‰8ÐÜ&Ó(Ð(à�vÑØ" 8Ñ,‰MˆE�6Ø"&§-¡-×"9Ñ"9Ø�t×(Ñ(¨&ó#ˆDÕð r(   c                 ó†   — d| _         t        t        dœ}| j                  j	                  t         ||   |«      «      «       y)zC
        Deliver the process ended event to C{self.proto}.
        Nr*   )r.   r   r   r   r0   r	   )r   r5   Ú	statusMaps      r&   r0   zDummyProcess.processEndedP   s>   € ð ˆŒäÜ ñ
ˆ	ð 	�
‰
×Ñ¤Ð(9¨	°&Ñ(9¸&Ó(AÓ BÕCr(   )NNr   N)
Ú__name__Ú
__module__Ú__qualname__Ú__doc__r.   r   r-   r'   r6   r0   © r(   r&   r   r      s7   „ ñð €CØ€EàÐð ØØØó"ò2ó.	Dr(   r   c                   ó,   — e Zd ZdZd„ Zdi dddddfd„Zy)ÚDummyProcessReactorz�
    @ivar spawnedProcesses: a list that keeps track of the fake process
        instances built by C{spawnProcess}.
    @type spawnedProcesses: C{list}
    c                 óf   — t        j                  | «       t        j                  | «       g | _        y r   )r   r'   r   ÚspawnedProcesses©r   s    r&   r'   zDummyProcessReactor.__init__c   s$   € Ü×Ñ˜tÔ$Ü�‰�tÔà "ˆÕr(   r=   Nr   c
                 ó†   — t        | |||||||||	«
      }
|j                  |
«       | j                  j                  |
«       |
S )zz
        Fake L{reactor.spawnProcess}, that logs all the process
        arguments and returns a L{DummyProcess}.
        )r   ÚmakeConnectionrA   Úappend)r   ÚprocessProtocolr   r   Úenvr!   r"   r#   r$   r%   Úprocs              r&   ÚspawnProcessz DummyProcessReactor.spawnProcessi   sU   € ô" ØØØØØØØØØØó
ˆð 	×&Ñ& tÔ,Ø×Ñ×$Ñ$ TÔ*Øˆr(   )r9   r:   r;   r<   r'   rI   r=   r(   r&   r?   r?   \   s(   „ ñò#ð ØØØØØØôr(   r?   c                   óÐ   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ 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?   r   r   ÚpmÚminRestartDelayÚmaxRestartDelayÚ	thresholdrB   s    r&   ÚsetUpzProcmonTests.setUp�   sB   € ô +Ó,ˆŒÜ ¨¯©Ô6ˆŒØ"#ˆ�‰ÔØ"$ˆ�‰ÔØˆ�‰Õr(   c                 óÞ   — | j                   j                  dddgddi ¬«       t        | j                   «      }| j                  d|«       | j                  d|«       | j                  d|«       y	)
z+
        Repr includes all details
        ÚfooÚarg1Úarg2r   rN   ©r"   r#   rG   Ú1Ú2N)rP   Ú
addProcessÚreprÚassertIn©r   Úrepresentations     r&   Útest_reprLooksGoodzProcmonTests.test_reprLooksGoodš   s]   € ð 	�‰×Ñ˜5 6¨6Ð"2¸¸qÀbÐÔIÜ˜dŸg™g›ˆØ�‰�e˜^Ô,Ø�‰�c˜>Ô*Ø�‰�c˜>Õ*r(   c                 ó¶   — | j                   j                  dddgi ¬«       t        | j                   «      }| j                  d|«       | j                  d|«       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.
        rV   rW   rX   )rG   ú(ú)N)rP   r\   r]   ÚassertNotInr_   s     r&   Útest_simpleReprLooksGoodz%ProcmonTests.test_simpleReprLooksGood¤   sO   € ð 	�‰×Ñ˜5 6¨6Ð"2¸ÐÔ;Ü˜dŸg™g›ˆØ×Ñ˜˜nÔ-Ø×Ñ˜˜nÕ-r(   c                 ó²   — | j                   j                  dddgddi ¬«       | j                  | j                   j                  «       d   dddgddi fi«       y)	zW
        The list of monitored processes must be included in the pickle state.
        rV   rW   rX   r   rN   rY   Ú	processesN)rP   r\   ÚassertEqualÚ__getstate__rB   s    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   — | j                  d| j                  j                  «       «       y)z~
        The private L{ProcessMonitor._reactor} instance variable should not be
        included in the pickle state.
        r   N)re   rP   rj   rB   s    r&   Útest_getStateExcludesReactorz)ProcmonTests.test_getStateExcludesReactor¹   s!   € ð
 	×Ñ˜ T§W¡W×%9Ñ%9Ó%;Õ<r(   c                 óÖ  — | j                   j                  dddgddi ¬«       | j                  | j                   j                  i «       | j                  | j                   j                  dddgddi fi«       | j                   j                  «        | j                  j                  d«       | j                  t        | j                   j                  j                  «       «      dg«       y)	z‡
        L{ProcessMonitor.addProcess} only starts the named program if
        L{ProcessMonitor.startService} has been called.
        rV   rW   rX   r   rN   rY   r   N)
rP   r\   ri   Ú	protocolsrh   ÚstartServicer   ÚadvanceÚlistÚkeysrB   s    r&   Útest_addProcesszProcmonTests.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           	      ó¬   — | j                   j                  dddgddi ¬«       | j                  t        | j                   j                  dddgddi ¬«       y)z|
        L{ProcessMonitor.addProcess} raises a C{KeyError} if a process with the
        given name already exists.
        rV   rW   rX   r   rN   rY   N)rP   r\   ÚassertRaisesÚKeyErrorrB   s    r&   Ú test_addProcessDuplicateKeyErrorz-ProcmonTests.test_addProcessDuplicateKeyErrorÌ   sX   € ð
 	�‰×Ñ˜5 6¨6Ð"2¸¸qÀbÐÔIØ×ÑÜ�d—g‘g×(Ñ(¨%°&¸&Ð1AÀqÈaÐUWð 	õ 	
r(   c                 ó  — ddi}| j                   j                  «        | j                   j                  ddgdd|¬«       | j                  j	                  d«       | j                  | j                  j                  d   j                  |«       y)	zƒ
        L{ProcessMonitor.addProcess} takes an C{env} parameter that is passed to
        L{IReactorProcess.spawnProcess}.
        ÚKEYÚvaluerV   r   rN   rY   r   N)rP   rp   r\   r   rq   ri   rA   r   )r   ÚfakeEnvs     r&   Útest_addProcessEnvzProcmonTests.test_addProcessEnvÖ   st   € ð
 ˜'Ð"ˆØ�‰×ÑÔØ�‰×Ñ˜5 5 '¨q°a¸WÐÔEØ�‰×Ñ˜QÔØ×Ñ˜Ÿ™×6Ñ6°qÑ9×FÑFÈÕPr(   c                 ó  — | j                   j                  «        | j                   j                  ddgd¬«       | j                  j	                  d«       | j                  | j                  j                  d   j                  d«       y)zƒ
        L{ProcessMonitor.addProcess} takes an C{cwd} parameter that is passed
        to L{IReactorProcess.spawnProcess}.
        rV   z	/mnt/lala)Úcwdr   N)rP   rp   r\   r   rq   ri   rA   r   rB   s    r&   Útest_addProcessCwdzProcmonTests.test_addProcessCwdá   sf   € ð
 	�‰×ÑÔØ�‰×Ñ˜5 5 '¨{ÐÔ;Ø�‰×Ñ˜QÔØ×Ñ˜Ÿ™×6Ñ6°qÑ9×?Ñ?ÀÕMr(   c                 ód  — | j                   j                  «        | j                   j                  ddg«       | j                  t	        | j                   j
                  «      d«       | j                   j                  d«       | j                  t	        | j                   j
                  «      d«       y)zm
        L{ProcessMonitor.removeProcess} removes the process from the public
        processes list.
        rV   r   r   N)rP   rp   r\   ri   Úlenrh   ÚremoveProcessrB   s    r&   Útest_removeProcesszProcmonTests.test_removeProcessë   sz   € ð
 	�‰×ÑÔØ�‰×Ñ˜5 5 'Ô*Ø×Ñœ˜TŸW™W×.Ñ.Ó/°Ô3Ø�‰×Ñ˜eÔ$Ø×Ñœ˜TŸW™W×.Ñ.Ó/°Õ3r(   c                 óŽ   — | j                   j                  «        | j                  t        | j                   j                  d«       y)zz
        L{ProcessMonitor.removeProcess} raises a C{KeyError} if the given
        process name isn't recognised.
        rV   N)rP   rp   rv   rw   rƒ   rB   s    r&   Ú!test_removeProcessUnknownKeyErrorz.ProcmonTests.test_removeProcessUnknownKeyErrorö   s0   € ð
 	�‰×ÑÔØ×Ñœ( D§G¡G×$9Ñ$9¸5ÕAr(   c                 ó6  — | j                   j                  ddg«       | j                   j                  d«       | j                  | j                   j                  d   t
        «       | j                  d| j                   j                  j                  «       «       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.
        rV   N)	rP   r\   ÚstartProcessÚassertIsInstancero   r
   r^   ÚtimeStartedrs   rB   s    r&   Útest_startProcesszProcmonTests.test_startProcessþ   sl   € ð 	�‰×Ñ˜5 5 'Ô*Ø�‰×Ñ˜UÔ#Ø×Ñ˜dŸg™g×/Ñ/°Ñ6¼ÔHØ�‰�e˜TŸW™W×0Ñ0×5Ñ5Ó7Õ8r(   c                 óÈ   — | j                   j                  ddg«       | j                   j                  d«       | j                  | j                   j                  d«      «       y)zr
        L{ProcessMonitor.startProcess} silently returns if the named process is
        already started.
        rV   N)rP   r\   rˆ   ÚassertIsNonerB   s    r&   Útest_startProcessAlreadyStartedz,ProcmonTests.test_startProcessAlreadyStarted
  sI   € ð
 	�‰×Ñ˜5 5 'Ô*Ø�‰×Ñ˜UÔ#Ø×Ñ˜$Ÿ'™'×.Ñ.¨uÓ5Õ6r(   c                 óZ   — | j                  t        | j                  j                  d«       y)zy
        L{ProcessMonitor.startProcess} raises a C{KeyError} if the given
        process name isn't recognised.
        rV   N)rv   rw   rP   rˆ   rB   s    r&   Ú test_startProcessUnknownKeyErrorz-ProcmonTests.test_startProcessUnknownKeyError  s    € ð
 	×Ñœ( D§G¡G×$8Ñ$8¸%Õ@r(   c                 ó”  — | j                   j                  «        | j                   j                  ddg«       | j                  d| j                   j                  «       dx}| j                   j                  d   j
                  _        | j                  j                  | j                   j                  «       | j                   j                  d«       | j                  j                  |«       | j                  j                  d«       | j                  | j                  j                  «       | j                   j                  d   «       y)zm
        L{ProcessMonitor.stopProcess} immediately sends a TERM signal to the
        named process.
        rV   r   r   N)rP   rp   r\   r^   ro   Ú	transportr-   r   rq   rS   ÚstopProcessri   ÚsecondsrŠ   )r   Ú	timeToDies     r&   Ú"test_stopProcessNaturalTerminationz/ProcmonTests.test_stopProcessNaturalTermination  sî   € ð
 	�‰×ÑÔØ�‰×Ñ˜5 5 'Ô*Ø�‰�e˜TŸW™W×.Ñ.Ô/ð LMÐLˆ	�D—G‘G×%Ñ% eÑ,×6Ñ6ÔHð 	�‰×Ñ˜TŸW™W×.Ñ.Ô/à�‰×Ñ˜EÔ"ð 	�‰×Ñ˜YÔ'ð
 	�‰×Ñ˜QÔð 	×Ñ˜Ÿ™×-Ñ-Ó/°·±×1DÑ1DÀUÑ1KÕLr(   c                 ó|  — | j                   j                  «        | j                   j                  ddg«       | j                  d| j                   j                  «       | j
                  j                  | j                   j                  «       | j                   j                  d   j                  }| j                   j                  dz   |_
        | j                   j                  d«       | j
                  j                  | j                   j                  dz
  «       | j                  d| j                   j                  d   «       | j
                  j                  d«       | j
                  j                  ddg«       | j                  | j
                  j                  «       | j                   j                  d   «       y)z•
        L{ProcessMonitor.stopProcess} kills a process which fails to terminate
        naturally within L{ProcessMonitor.killTime} seconds.
        rV   r   g        r   N)rP   rp   r\   r^   ro   r   rq   rS   r’   ÚkillTimer-   r“   ri   rŠ   Úpumpr”   )r   rH   s     r&   Útest_stopProcessForcedKillz'ProcmonTests.test_stopProcessForcedKill8  s9  € ð
 	�‰×ÑÔØ�‰×Ñ˜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   — | j                  t        | j                  j                  d«       y)zx
        L{ProcessMonitor.stopProcess} raises a C{KeyError} if the given process
        name isn't recognised.
        rV   N)rv   rw   rP   r“   rB   s    r&   Útest_stopProcessUnknownKeyErrorz,ProcmonTests.test_stopProcessUnknownKeyErrorU  s    € ð
 	×Ñœ( D§G¡G×$7Ñ$7¸Õ?r(   c                 ó’   — | j                   j                  ddg«       | j                  | j                   j                  d«      «       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.
        rV   N)rP   r\   r�   r“   rB   s    r&   Útest_stopProcessAlreadyStoppedz+ProcmonTests.test_stopProcessAlreadyStopped\  s7   € ð 	�‰×Ñ˜5 5 'Ô*Ø×Ñ˜$Ÿ'™'×-Ñ-¨eÓ4Õ5r(   c                 ó>  — g }| j                  t        j                  |j                  «       t        j                  |j                  «       | j
                  j                  ddg«       | j
                  j                  «        | j                  j                  d«       | j                  d| j
                  j                  «       | j                  j                  | j
                  j                  «       | j
                  j                  d   j                  d«       | j                  t        |«      d«       |d   d   }|d   d   }|d   d   }|d   d   }| j                  |d	«       | j                  |d
«       | j                  |d«       | j                  |d«       y)zS
        Getting a complete output line on stdout generates a log message.
        rV   r   ó   hello world!
r   Úlog_namespaceÚstreamÚtagÚlineú%twisted.runner.procmon.ProcessMonitorÚstdoutúhello world!N)Ú
addCleanupr   ÚremoveObserverrE   ÚaddObserverrP   r\   rp   r   rq   r^   ro   rS   Ú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 }| j                  t        j                  |j                  «       t        j                  |j                  «       | j
                  j                  ddg«       | j
                  j                  «        | j                  j                  d«       | j                  d| j
                  j                  «       | j                  j                  | j
                  j                  «       | j
                  j                  d   j                  d«       | j                  t        |«      d«       |d   d   }|d   d   }|d   d   }|d   d   }| j                  |d	«       | j                  |d
«       | j                  |d«       | j                  |d«       y)zS
        Getting a complete output line on stderr generates a log message.
        rV   r   r    r   r¡   r¢   r£   r¤   r¥   Ústderrr§   N)r¨   r   r©   rE   rª   rP   r\   rp   r   rq   r^   ro   rS   ÚerrReceivedr¬   r‚   r­   s         r&   Ú!test_ouputReceivedCompleteErrLinez.ProcmonTests.test_ouputReceivedCompleteErrLine€  r±   r(   c                 óB  — g }| j                  t        j                  |j                  «       t        j                  |j                  «       | j
                  j                  ddg«       | j
                  j                  «        | j                  j                  d«       | j                  d| j
                  j                  «       | j                  j                  | j
                  j                  «       | j
                  j                  d   j                  d«       | j                  t        |«      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
        rV   r   s   ÿhello world!
r   r¡   r¢   r£   r¤   r¥   r¦   s   ÿhello world!N)r¨   r   r©   rE   rª   rP   r\   rp   r   rq   r^   ro   rS   r«   r¬   r‚   r]   )r   r®   Ú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 }| j                  t        j                  |j                  «       t        j                  |j                  «       | j
                  j                  ddg«       | j
                  j                  «        | j                  j                  d«       | j                  d| j
                  j                  «       | j                  j                  | j
                  j                  «       | j
                  j                  d   j                  d«       | j                  t        |«      d«       | j
                  j                  d   j!                  t#        t%        d«      «      «       | j                  t        |«      d«       |d   d   }|d   d   }|d   d   }|d   d   }| j                  |d	«       | j                  |d
«       | j                  |d«       | j                  |d«       y)zM
        Getting partial line results in no events until process end
        rV   r   s   hello world!r   r¡   r¢   r£   r¤   r¥   r¦   r§   N)r¨   r   r©   rE   rª   rP   r\   rp   r   rq   r^   ro   rS   r«   r¬   r‚   r0   r	   r   r­   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                 ó”  — | j                   j                  ddg«       | j                   j                  «        | j                  j	                  d«       | j                  d| j                   j                  «       | j                  j	                  | j                   j                  «       | j                   j                  d   j                  t        t        d«      «      «       | j                  d| j                   j                  «       | j                  j	                  d«       | j                  d| j                   j                  «       y)z§
        L{ProcessMonitor.connectionLost} should immediately restart a process
        if it has been running longer than L{ProcessMonitor.threshold} seconds.
        rV   r   N)rP   r\   rp   r   rq   r^   ro   rS   r0   r	   r   re   rB   s    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                 ó°  — | j                   j                  ddg«       | j                   j                  «        | j                  j	                  d«       | j                   j                  d«       | j                  d| j                   j                  «       | j                   j                  d   }| j                  |j                  «       «       | j                  j	                  | j                   j                  d   j                  j                  «       | j                  |j                  «       «       | j                  d| j                   j                  «       y)z¡
        L{ProcessMonitor.connectionLost} cancels a scheduled process killer and
        deletes the DelayedCall from the L{ProcessMonitor.murder} list.
        rV   r   N)rP   r\   rp   r   rq   r“   r^   ÚmurderÚ
assertTrueÚactivero   r’   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                 óú  — | j                   j                  «        | j                   j                  ddg«       | j                  d| j                   j                  «       | j                   j                  d   j
                  j                  d«       | j                  j                  | j                   j                  d   j
                  j                  «       | j                  d| j                   j                  «       y)z˜
        L{ProcessMonitor.connectionLost} removes the corresponding
        ProcessProtocol instance from the L{ProcessMonitor.protocols} list.
        rV   r,   N)rP   rp   r\   r^   ro   r’   r6   r   rq   r-   re   rB   s    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                   _        | j                   j                  «        | j                   j	                  ddg«       | j                  | j                   j                  d   | j                   j                  «       | j                  j                  | j                   j                  dz
  «       | j                   j                  d   j                  t        t        d«      «      «       | j                  | j                   j                  d   | j                   j                  «       y)z}
        L{ProcessMonitor.connectionLost} will wait at least minRestartDelay s
        and at most maxRestartDelay s
        rN   é   rV   r   r   N)rP   rQ   rR   rp   r\   ri   r4   r   rq   rS   ro   r0   r	   r   rB   s    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                 ó�  — | j                   j                  «        | j                   j                  ddg«       | j                  j	                  | j                   j
                  dz
  «       | j                  d| j                   j                  «       | j                  | j                   j                  d   | j                   j                  «       | j                   j                  d   j                  t        t        d«      «      «       | j                  | j                   j                  d   | j                   j                  dz  «       y)z|
        L{ProcessMonitor.connectionLost} doubles the restart delay each time
        the process dies too quickly.
        rV   r   r   rN   N)rP   rp   r\   r   rq   rS   r^   ro   ri   r4   rQ   r0   r	   r   rB   s    r&   Ú&test_connectionLostBackoffDelayDoublesz3ProcmonTests.test_connectionLostBackoffDelayDoubles  sÜ   € ð
 	�‰×ÑÔØ�‰×Ñ˜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                 óô   — | j                   j                  ddg«       | j                   j                  «        | j                  j	                  d«       | j                  d| j                   j                  «       y)zP
        L{ProcessMonitor.startService} starts all monitored processes.
        rV   r   N)rP   r\   rp   r   rq   r^   ro   rB   s    r&   Útest_startServicezProcmonTests.test_startService'  sT   € ð 	�‰×Ñ˜5 5 'Ô*à�‰×ÑÔà�‰×Ñ˜QÔØ�‰�e˜TŸW™W×.Ñ.Õ/r(   c                 ó¼  — | j                   j                  ddg«       | j                   j                  ddg«       | j                   j                  «        | j                  j	                  | j                   j
                  «       | j                  d| j                   j                  «       | j                  d| j                   j                  «       | j                  j	                  d«       | j                   j                  «        | j                  j	                  | j                   j                  dz   «       | j                  i | j                   j                  «       y)zT
        L{ProcessMonitor.stopService} should stop all monitored processes.
        rV   Úbarr   N)rP   r\   rp   r   rq   rS   r^   ro   ÚstopServicer˜   ri   rB   s    r&   Útest_stopServicezProcmonTests.test_stopService2  së   € ð 	�‰×Ñ˜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                 óÊ  — | j                   j                  ddg«       | j                   j                  «        | j                  j	                  d«       | j                   j                  «        | j                  j	                  d«       t        | j                  j                  «      }|j                  «       }| j                  |g «       | j                  |j                  «       y)zR
        L{ProcessMonitor.restartAll} succeeds when there is one process.
        rV   r   N)rP   r\   rp   r   rq   Ú
restartAllrr   rA   Úpopr¬   r�   r.   )r   rh   Ú	myProcesss      r&   Ú!test_restartAllRestartsOneProcessz.ProcmonTests.test_restartAllRestartsOneProcessH  s¡   € ð 	�‰×Ñ˜5 5 'Ô*Ø�‰×ÑÔØ�‰×Ñ˜QÔØ�‰×ÑÔð 	�‰×Ñ˜QÔÜ˜Ÿ™×6Ñ6Ó7ˆ	Ø—M‘M“Oˆ	Ø×Ñ˜) RÔ(Ø×Ñ˜)Ÿ-™-Õ(r(   c                 óÒ  — | j                   j                  ddg«       | j                   j                  «        | j                  j	                  | j                   j
                  «       | j                  d| j                   j                  «       | j                  j	                  d«       | j                   j                  d   j                  t        t        d«      «      «       | j                  | j                   j                  d   j                  «       «       | j                   j                  «        | j                  | j                   j                  d   j                  «       «       y)ze
        L{ProcessMonitor.stopService} should cancel any scheduled process
        restarts.
        rV   r   r   N)rP   r\   rp   r   rq   rS   r^   ro   r0   r	   r   rÀ   ÚrestartrÁ   rÐ   rÂ   rB   s    r&   Útest_stopServiceCancelRestartsz+ProcmonTests.test_stopServiceCancelRestartsX  sì   € ð
 	�‰×Ñ˜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                   _        | j                   j                  «        | j                   j	                  ddg«       | j
                  j                  d«       | j                   j                  d«       | j
                  j                  d«       | j                   j                  «        | j
                  j                  d«       | j                  | j                   j                  i «       y)ze
        L{ProcessMonitor.stopService} should cancel all scheduled process
        restarts.
        é   rV   r   é   N)rP   rS   rQ   rp   r\   r   rq   r“   rÐ   ri   ro   rB   s    r&   Ú(test_stopServiceCleanupScheduledRestartsz5ProcmonTests.test_stopServiceCleanupScheduledRestartsl  s¶   € ð
 ˆ�‰ÔØ"#ˆ�‰Ôà�‰×ÑÔØ�‰×Ñ˜5 5 'Ô*à�‰×Ñ˜QÔØ�‰×Ñ˜EÔ"à�‰×Ñ˜QÔà�‰×ÑÔà�‰×Ñ˜QÔð 	×Ñ˜Ÿ™×*Ñ*¨BÕ/r(   N)$r9   r:   r;   r<   rT   ra   rf   rk   rm   rt   rx   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(   r&   rK   rK   ‹   s±   „ ñòò+ò
.ò
ò=ò
Bò
ò	QòNò	4òBò
9ò7òAòMò<Mò:@ò6ò0ò60ò6=ò80ò:0ò(0ò*
3òHò Lò	0ò0ò,)ò :ó(0r(   rK   c                   ó(   — e Zd ZdZd„ Zd„ Zd„ Zd„ Zy)ÚDeprecationTestszQ
    Tests that check functionality that should be deprecated is deprecated.
    c                 óX   — t        «       | _        t        | j                  ¬«      | _        y)z5
        Create reactor and process monitor.
        rM   N)r?   r   r   rP   rB   s    r&   rT   zDeprecationTests.setUpŠ  s   € ô +Ó,ˆŒÜ ¨¯©Ô6ˆ�r(   c                 óT  — | j                   j                  ddg«       | j                   j                  }| j                  t	        |«      d«       | j                  «       }d}|D ]%  }| j                  |d   t        «       d|d   v sŒ$d}Œ' | j                  |dt        |«      › �«       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.
        rV   r   FÚcategoryÚtoTupler·   Tzno tuple deprecation found:N)
rP   r\   rh   r¬   r‚   ÚflushWarningsÚassertIsÚDeprecationWarningrÀ   r]   )r   ÚmyprocessesÚwarningsÚfoundToTupleÚwarnings        r&   Útest_toTuplezDeprecationTests.test_toTuple‘  s£   € ð 	�‰×Ñ˜5 5 'Ô*Ø—g‘g×'Ñ'ˆØ×Ñœ#˜kÓ*¨AÔ.Ø×%Ñ%Ó'ˆØˆØò 	$ˆGØ�M‰M˜' *Ñ-Ô/AÔBØ˜G IÑ.Ò.Ø#‘ð	$ð 	�‰˜Ð(CÄDÈÃNÐCSÐ&TÕUr(   c                 óì   — | j                   j                  }| j                  |i «       | j                  «       }|j	                  d«      }| j                  |d   t        «       | 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.
        r   râ   N)rP   rh   r¬   rä   rÔ   rå   ræ   )r   ÚmyProcessesrè   Úfirsts       r&   Útest_processeszDeprecationTests.test_processes¤  sb   € ð —g‘g×'Ñ'ˆØ×Ñ˜+ rÔ*Ø×%Ñ%Ó'ˆØ—‘˜Q“ˆØ�‰�e˜JÑ'Ô);Ô<Ø×Ñ˜( BÕ'r(   c                 ó¢   — t        j                  | j                  «       | j                  «       }|D ]  }| j	                  |d   t
        «       Œ y)zO
        Pickling an L{ProcessMonitor} results in deprecation warnings
        râ   N)ÚpickleÚdumpsrP   rä   rå   ræ   )r   rè   rê   s      r&   Útest_getstatezDeprecationTests.test_getstate³  sG   € ô 	�‰�T—W‘WÔØ×%Ñ%Ó'ˆØò 	CˆGØ�M‰M˜' *Ñ-Ô/AÕBñ	Cr(   N)r9   r:   r;   r<   rT   rë   rï   ró   r=   r(   r&   rß   rß   „  s   „ ñò7òVò&(óCr(   rß   )r<   rñ   Útwisted.internet.errorr   r   r   Útwisted.internet.taskr   Útwisted.internet.testingr   Útwisted.loggerr   Útwisted.python.failurer	   Útwisted.runner.procmonr
   r   Útwisted.trialr   r   r?   ÚTestCaserK   ÚSynchronousTestCaserß   r=   r(   r&   ú<module>rý      sn   ðñó ç WÑ WÝ 'Ý 2Ý -Ý *ß BÝ "÷GDñ GDôT,˜-¨ô ,ô^v0�8×$Ñ$ô v0ôr6C�x×3Ñ3õ 6Cr(   