
    VhQ                     j    d Z ddlmZ ddlmZ ddlmZmZmZm	Z	 ddl
mZmZ ddl
mZ  G d d	e      Zy
)z,
Tests for the public interface of Automat.
    )reduce)TestCase)ArgSpec_getArgNames_getArgSpec_filterArgs   )MethodicalMachineNoTransition)_methodicalc                       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y)MethodicalTestsz)
    Tests for L{MethodicalMachine}.
    c                      G d dt               } |       }| j                  |j                         dg       | j                  |j                         dg       y)a!  
        L{MethodicalMachine} provides a way for you to declare a state machine
        with inputs, outputs, and states as methods.  When you have declared an
        input, an output, and a state, calling the input method in that state
        will produce the specified output.
        c                   N   e Zd Z e       Zej                         d        Zej                         d        Zej                         d        Z	ej                  d      d        Zej                         d        Zej                  eeeg       ej                  eee	g       y	)
7MethodicalTests.test_oneTransition.<locals>.Machinationc                      yzan inputN selfs    M/home/dcms/DCMS/lib/python3.12/site-packages/automat/_test/test_methodical.pyanInputz?MethodicalTests.test_oneTransition.<locals>.Machination.anInput           c                      y)z	an outputan-output-valuer   r   s    r   anOutputz@MethodicalTests.test_oneTransition.<locals>.Machination.anOutput!   s     )r   c                      y)zanother outputanother-output-valuer   r   s    r   anotherOutputzEMethodicalTests.test_oneTransition.<locals>.Machination.anotherOutput&   s     .r   Tinitialc                      yza stateNr   r   s    r   anStatez?MethodicalTests.test_oneTransition.<locals>.Machination.anState+   r   r   c                      y)zanother stateNr   r   s    r   anotherStatezDMethodicalTests.test_oneTransition.<locals>.Machination.anotherState/   r   r   enteroutputsN)__name__
__module____qualname__r
   machineinputr   outputr   r    stater%   r'   uponr   r   r   Machinationr      s    ')G]]_  ^^) ) ^^. . ]]4]( ) ]]_    LLxjLIg\M?Sr   r3   r   r   N)objectassertEqualr   )r   r3   ms      r   test_oneTransitionz"MethodicalTests.test_oneTransition   sM    	T& 	T8 M'8&9:'=&>?r   c                 8   t                G fddt              } |       }| j                  t              5 }|j                   ddd       | j                  dt        j                               | j                  |j                         y# 1 sw Y   KxY w)a4  
        L{MethodicalMachine} is an implementation detail.  If you attempt to
        access it on an instance of your class, you will get an exception.
        However, since tools may need to access it for the purposes of, for
        example, visualization, you may access it on the class itself.
        c                       e Zd ZW  Zy)@MethodicalTests.test_machineItselfIsPrivate.<locals>.MachinationN)r+   r,   r-   r.   )expectedMachines   r   r3   r:   C   s    %Gr   r3   Nz-MethodicalMachine is an implementation detail)	r
   r4   assertRaisesAttributeErrorr.   assertInstr	exceptionassertIs)r   r3   machinationcmr;   s       @r   test_machineItselfIsPrivatez+MethodicalTests.test_machineItselfIsPrivate:   s     ,-	&& 	& "m~. 	 "	 ;S=N	
 	k))?;	  	 s   BBc                     G d dt               } |       }|j                          | j                  |j                  d        |       }| j	                  t
              5 }|j                   ddd       | j                  |j                  d       | j                  dt        j                               y# 1 sw Y   KxY w)au  
        One of the benefits of using a state machine is that your output method
        implementations don't need to take invalid state transitions into
        account - the methods simply won't be called.  This property would be
        broken if client code called output methods directly, so output methods
        are not directly visible under their names.
        c                       e Zd Z e       ZdZej                         d        Zej                         d        Z	ej                  d      d        Z
e
j                  ee
e	g       y)	;MethodicalTests.test_outputsArePrivate.<locals>.Machinationr   c                      yr   r   r   s    r   r   zCMethodicalTests.test_outputsArePrivate.<locals>.Machination.anInput[   r   r   c                 .    | xj                   dz  c_         y N   )counterr   s    r   r   zDMethodicalTests.test_outputsArePrivate.<locals>.Machination.anOutput_   s    !r   Tr!   c                      y)za machine stateNr   r   s    r   r1   zAMethodicalTests.test_outputsArePrivate.<locals>.Machination.statec   r   r   r(   N)r+   r,   r-   r
   r.   rL   r/   r   r0   r   r1   r2   r   r   r   r3   rG   W   sw    ')GG]]_  ^^" " ]]4](" )" JJwehZJ@r   r3   rK   Nr   zlMachination.anOutput is a state-machine output method; to produce this output, call an input method instead.)
r4   r   r5   rL   r<   r=   r   r>   r?   r@   )r   r3   mach1mach2rC   s        r   test_outputsArePrivatez&MethodicalTests.test_outputsArePrivateN   s    	A& 	A$ *~. 	"NN	*A	
		 	s   B66B?c                      G d dt               } |       }| j                  |j                         dg       | j                  |j                         dg       y)zw
        Two machines may co-exist happily on the same instance; they don't
        interfere with each other.
        c                      e Zd Z e       Z e       Zej                         d        Zej                         d        Zej                  d      d        Z
ej                  d      d        Zej                         d        Zej                         d        Ze
j                  ee
eg       ej                  eeeg       y	)
8MethodicalTests.test_multipleMachines.<locals>.MultiMachc                      y)zinput ANr   r   s    r   inputAz?MethodicalTests.test_multipleMachines.<locals>.MultiMach.inputA   r   r   c                      y)zinput BNr   r   s    r   inputBz?MethodicalTests.test_multipleMachines.<locals>.MultiMach.inputB   r   r   Tr!   c                      y)z	initial ANr   r   s    r   initialAzAMethodicalTests.test_multipleMachines.<locals>.MultiMach.initialA   r   r   c                      y)z	initial BNr   r   s    r   initialBzAMethodicalTests.test_multipleMachines.<locals>.MultiMach.initialB   r   r   c                      yNAr   r   s    r   outputAz@MethodicalTests.test_multipleMachines.<locals>.MultiMach.outputA       r   c                      yNBr   r   s    r   outputBz@MethodicalTests.test_multipleMachines.<locals>.MultiMach.outputB   r`   r   N)r+   r,   r-   r
   abr/   rU   rW   r1   rY   r[   r0   r_   rd   r2   r   r   r   	MultiMachrS   }   s    !#A!#AWWY  WWY  WWTW" # WWTW" # XXZ  XXZ  MM&(WI6MM&(WI6r   rg   r^   rc   N)r4   r5   rU   rW   )r   rg   mms      r   test_multipleMachinesz%MethodicalTests.test_multipleMachinesw   sG    	7 	7> [se,se,r   c                 ~    ddl  G fddt              } |       }| j                  |j                         d       y)zR
        Outputs can be combined with the "collector" argument to "upon".
        r   Nc                      e Zd Z e       Zej                         d        Zej                         d        Zej                         d        Zej                  d      d        Z	e	j                  ee	eeg fd       y	)
4MethodicalTests.test_collectOutputs.<locals>.Machinec                      yr   r   r   s    r   r/   z:MethodicalTests.test_collectOutputs.<locals>.Machine.input   r   r   c                      yr]   r   r   s    r   r_   z<MethodicalTests.test_collectOutputs.<locals>.Machine.outputA   r`   r   c                      yrb   r   r   s    r   rd   z<MethodicalTests.test_collectOutputs.<locals>.Machine.outputB   r`   r   Tr!   c                      yr$   r   r   s    r   r1   z:MethodicalTests.test_collectOutputs.<locals>.Machine.state   r   r   c                 0    t        j                  |       S N)r   add)xoperators    r   <lambda>z=MethodicalTests.test_collectOutputs.<locals>.Machine.<lambda>   s    F8<<$; r   	collectorN)r+   r,   r-   r
   r6   r/   r0   r_   rd   r1   r2   )ru   s   r   Machinerl      s    !#AWWY  XXZ  XXZ  WWTW" # JJ'";	  r   ry   AB)ru   r4   r5   r/   )r   ry   r6   ru   s      @r   test_collectOutputsz#MethodicalTests.test_collectOutputs   s3     		f 	4 ID)r   c                      G d dt               } |       }| j                  t              5 }|j                  ddd       ddd       | j	                  dt        j                               y# 1 sw Y   /xY w)z>
        Input methods preserve their declared names.
        c                   v    e Zd Z e       Zej                         d        Zej                  d      d        Zy)-MethodicalTests.test_methodName.<locals>.Mechc                      yr   r   r   s    r   declaredInputNamez?MethodicalTests.test_methodName.<locals>.Mech.declaredInputName   r   r   Tr!   c                      y)r1   Nr   r   s    r   aStatez4MethodicalTests.test_methodName.<locals>.Mech.aState   r   r   N)	r+   r,   r-   r
   r6   r/   r   r1   r   r   r   r   Mechr~      sA    !#AWWY  WWTW" #r   r   toomany	argumentsNr   )r4   r<   	TypeErrorr   r>   r?   r@   )r   r   r6   rC   s       r   test_methodNamezMethodicalTests.test_methodName   sf    
		6 		 Fy) 	<Rv{;	<)3r||+<=	< 	<s   A..A7c                      G d dt               } |       }| j                  |j                  d      dg       | j                  |j                  d       y)zW
        If an input takes an argument, it will pass that along to its output.
        c                       e Zd Z e       Zej                         dd       Zej                  d      d        Zej                         dd       Zej                  eeeg       y):MethodicalTests.test_inputWithArguments.<locals>.Mechanismc                      yr   r   r   rt   ys      r   r/   z@MethodicalTests.test_inputWithArguments.<locals>.Mechanism.input   r   r   Tr!   c                      yr$   r   r   s    r   r1   z@MethodicalTests.test_inputWithArguments.<locals>.Mechanism.state   r   r   c                     || _         ||z   S rr   _xr   s      r   r0   zAMethodicalTests.test_inputWithArguments.<locals>.Mechanism.output   s    1ur   NrK   )	r+   r,   r-   r
   r6   r/   r1   r0   r2   r   r   r   	Mechanismr      so    !#AWWY  WWTW" # XXZ  JJuefX.r   r         N)r4   r5   r/   r   r   r   r6   s      r   test_inputWithArgumentsz'MethodicalTests.test_inputWithArguments   sE    
	/ 	/$ KaS)q!r   c                     G d dt               } |       }| j                  |j                  d      g d       | j                  |j                  d       | j                  |j                  d       | j                  |j                  d      g d       | j                  |j                  d       | j                  |j                  d       | j                  |j                  d	d      g d
       | j                  |j                  d	       | j                  |j                  d       | j                  |j                  dd      g d       | j                  |j                  d       | j                  |j                  d       y)z@
        Inputs pass arguments that output will accept.
        c                   (   e Zd Z e       Zej                         d	d       Zej                  d      d        Zej                         d        Zej                         d        Z	ej                         d        Z
ej                  eeee	e
g       y)
CMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanismc                      yr   r   r   s      r   r/   zIMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.input   r   r   Tr!   c                      yr$   r   r   s    r   r1   zIMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.state   r   r   c                     || _         |S rr   r   )r   rt   s     r   outputXzKMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputX      r   c                     || _         |S rr   )_y)r   r   s     r   outputYzKMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputY  r   r   c                      y rr   r   r   s    r   outputNoArgszPMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputNoArgs      r   Nr   )r+   r,   r-   r
   r6   r/   r1   r0   r   r   r   r2   r   r   r   r   r      s    !#AWWY  WWTW" # XXZ  XXZ  XXZ  JJuegw%EFr   r   r   )r   rK   NrK   r   rt   )r   rK   N   )r   r   N   r	   )r   )r   r	   NN)r4   r5   r/   r   r   r   s      r    test_outputWithSubsetOfArgumentsz0MethodicalTests.test_outputWithSubsetOfArguments   s)   
	G 	G6 K 	\2q!q! 	1|4q!q! 	A5q!q! 	a,7q!q!r   c                     t        j                          t        j                           G  fddt              } G d dt              } |       j	                           G d dt              } |       j	                           G d dt              } |       j	                           G d	 d
t              } |       j	                           G d dt              } |       j	                          y)zE
        The wrapped input function must have an empty body.
        c                       e Zd Z e       ZW  j                  e      5 Zej                         d        Zddd       W  j                   e
ej                        d       y# 1 sw Y   -xY w)AMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.Mechanismc                     t                yr   listr   s    r   r/   zGMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.Mechanism.input7  s	     Fr   Nzfunction body must be empty)r+   r,   r-   r
   r6   r<   
ValueErrorrC   r/   r5   r?   r@   r   s   r   r   r   3  sd    !#A"":. "  S.0MN s   A""A+r   c                       e Zd Z e       Zej                         d        Zej                  d      d        Zej                  eeg        y)NMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringc                      yr   r   r   s    r   r/   zTMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstring.inputD  r   r   Tr!   c                      yzstarting stateNr   r   s    r   startzTMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstring.startH  r   r   r(   N	r+   r,   r-   r
   r6   r/   r1   r   r2   r   r   r   MechanismWithDocstringr   A  sU    !#AWWY  WWTW"! #! JJuE2J6r   r   c                       e Zd Z e       Zej                         d        Zej                  d      d        Zej                  eeg        y)IMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPassc                      y rr   r   r   s    r   r/   zOMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPass.inputS  s    r   Tr!   c                      yr   r   r   s    r   r   zOMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPass.startW  r   r   r(   Nr   r   r   r   MechanismWithPassr   P  sU    !#AWWY  WWTW"! #! JJuE2J6r   r   c                       e Zd Z e       Zej                         d        Zej                  d      d        Zej                  eeg        y)UMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPassc                      yr   r   r   s    r   r/   z[MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPass.inputb  s     r   Tr!   c                      yr   r   r   s    r   r   z[MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPass.startg  r   r   r(   Nr   r   r   r   MechanismWithDocstringAndPassr   _  sU    !#AWWY  WWTW"! #! JJuE2J6r   r   c                       e Zd Z e       Zej                         d        Zej                  d      d        Zej                  eeg        y)LMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNonec                      y rr   r   r   s    r   r/   zRMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNone.inputr  r   r   Tr!   c                      yr   r   r   s    r   r   zRMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNone.startv  r   r   r(   Nr   r   r   r   MechanismReturnsNoner   o  sU    !#AWWY  WWTW"! #! JJuE2J6r   r   c                       e Zd Z e       Zej                         d        Zej                  d      d        Zej                  eeg        y)\MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNonec                      yr   r   r   s    r   r/   zbMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNone.input  s     r   Tr!   c                      yr   r   r   s    r   r   zbMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNone.start  r   r   r(   Nr   r   r   r   $MechanismWithDocstringAndReturnsNoner   ~  sU    !#AWWY  WWTW"! #! JJuE2J6r   r   N)r   _empty
_docstringr4   r/   )r   r   r   r   r   r   r   s   `      r   test_inputFunctionsMustBeEmptyz.MethodicalTests.test_inputFunctionsMustBeEmpty)  s     	 		O 		O	7V 	7 	 &&(	7 	7 	!!#	7F 	7 	&'--/	76 	7 	$$&	76 	7 	-.446r   c                 (      G  fddt               }y)z
        All the argument lists of the outputs for a given input must match; if
        one does not the call to C{upon} will raise a C{TypeError}.
        c                      e Zd Z e       Zej                         d        Zej                         d        Zej                         d        Z	ej                         d        Z
W  j                  e      5 Ze
j                  ee
ee	g       ddd       W  j                  d eej"                               W  j                  d eej"                               y# 1 sw Y   PxY w);MethodicalTests.test_inputOutputMismatch.<locals>.Mechanismc                      yr   r   r   re   s     r   nameOfInputzGMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.nameOfInput  r   r   c                      y)zan output that matchesNr   r   s     r   outputThatMatcheszMMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.outputThatMatches  r   r   c                      y)zan output that doesn't matchNr   )r   rf   s     r   outputThatDoesntMatchzQMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.outputThatDoesntMatch  r   r   c                      yr$   r   r   s    r   r1   zAMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.state  r   r   Nr   r   )r+   r,   r-   r
   r6   r/   r   r0   r   r   r1   r<   r   rC   r2   r>   r?   r@   r   s   r   r   r     s    !#AWWY  XXZ) ) XXZ/ / WWY  ""9- 

):<Q(R MM-R\\):;MM13r||3DE s   7CC%r   Nr4   r   r   s   ` r   test_inputOutputMismatchz(MethodicalTests.test_inputOutputMismatch  s    	F 	Fr   c                 x     G d dt               } |       }|j                         \  }| j                  |d       y)zI
        It is possible to write a self-loop by omitting "enter"
        c                   "   e Zd Z e       Zej                         d        Zej                         d        Zej                         d        Zej                  d      d        Z
d Ze
j                  eg        e
j                  eeg       y	)
1MethodicalTests.test_stateLoop.<locals>.Mechanismc                      yr   r   r   s    r   r/   z7MethodicalTests.test_stateLoop.<locals>.Mechanism.input  r   r   c                      yr   r   r   s    r   say_hiz8MethodicalTests.test_stateLoop.<locals>.Mechanism.say_hi  r   r   c                      y)Nhir   r   s    r   _start_say_hiz?MethodicalTests.test_stateLoop.<locals>.Mechanism._start_say_hi  r   r   Tr!   c                      yr$   r   r   s    r   r   z7MethodicalTests.test_stateLoop.<locals>.Mechanism.start  r   r   c                      y)za state with no inputsNr   r   s    r   said_hiz9MethodicalTests.test_stateLoop.<locals>.Mechanism.said_hi  r   r   )r*   N)r+   r,   r-   r
   r6   r/   r   r0   r   r1   r   r   r2   r   r   r   r   r     s    !#AWWY  WWY  XXZ  WWTW" #) JJubJ)JJvJ7r   r   r   N)r4   r   r5   )r   r   a_mechanism
a_greetings       r   test_stateLoopzMethodicalTests.test_stateLoop  s7    
	8 	82  k"))+T*r   c                 L     G d dt               } |       j                          y)zF
        It is possible to write a transition with no outputs
        c                       e Zd Z e       Zej                         d        Zej                  d      d        Zej                         d        Z	ej                  ee	       y)6MethodicalTests.test_defaultOutputs.<locals>.Mechanismc                      y)zfinal transitionNr   r   s    r   finishz=MethodicalTests.test_defaultOutputs.<locals>.Mechanism.finish  r   r   Tr!   c                      y)za start stateNr   r   s    r   r   z<MethodicalTests.test_defaultOutputs.<locals>.Mechanism.start  r   r   c                      y)za final stateNr   r   s    r   finishedz?MethodicalTests.test_defaultOutputs.<locals>.Mechanism.finished  r   r   )r)   N)r+   r,   r-   r
   r6   r/   r   r1   r   r   r2   r   r   r   r   r     sm    !#AWWY# # WWTW"  #  WWY    JJvXJ.r   r   N)r4   r   r   s     r   test_defaultOutputsz#MethodicalTests.test_defaultOutputs  s    
	/ 	/" 	r   c                     t        dddddddt        fdt        ff      }| j                  t	        |      dddt        fdt        fh       y)zC
        Type annotations should be included in the set of
        )re   rf   Nr   re   rf   )argsvarargsvarkwdefaults
kwonlyargskwonlydefaultsannotations)r   intr?   r5   r   )r   specs     r   test_getArgNamesz MethodicalTests.test_getArgNames  s\     sc3Z0
 	#SzC:.	
r   c                 ~    t        d       }t        d       }d}t        |i ||      \  }}| j                  ||       y)zl
        filterArgs() should not filter the `args` parameter
        if outputSpec accepts `*args`.
        c                       y rr   r   r   kwargss     r   rv   z1MethodicalTests.test_filterArgs.<locals>.<lambda>  r   r   c                       y rr   r   r  s     r   rv   z1MethodicalTests.test_filterArgs.<locals>.<lambda>   r   r   r   N)r   r   rA   )r   	inputSpec
outputSpecargsInargsOut_s         r   test_filterArgszMethodicalTests.test_filterArgs  sA    
   <=	 !=>
 Y
C
fg&r   c                 (      G  fddt               }y)zI
        A L{MethodicalMachine} can only have one initial state.
        c                       e Zd Z e       Zej                  d      d        ZW  j                  e      5  ej                  d      d        Z	ddd       y# 1 sw Y   yxY w)CMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFailTr!   c                      y)z&The first initial state -- this is OK.Nr   r   s    r   firstInitialStatezUMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFail.firstInitialState  r   r   c                      y)z4The second initial state -- results in a ValueError.Nr   r   s    r   secondInitialStatezVMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFail.secondInitialState  r   r   N)
r+   r,   r-   r
   r6   r1   r  r<   r   r  r   s   r   WillFailr  
  sp    !#AWWTW"9 #9 "":. K&K 'KK K Ks   AA"r  Nr   r   r  s   ` r   !test_multipleInitialStatesFailurez1MethodicalTests.test_multipleInitialStatesFailure  s    
	Kv 	Kr   c                 (      G  fddt               }y)zc
        A L{MethodicalMachine} can only have one transition per start/event
        pair.
        c                   B   e Zd Z e       Zej                  d      d        Zej                         d        Zej                         d        Z	ej                  e	eg        W  j                  e      5  ej                  e	eg        ddd       y# 1 sw Y   yxY w)AMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFailTr!   c                      y)zWe start here.Nr   r   s    r   r   zGMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.start   r   r   c                      y)zRainbows end.Nr   r   s    r   endzEMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.end$  r   r   c                      y)z	An event.Nr   r   s    r   eventzGMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.event(  r   r   r(   N)r+   r,   r-   r
   r6   r1   r   r  r/   r  r2   r<   r   r   s   r   r  r    s    !#AWWTW"! #! WWY    WWY  JJuCJ4"":. 9

5R
89 9 9s   7BBr  Nr   r  s   ` r   test_multipleTransitionsFailurez/MethodicalTests.test_multipleTransitionsFailure  s    	9v 	9r   c                 `    G d dt               } |       }| j                  t              5 }|j                          ddd       | j	                  dt        j                               | j	                  dt        |j                               |j                          | j                  t              5 }|j                          ddd       | j	                  dt        |j                               | j	                  dt        |j                               y# 1 sw Y   xY w# 1 sw Y   `xY w)z
        Calling any input method that lacks a transition for the machine's
        current state raises an informative L{NoTransition}.
        c                       e Zd Z e       Zej                  d      d        Zej                         d        Zej                         d        Z	ej                         d        Z
ej                  e	eg        y)FMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePathTr!   c                      y)zStart state.Nr   r   s    r   r   zLMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.start9  r   r   c                      y)z
End state.Nr   r   s    r   r  zJMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.end=  r   r   c                      y)zMove from start to end.Nr   r   s    r   advancezNMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.advanceA  r   r   c                      y)z%A transition from nowhere to nowhere.Nr   r   s    r   deadEndzNMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.deadEndE  r   r   N)r+   r,   r-   r
   r6   r1   r   r  r/   r&  r(  r2   r   r   r   OnlyOnePathr"  6  s    !#AWWTW" # WWY  WWY* * WWY8 8 JJwR(r   r)  Nr(  r   r  )r4   r<   r   r(  r>   r?   r@   r&  )r   r)  r.   rC   s       r   !test_badTransitionForCurrentStatez1MethodicalTests.test_badTransitionForCurrentState0  s    	)& 	)* -|, 	OO	iR\\!23gs2<<01|, 	OO	iR\\!23eS./	 	
	 	s   D4D$D!$D-c                 r     G d dt               }| j                   |       j                         ddd       y)a   
        L{MethodicalMachine.serializer} is a decorator that modifies its
        decoratee's signature to take a "state" object as its first argument,
        which is the "serialized" argument to the L{MethodicalMachine.state}
        decorator.
        c                       e Zd Z e       Zd Zej                  dd      d        Zej                  d      d        Zej                         d	        Z
y
)1MethodicalTests.test_saveState.<locals>.Mechanismc                     d| _         y rJ   valuer   s    r   __init__z:MethodicalTests.test_saveState.<locals>.Mechanism.__init__a  s	    
r   first-stateT
serializedr"   c                      yzFirst state.Nr   r   s    r   firstz7MethodicalTests.test_saveState.<locals>.Mechanism.firstd  r   r   second-stater4  c                      yzSecond state.Nr   r   s    r   secondz8MethodicalTests.test_saveState.<locals>.Mechanism.secondh  r   r   c                      || j                   dS Nmachine-state
some-valuer/  r   r1   s     r   savez6MethodicalTests.test_saveState.<locals>.Mechanism.savel       &+"&** r   N)r+   r,   r-   r
   r6   r1  r1   r7  r<  
serializerrC  r   r   r   r   r-  ^  si    !#A WWtW< = WWW/  0  \\^ r   r   r2  rK   r?  N)r4   r5   rC  r   s     r   test_saveStatezMethodicalTests.test_saveStateV  s7    	 	* 	K!.	
r   c                 P    G d dt               } |       }|j                          |j                         }|j                  |      }| j	                  |j
                  d       | j	                  |j                         d       | j	                  |j                         ddd       y)a/  
        L{MethodicalMachine.unserializer} decorates a function that becomes a
        machine-state unserializer; its return value is mapped to the
        C{serialized} parameter to C{state}, and the L{MethodicalMachine}
        associated with that instance's state is updated to that state.
        c                      e Zd Z e       Zd Zej                  dd      d        Zej                  d      d        Zej                         d	        Z	ej                         d
        Z
ej                         d        Zej                  e	ee
gd        ej                  e	eegd        ej                         d        Zej                         d        Zed        Zy)4MethodicalTests.test_restoreState.<locals>.Mechanismc                      d| _         d| _        y )NrK   Fr0  	ranOutputr   s    r   r1  z=MethodicalTests.test_restoreState.<locals>.Mechanism.__init__  s    
!&r   r2  Tr3  c                      yr6  r   r   s    r   r7  z:MethodicalTests.test_restoreState.<locals>.Mechanism.first  r   r   r8  r9  c                      yr;  r   r   s    r   r<  z;MethodicalTests.test_restoreState.<locals>.Mechanism.second  r   r   c                      yr   r   r   s    r   r/   z:MethodicalTests.test_restoreState.<locals>.Mechanism.input  r   r   c                      d| _         d| _        y)Nr	   TrK   rK  r   s    r   r0   z;MethodicalTests.test_restoreState.<locals>.Mechanism.output  s    
!%r   c                      y)Nr	   r   r   s    r   output2z<MethodicalTests.test_restoreState.<locals>.Mechanism.output2  s    r   c                     t        |       d   S Nr   r   r   s    r   rv   z=MethodicalTests.test_restoreState.<locals>.Mechanism.<lambda>  s    DGAJ r   rw   c                     t        |       d   S rT  r   r   s    r   rv   z=MethodicalTests.test_restoreState.<locals>.Mechanism.<lambda>  s    d1gaj r   c                      || j                   dS r>  r/  rB  s     r   rC  z9MethodicalTests.test_restoreState.<locals>.Mechanism.save  rD  r   c                      |d   | _         |d   S )NrA  r@  r/  )r   blobs     r   _restorez=MethodicalTests.test_restoreState.<locals>.Mechanism._restore  s    !,/
O,,r   c                 6     |        }|j                  |       |S rr   )rY  )clsrX  r   s      r   fromBlobz=MethodicalTests.test_restoreState.<locals>.Mechanism.fromBlob  s    ud#r   N)r+   r,   r-   r
   r6   r1  r1   r7  r<  r/   r0   rR  r2   rE  rC  unserializerrY  classmethodr\  r   r   r   r   rI    s   !#A' WWtW< = WWW/  0  WWY  XXZ 
 XXZ  JJufvh:NJOKKvy<PKQ\\^  ^^- -  r   r   Fr	   r8  r?  N)r4   r/   rC  r\  r5   rL  )r   r   m1rX  m2s        r   test_restoreStatez!MethodicalTests.test_restoreState{  s    0	 0	d [

wwy%u-Q'GGI!/	
r   c                 ^     G d dt               } |       }|j                  d      dgk(  sJ y)z_
        L{MethodicalMachine} can operate with type annotations on inputs and outputs.
        c                       e Zd Z e       Zej                         defd       Zej                         dedefd       Z	ej                  d      d        Z
e
j                  ee
e	g       y	)
AMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanismargc                      y)zAn inputNr   r   re  s     r   an_inputzJMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanism.an_input  r   r   returnc                     |dz   S rJ   r   rg  s     r   	an_outputzKMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanism.an_output  s    Qwr   Tr!   c                      y)zA stateNr   r   s    r   r1   zGMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanism.state  r   r   r(   N)r+   r,   r-   r
   r6   r/   r   rh  r0   rk  r1   r2   r   r   r   r   rd    s    !#AWWYC   XXZS S   WWTW" # JJxuykJBr   r   r	   r   N)r4   rh  )r   r   	mechanisms      r   test_allowBasicTypeAnnotationsz.MethodicalTests.test_allowBasicTypeAnnotations  s4    
	C 	C" K	!!!$+++r   N)r+   r,   r-   __doc__r7   rD   rP   ri   r{   r   r   r   r   r   r   r   r  r  r  r  r*  rF  ra  rn  r   r   r   r   r      s{    &@P<('
R'-R!*F>*"64"lc7JF@ +D0
$	'K$92$0L#
JF
P,r   r   N)ro  	functoolsr   unittestr   automat._methodicalr   r   r   r    r
   r   r   r   r   r   r   <module>rt     s,      O O . M,h M,r   