+
    Q�iÁQ  ã                   ól   € R t ^ RIHt ^ RIHt ^ RIHtHtHtH	t	 ^RI
HtHt ^RI
Ht  ! R R]4      tR# )	z,
Tests for the public interface of Automat.
)Úreduce)ÚTestCase)ÚArgSpecÚ_getArgNamesÚ_getArgSpecÚ_filterArgs)ÚMethodicalMachineÚNoTransition)Ú_methodicalc                   óœ   a € ] tR t^t o RtR tR tR tR tR t	R t
R tR	 tR
 tR tR tR tR tR tR tR tR tR tR tR tRtV tR# )ÚMethodicalTestsz!
Tests for L{MethodicalMachine}.
c                ó¶   €  ! R R\         4      pV! 4       pV P                  VP                  4       R.4       V P                  VP                  4       R.4       R# )zù
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                   ób  a € ] tR t^t o ]! 4       t]P                  4       R 4       t]P                  4       R 4       t	]P                  4       R 4       t
]P                  RR7      R 4       t]P                  4       R 4       t]P                  ]]]	.R7       ]P                  ]]]
.R7       R	tV tR
# )Ú7MethodicalTests.test_oneTransition.<locals>.Machinationc                ó   € R# ©zan inputN© ©Úselfs   &Ú?/usr/lib/python3/dist-packages/automat/_test/test_methodical.pyÚanInputÚ?MethodicalTests.test_oneTransition.<locals>.Machination.anInput   ó   ‚ ó    c                ó   € R# )z	an outputúan-output-valuer   r   s   &r   ÚanOutputÚ@MethodicalTests.test_oneTransition.<locals>.Machination.anOutput!   s   € ñ )r   c                ó   € R# )zanother outputúanother-output-valuer   r   s   &r   ÚanotherOutputÚEMethodicalTests.test_oneTransition.<locals>.Machination.anotherOutput&   s   € ñ .r   T©Úinitialc                ó   € R# ©za stateNr   r   s   &r   ÚanStateÚ?MethodicalTests.test_oneTransition.<locals>.Machination.anState+   r   r   c                ó   € R# )zanother stateNr   r   s   &r   ÚanotherStateÚDMethodicalTests.test_oneTransition.<locals>.Machination.anotherState/   r   r   ©ÚenterÚoutputsr   N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__r   ÚmachineÚinputr   Úoutputr   r    Ústater&   r)   ÚuponÚ__static_attributes__Ú__classdictcell__©Ú__classdict__s   @r   ÚMachinationr      sÄ   ø‡ € Ù'Ó)ˆGà�]‰]‹_ñó ðð �^‰^Óñ)ó ð)ð �^‰^Óñ.ó ð.ð �]‰] 4ˆ]Ó(ñó )ðð �]‰]‹_ñ ó ð ð �L‰L˜¨¸x¸jˆLÔIØ×Ñ˜g¨\ÀMÀ?Ð×SÒSr   r;   r   r   N)ÚobjectÚassertEqualr   )r   r;   Úms   &  r   Útest_oneTransitionÚ"MethodicalTests.test_oneTransition   sM   € ô	Tœ&ô 	Tñ8 ‹MˆØ×Ñ˜Ÿ™›Ð'8Ð&9Ô:Ø×Ñ˜Ÿ™›Ð'=Ð&>Ö?r   c                óZ  a€ \        4       o ! V3R lR\        4      pV! 4       pV P                  \        4      ;_uu_ 4       pVP                   RRR4       V P                  R\        XP                  4      4       V P                  VP                  S4       R#   + '       g   i     LS; i)a  
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                   ó   <€ ] tR t^Ct Z tRtR# )Ú@MethodicalTests.test_machineItselfIsPrivate.<locals>.Machinationr   N)r.   r/   r0   r1   r2   r7   )ÚexpectedMachines   €r   r;   rC   C   s   ø† Ù%ŒGr   r;   Nz-MethodicalMachine is an implementation detail)	r   r<   ÚassertRaisesÚAttributeErrorr2   ÚassertInÚstrÚ	exceptionÚassertIs)r   r;   ÚmachinationÚcmrD   s   &   @r   Útest_machineItselfIsPrivateÚ+MethodicalTests.test_machineItselfIsPrivate:   s|   ø€ ô ,Ó-ˆ÷	&œ&ô 	&ñ "“mˆØ×Ñœ~×.Ô.°"Ø×Ò÷ /à�‰Ø;¼SÀÇÁÓ=Nô	
ð 	�‰�k×)Ñ)¨?Ö;÷ /×.ús   ÁBÂB*	c                ó¤  €  ! R R\         4      pV! 4       pVP                  4        V P                  VP                  ^4       V! 4       pV P	                  \
        4      ;_uu_ 4       pVP                   RRR4       V P                  VP                  ^ 4       V P                  R\        XP                  4      4       R#   + '       g   i     LS; i)aE  
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                   óä   a € ] tR t^Wt o ]! 4       t^ t]P                  4       R 4       t]P                  4       R 4       t
]P                  RR7      R 4       t]P                  ]]]
.R7       RtV tR# )	Ú;MethodicalTests.test_outputsArePrivate.<locals>.Machinationc                ó   € R# r   r   r   s   &r   r   ÚCMethodicalTests.test_outputsArePrivate.<locals>.Machination.anInput[   r   r   c                ó8   € V ;P                   ^,          un         R# ©é   N)Úcounterr   s   &r   r   ÚDMethodicalTests.test_outputsArePrivate.<locals>.Machination.anOutput_   s   € à—’ Õ!—r   Tr"   c                ó   € R# )za machine stateNr   r   s   &r   r5   ÚAMethodicalTests.test_outputsArePrivate.<locals>.Machination.statec   r   r   r+   r   N)r.   r/   r0   r1   r   r2   rW   r3   r   r4   r   r5   r6   r7   r8   r9   s   @r   r;   rQ   W   s}   ø‡ € Ù'Ó)ˆGØˆGà�]‰]‹_ñó ðð �^‰^Óñ"ó ð"ð �]‰] 4ˆ]Ó(ñ"ó )ð"ð �J‰J�w e°h°ZˆJ×@Ò@r   r;   NzlMachination.anOutput is a state-machine output method; to produce this output, call an input method instead.)
r<   r   r=   rW   rE   rF   r   rG   rH   rI   )r   r;   Úmach1Úmach2rL   s   &    r   Útest_outputsArePrivateÚ&MethodicalTests.test_outputsArePrivateN   s—   € ô	Aœ&ô 	Añ$ “ˆØ�‰ŒØ×Ñ˜Ÿ™¨Ô*Ù“ˆØ×Ñœ~×.Ô.°"Ø�NŠN÷ /à×Ñ˜Ÿ™¨Ô*à�‰ðAä�—‘Óö	
÷	 /×.ús   Á'B?Â?C	c                ó¶   €  ! R R\         4      pV! 4       pV P                  VP                  4       R.4       V P                  VP                  4       R.4       R# )z_
Two machines may co-exist happily on the same instance; they don't
interfere with each other.
c                   óœ  a € ] tR t^}t o ]! 4       t]! 4       t]P                  4       R 4       t]P                  4       R 4       t	]P                  RR7      R 4       t]P                  RR7      R 4       t]P                  4       R 4       t]P                  4       R 4       t]P!                  ]]].4       ]P!                  ]	]].4       R	tV tR
# )Ú8MethodicalTests.test_multipleMachines.<locals>.MultiMachc                ó   € R# )zinput ANr   r   s   &r   ÚinputAÚ?MethodicalTests.test_multipleMachines.<locals>.MultiMach.inputA�   r   r   c                ó   € R# )zinput BNr   r   s   &r   ÚinputBÚ?MethodicalTests.test_multipleMachines.<locals>.MultiMach.inputB…   r   r   Tr"   c                ó   € R# )z	initial ANr   r   s   &r   ÚinitialAÚAMethodicalTests.test_multipleMachines.<locals>.MultiMach.initialA‰   r   r   c                ó   € R# )z	initial BNr   r   s   &r   ÚinitialBÚAMethodicalTests.test_multipleMachines.<locals>.MultiMach.initialB�   r   r   c                ó   € R # ©ÚAr   r   s   &r   ÚoutputAÚ@MethodicalTests.test_multipleMachines.<locals>.MultiMach.outputA‘   ó   € ár   c                ó   € R # ©ÚBr   r   s   &r   ÚoutputBÚ@MethodicalTests.test_multipleMachines.<locals>.MultiMach.outputB•   rs   r   r   N)r.   r/   r0   r1   r   ÚaÚbr3   rc   rf   r5   ri   rl   r4   rq   rw   r6   r7   r8   r9   s   @r   Ú	MultiMachra   }   sâ   ø‡ € Ù!Ó#ˆAÙ!Ó#ˆAà�W‰W‹Yñó ðð �W‰W‹Yñó ðð �W‰W˜TˆWÓ"ñó #ðð �W‰W˜TˆWÓ"ñó #ðð �X‰X‹Zñó ðð �X‰X‹Zñó ðð �M‰M˜& (¨W¨IÔ6Ø�M‰M˜& (¨W¨I×6Ò6r   r{   rp   rv   N)r<   r=   rc   rf   )r   r{   Úmms   &  r   Útest_multipleMachinesÚ%MethodicalTests.test_multipleMachinesw   sG   € ô	7œô 	7ñ> ‹[ˆØ×Ñ˜Ÿ™› s eÔ,Ø×Ñ˜Ÿ™› s eÖ,r   c                ó‚   a€ ^ RI o ! V3R lR\        4      pV! 4       pV P                  VP                  4       R4       R# )zB
Outputs can be combined with the "collector" argument to "upon".
Nc                   ó  <a € ] tR t^¦t o ]! 4       t]P                  4       R 4       t]P                  4       R 4       t]P                  4       R 4       t	]P                  RR7      R 4       t
]
P                  ]]
]]	.V3R lR7       R	tV tR
# )Ú4MethodicalTests.test_collectOutputs.<locals>.Machinec                ó   € R# r   r   r   s   &r   r3   Ú:MethodicalTests.test_collectOutputs.<locals>.Machine.input©   r   r   c                ó   € R # ro   r   r   s   &r   rq   Ú<MethodicalTests.test_collectOutputs.<locals>.Machine.outputA­   rs   r   c                ó   € R # ru   r   r   s   &r   rw   Ú<MethodicalTests.test_collectOutputs.<locals>.Machine.outputB±   rs   r   Tr"   c                ó   € R# r%   r   r   s   &r   r5   Ú:MethodicalTests.test_collectOutputs.<locals>.Machine.stateµ   r   r   c                ó0   <€ \        SP                  V 4      # ©N)r   Úadd)ÚxÚoperators   &€r   Ú<lambda>Ú=MethodicalTests.test_collectOutputs.<locals>.Machine.<lambda>½   s   ø€ ¤F¨8¯<©<¸Ô$;r   ©Ú	collectorr   N)r.   r/   r0   r1   r   r>   r3   r4   rq   rw   r5   r6   r7   r8   )r:   rŽ   s   @€r   ÚMachiner�   ¦   s¡   ù‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �X‰X‹Zñó ðð �X‰X‹Zñó ðð �W‰W˜TˆWÓ"ñó #ðð �J‰JØØØ˜'Ð"Ü;ð	 ÷ ò r   r“   ÚAB)rŽ   r<   r=   r3   )r   r“   r>   rŽ   s   &  @r   Útest_collectOutputsÚ#MethodicalTests.test_collectOutputs    s3   ø€ ó 	÷	”fô 	ñ4 ‹IˆØ×Ñ˜Ÿ™› DÖ)r   c                ó  €  ! R R\         4      pV! 4       pV P                  \        4      ;_uu_ 4       pVP                  RRR4       RRR4       V P	                  R\        XP                  4      4       R#   + '       g   i     L7; i)z.
Input methods preserve their declared names.
c                   óŠ   a € ] tR t^Èt o ]! 4       t]P                  4       R 4       t]P                  RR7      R 4       t	Rt
V tR# )Ú-MethodicalTests.test_methodName.<locals>.Mechc                ó   € R# r   r   r   s   &r   ÚdeclaredInputNameÚ?MethodicalTests.test_methodName.<locals>.Mech.declaredInputNameË   r   r   Tr"   c                ó   € R# )r5   Nr   r   s   &r   ÚaStateÚ4MethodicalTests.test_methodName.<locals>.Mech.aStateÏ   r   r   r   N)r.   r/   r0   r1   r   r>   r3   r›   r5   rž   r7   r8   r9   s   @r   ÚMechr™   È   sD   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �W‰W˜TˆWÓ"ñó #ör   r    ÚtooÚmanyÚ	argumentsNr›   )r<   rE   Ú	TypeErrorr›   rG   rH   rI   )r   r    r>   rL   s   &   r   Útest_methodNameÚMethodicalTests.test_methodNameÃ   sb   € ô
		”6ô 		ñ ‹FˆØ×Ñœy×)Ô)¨RØ×Ñ  v¨{Ô;÷ *à�‰Ð)¬3¨r¯|©|Ó+<Ö=÷ *×)ús   ´A7Á7B	c                ó®   €  ! R R\         4      pV! 4       pV P                  VP                  ^4      ^.4       V P                  VP                  ^4       R# )zG
If an input takes an argument, it will pass that along to its output.
c                   óæ   a € ] tR t^Ýt o ]! 4       t]P                  4       RR l4       t]P                  RR7      R 4       t]P                  4       RR l4       t]P                  ]]].4       Rt
V tR# )	Ú:MethodicalTests.test_inputWithArguments.<locals>.Mechanismc                ó   € R# r   r   ©r   r�   Úys   &&&r   r3   Ú@MethodicalTests.test_inputWithArguments.<locals>.Mechanism.inputà   r   r   Tr"   c                ó   € R# r%   r   r   s   &r   r5   Ú@MethodicalTests.test_inputWithArguments.<locals>.Mechanism.stateä   r   r   c                ó   € Wn         W,           # r‹   ©Ú_xr«   s   &&&r   r4   ÚAMethodicalTests.test_inputWithArguments.<locals>.Mechanism.outputè   s   € à”Ø•u�r   r±   N©rV   )r.   r/   r0   r1   r   r>   r3   r5   r4   r6   r7   r8   r9   s   @r   Ú	Mechanismr©   Ý   su   ø‡ € Ù!Ó#ˆAà�W‰W‹Yóó ðð �W‰W˜TˆWÓ"ñó #ðð �X‰X‹Zóó ðð �J‰J�u˜e f X×.Ò.r   rµ   N)r<   r=   r3   r²   ©r   rµ   r>   s   &  r   Útest_inputWithArgumentsÚ'MethodicalTests.test_inputWithArgumentsØ   sE   € ô
	/œô 	/ñ$ ‹KˆØ×Ñ˜Ÿ™ › a SÔ)Ø×Ñ˜Ÿ™˜qÖ!r   c                ó  €  ! R R\         4      pV! 4       pV P                  VP                  ^4      . RO4       V P                  VP                  ^4       V P                  VP                  ^4       V P                  VP                  ^R7      . RO4       V P                  VP                  ^4       V P                  VP                  ^4       V P                  VP                  ^^4      . RO4       V P                  VP                  ^4       V P                  VP                  ^4       V P                  VP                  ^^R7      . R	O4       V P                  VP                  ^4       V P                  VP                  ^4       R# )
z0
Inputs pass arguments that output will accept.
c                   ó>  a € ] tR t^øt o ]! 4       t]P                  4       R
R l4       t]P                  RR7      R 4       t]P                  4       R 4       t	]P                  4       R 4       t
]P                  4       R 4       t]P                  ]]]	]
].4       RtV tR	# )ÚCMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanismc                ó   € R# r   r   r«   s   &&&r   r3   ÚIMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.inputû   r   r   Tr"   c                ó   € R# r%   r   r   s   &r   r5   ÚIMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.stateÿ   r   r   c                ó   € Wn         V# r‹   r±   )r   r�   s   &&r   ÚoutputXÚKMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputX  ó   € à”Ø�r   c                ó   € Wn         V# r‹   )Ú_y)r   r¬   s   &&r   ÚoutputYÚKMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputY  rÃ   r   c                ó   € R # r‹   r   r   s   &r   ÚoutputNoArgsÚPMethodicalTests.test_outputWithSubsetOfArguments.<locals>.Mechanism.outputNoArgs  ó   € ár   )r²   rÅ   Nr´   )r.   r/   r0   r1   r   r>   r3   r5   r4   rÁ   rÆ   rÉ   r6   r7   r8   r9   s   @r   rµ   r»   ø   s®   ø‡ € Ù!Ó#ˆAà�W‰W‹Yóó ðð �W‰W˜TˆWÓ"ñó #ðð �X‰X‹Zñó ðð �X‰X‹Zñó ðð �X‰X‹Zñó ðð �J‰J�u˜e g¨w¸Ð%E×FÒFr   rµ   N©r�   )r¬   )é   rV   N)é   rV   N)é   rÍ   N)é   é   N)r<   r=   r3   r²   rÅ   r¶   s   &  r   Ú test_outputWithSubsetOfArgumentsÚ0MethodicalTests.test_outputWithSubsetOfArgumentsó   s)  € ô
	Gœô 	Gñ6 ‹Kˆð 	×Ñ˜Ÿ™ ›¢\Ô2Ø×Ñ˜Ÿ™˜qÔ!Ø×Ñ˜Ÿ™˜qÔ!ð 	×Ñ˜Ÿ™ 1˜›¢|Ô4Ø×Ñ˜Ÿ™˜qÔ!Ø×Ñ˜Ÿ™˜qÔ!ð 	×Ñ˜Ÿ™  A›ªÔ5Ø×Ñ˜Ÿ™˜qÔ!Ø×Ñ˜Ÿ™˜qÔ!ð 	×Ñ˜Ÿ™  a˜›ª,Ô7Ø×Ñ˜Ÿ™˜qÔ!Ø×Ñ˜Ÿ™˜qÖ!r   c                óè  a € \         P                  ! 4        \         P                  ! 4         ! V 3R lR\        4      p ! R R\        4      pV! 4       P	                  4         ! R R\        4      pV! 4       P	                  4         ! R R\        4      pV! 4       P	                  4         ! R	 R
\        4      pV! 4       P	                  4         ! R R\        4      pV! 4       P	                  4        R# )z5
The wrapped input function must have an empty body.
c                   ó  <a € ] tR tRt o ]! 4       t ZP                  ]4      ;_uu_ 4       t]P                  4       R 4       t	RRR4        ZP                  ]! ]P                  4      R4       RtV tR#   + '       g   i     L9; i)ÚAMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.Mechanismi3  c                ó   € \        4        R# r   ©Úlistr   s   &r   r3   ÚGMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.Mechanism.input7  s	   € ô –Fr   Nzfunction body must be emptyr   )r.   r/   r0   r1   r   r>   rE   Ú
ValueErrorrL   r3   r=   rH   rI   r7   r8   ©r:   r   s   @€r   rµ   rÖ   3  se   ù‡ € Ù!Ó#ˆAÙ×"Ñ" :×.Ô.°"à—‘“ñó ð÷ /ñ ×Ñ™S §¡Ó.Ð0M×NÒN÷ /×.ús   ¬A4Á4B	rµ   c                   ó²   a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  RR7      R 4       t]P                  ]]. R7       Rt
V tR# )	ÚNMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringiA  c                ó   € R# r   r   r   s   &r   r3   ÚTMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstring.inputD  r   r   Tr"   c                ó   € R# ©zstarting stateNr   r   s   &r   ÚstartÚTMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstring.startH  r   r   r+   r   N©r.   r/   r0   r1   r   r>   r3   r5   rã   r6   r7   r8   r9   s   @r   ÚMechanismWithDocstringrÞ   A  s[   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �W‰W˜TˆWÓ"ñ!ó #ð!ð �J‰J�u E°2ˆJ×6Ò6r   ræ   c                   ó²   a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  RR7      R 4       t]P                  ]]. R7       Rt
V tR# )	ÚIMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPassiP  c                ó   € R # r‹   r   r   s   &r   r3   ÚOMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPass.inputS  s   € ár   Tr"   c                ó   € R# râ   r   r   s   &r   rã   ÚOMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithPass.startW  r   r   r+   r   Nrå   r9   s   @r   ÚMechanismWithPassrè   P  s[   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �W‰W˜TˆWÓ"ñ!ó #ð!ð �J‰J�u E°2ˆJ×6Ò6r   rí   c                   ó²   a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  RR7      R 4       t]P                  ]]. R7       Rt
V tR# )	ÚUMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPassi_  c                ó   € R# r   r   r   s   &r   r3   Ú[MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPass.inputb  s   € ñ r   Tr"   c                ó   € R# râ   r   r   s   &r   rã   Ú[MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndPass.startg  r   r   r+   r   Nrå   r9   s   @r   ÚMechanismWithDocstringAndPassrï   _  s[   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �W‰W˜TˆWÓ"ñ!ó #ð!ð �J‰J�u E°2ˆJ×6Ò6r   rô   c                   ó²   a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  RR7      R 4       t]P                  ]]. R7       Rt
V tR# )	ÚLMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNoneio  c                ó   € R # r‹   r   r   s   &r   r3   ÚRMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNone.inputr  rË   r   Tr"   c                ó   € R# râ   r   r   s   &r   rã   ÚRMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismReturnsNone.startv  r   r   r+   r   Nrå   r9   s   @r   ÚMechanismReturnsNonerö   o  s[   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �W‰W˜TˆWÓ"ñ!ó #ð!ð �J‰J�u E°2ˆJ×6Ò6r   rû   c                   ó²   a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  RR7      R 4       t]P                  ]]. R7       Rt
V tR# )	Ú\MethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNonei~  c                ó   € R# r   r   r   s   &r   r3   ÚbMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNone.input�  s   € ñ r   Tr"   c                ó   € R# râ   r   r   s   &r   rã   ÚbMethodicalTests.test_inputFunctionsMustBeEmpty.<locals>.MechanismWithDocstringAndReturnsNone.start†  r   r   r+   r   Nrå   r9   s   @r   Ú$MechanismWithDocstringAndReturnsNonerý   ~  s[   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �W‰W˜TˆWÓ"ñ!ó #ð!ð �J‰J�u E°2ˆJ×6Ò6r   r  N)r
   Ú_emptyÚ
_docstringr<   r3   )r   rµ   ræ   rí   rô   rû   r  s   f      r   Útest_inputFunctionsMustBeEmptyÚ.MethodicalTests.test_inputFunctionsMustBeEmpty)  s¼   ø€ ô 	×ÒÔÜ×ÒÔ ÷		Oœô 		Oô	7¤Vô 	7ñ 	Ó ×&Ñ&Ô(ô	7¤ô 	7ñ 	Ó×!Ñ!Ô#ô	7¬Fô 	7ñ 	&Ó'×-Ñ-Ô/ô	7¤6ô 	7ñ 	Ó×$Ñ$Ô&ô	7´6ô 	7ñ 	-Ó.×4Ñ4Ö6r   c                ó,   a €  ! V 3R lR\         4      pR# )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                   ó  <a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  4       R 4       t	]P                  4       R 4       t
]P                  4       R 4       t ZP                  ]4      ;_uu_ 4       t]P                  ]]]	]
.4       RRR4        ZP!                  R]! ]P$                  4      4        ZP!                  R]! ]P$                  4      4       R	tV tR#   + '       g   i     L\; i)
Ú;MethodicalTests.test_inputOutputMismatch.<locals>.Mechanismi”  c                ó   € R# r   r   ©r   ry   s   &&r   ÚnameOfInputÚGMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.nameOfInput—  r   r   c                ó   € R# )zan output that matchesNr   r  s   &&r   ÚoutputThatMatchesÚMMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.outputThatMatches›  r   r   c                ó   € R# )zan output that doesn't matchNr   )r   rz   s   &&r   ÚoutputThatDoesntMatchÚQMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.outputThatDoesntMatchŸ  r   r   c                ó   € R# r%   r   r   s   &r   r5   ÚAMethodicalTests.test_inputOutputMismatch.<locals>.Mechanism.state£  r   r   Nr  r  r   )r.   r/   r0   r1   r   r>   r3   r  r4   r  r  r5   rE   r¤   rL   r6   rG   rH   rI   r7   r8   rÜ   s   @€r   rµ   r	  ”  sä   ù‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �X‰X‹Zñ)ó ð)ð �X‰X‹Zñ/ó ð/ð �W‰W‹Yñó ðñ ×"Ñ" 9×-Ô-°Ø—
‘
Ø Ð):Ð<QÐ(Rô÷ .ñ �M‰M˜-©¨R¯\©\Ó):Ô;Ù�M‰MÐ1±3°r·|±|Ó3D×EÒE÷ .×-ús   ÂC.Ã.C>	rµ   N©r<   ©r   rµ   s   f r   Útest_inputOutputMismatchÚ(MethodicalTests.test_inputOutputMismatchŽ  s   ø€ ÷	Fœö 	Fr   c                óz   €  ! R R\         4      pV! 4       pVP                  4       w  pV P                  VR4       R# )z9
It is possible to write a self-loop by omitting "enter"
c                   ó6  a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  4       R 4       t]P                  4       R 4       t	]P                  RR7      R 4       tR t]P                  ]. R	7       ]P                  ]]	.R	7       R
tV tR# )Ú1MethodicalTests.test_stateLoop.<locals>.Mechanismi³  c                ó   € R# r   r   r   s   &r   r3   Ú7MethodicalTests.test_stateLoop.<locals>.Mechanism.input¶  r   r   c                ó   € R# r   r   r   s   &r   Úsay_hiÚ8MethodicalTests.test_stateLoop.<locals>.Mechanism.say_hiº  r   r   c                ó   € R # )Úhir   r   s   &r   Ú_start_say_hiÚ?MethodicalTests.test_stateLoop.<locals>.Mechanism._start_say_hi¾  rË   r   Tr"   c                ó   € R# r%   r   r   s   &r   rã   Ú7MethodicalTests.test_stateLoop.<locals>.Mechanism.startÂ  r   r   c                ó   € R# )za state with no inputsNr   r   s   &r   Úsaid_hiÚ9MethodicalTests.test_stateLoop.<locals>.Mechanism.said_hiÆ  r   r   )r-   r   N)r.   r/   r0   r1   r   r>   r3   r   r4   r$  r5   rã   r)  r6   r7   r8   r9   s   @r   rµ   r  ³  s¤   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñó ðð �W‰W‹Yñó ðð �X‰X‹Zñó ðð �W‰W˜TˆWÓ"ñó #ðò)ð �J‰J�u bˆJÔ)Ø�J‰J�v¨ ˆJ×7Ò7r   rµ   r#  N)r<   r   r=   )r   rµ   Úa_mechanismÚ
a_greetings   &   r   Útest_stateLoopÚMethodicalTests.test_stateLoop®  s7   € ô
	8œô 	8ñ2  “kˆØ"×)Ñ)Ó+‰ˆØ×Ñ˜ TÖ*r   c                óN   €  ! R R\         4      pV! 4       P                  4        R# )z6
It is possible to write a transition with no outputs
c                   óÜ   a € ] tR tRt o ]! 4       t]P                  4       R 4       t]P                  RR7      R 4       t	]P                  4       R 4       t
]	P                  ]]
R7       RtV tR	# )
Ú6MethodicalTests.test_defaultOutputs.<locals>.MechanismiÕ  c                ó   € R# )zfinal transitionNr   r   s   &r   ÚfinishÚ=MethodicalTests.test_defaultOutputs.<locals>.Mechanism.finishØ  r   r   Tr"   c                ó   € R# )za start stateNr   r   s   &r   rã   Ú<MethodicalTests.test_defaultOutputs.<locals>.Mechanism.startÜ  r   r   c                ó   € R# )za final stateNr   r   s   &r   ÚfinishedÚ?MethodicalTests.test_defaultOutputs.<locals>.Mechanism.finishedà  r   r   )r,   r   N)r.   r/   r0   r1   r   r>   r3   r3  r5   rã   r8  r6   r7   r8   r9   s   @r   rµ   r1  Õ  ss   ø‡ € Ù!Ó#ˆAà�W‰W‹Yñ#ó ð#ð �W‰W˜TˆWÓ"ñ ó #ð ð �W‰W‹Yñ ó ð ð �J‰J�v XˆJ×.Ò.r   rµ   N)r<   r3  r  s   & r   Útest_defaultOutputsÚ#MethodicalTests.test_defaultOutputsÐ  s   € ô
	/œô 	/ñ" 	‹×ÑÖr   c                óœ   € \        RRRRRRR\        3R\        33R7      pV P                  \	        V4      RRR\        3R\        304       R# )z3
Type annotations should be included in the set of
ry   rz   N)ÚargsÚvarargsÚvarkwÚdefaultsÚ
kwonlyargsÚkwonlydefaultsÚannotations)ry   rz   r   )r   ÚintrH   r=   r   )r   Úspecs   & r   Útest_getArgNamesÚ MethodicalTests.test_getArgNamesè  s\   € ô ØØØØØØØœs˜ c¬3 ZÐ0ô
ˆð 	×ÑÜ˜ÓØ�#˜œS�z C¬ :Ð.ö	
r   c                óz   € \        R 4      p\        R 4      pRp\        V/ W4      w  rEV P                  W44       R# )zT
filterArgs() should not filter the `args` parameter
if outputSpec accepts `*args`.
c                  ó   € R # r‹   r   ©r=  Úkwargss   *,r   r�   Ú1MethodicalTests.test_filterArgs.<locals>.<lambda>ÿ  s   € ¹r   c                  ó   € R # r‹   r   rJ  s   *,r   r�   rL     s   € ¹r   Nr   )r   r   rJ   )r   Ú	inputSpecÚ
outputSpecÚargsInÚargsOutÚ_s   &     r   Útest_filterArgsÚMethodicalTests.test_filterArgsú  s;   € ô
  Ñ <Ó=ˆ	Ü Ñ!=Ó>ˆ
ØˆÜ  ¨¨YÓC‰
ˆØ�‰�fÖ&r   c                ó,   a €  ! V 3R lR\         4      pR# )z9
A L{MethodicalMachine} can only have one initial state.
c                   ó  <a € ] tR tRt o ]! 4       t]P                  RR7      R 4       t ZP                  ]	4      ;_uu_ 4        ]P                  RR7      R 4       t
RRR4       RtV tR#   + '       g   i     RtT tR# ; i)ÚCMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFaili
  Tr"   c                ó   € R# )z&The first initial state -- this is OK.Nr   r   s   &r   ÚfirstInitialStateÚUMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFail.firstInitialState  r   r   c                ó   € R# )z4The second initial state -- results in a ValueError.Nr   r   s   &r   ÚsecondInitialStateÚVMethodicalTests.test_multipleInitialStatesFailure.<locals>.WillFail.secondInitialState  r   r   Nr   )r.   r/   r0   r1   r   r>   r5   rY  rE   rÛ   r\  r7   r8   rÜ   s   @€r   ÚWillFailrW  
  sn   ù‡ € Ù!Ó#ˆAà�W‰W˜TˆWÓ"ñ9ó #ð9ñ ×"Ñ" :×.Õ.à—‘ �Ó&ñKó 'ðK÷ /×.×.×.Ò.ús   ÁA+Á+B 	r^  Nr  ©r   r^  s   f r   Ú!test_multipleInitialStatesFailureÚ1MethodicalTests.test_multipleInitialStatesFailure  s   ø€ ÷
	K”vö 	Kr   c                ó,   a €  ! V 3R lR\         4      pR# )zK
A L{MethodicalMachine} can only have one transition per start/event
pair.
c                   ó~  <a € ] tR tRt o ]! 4       t]P                  RR7      R 4       t]P                  4       R 4       t]P                  4       R 4       t
]P                  ]
]. R7        ZP                  ]4      ;_uu_ 4        ]P                  ]
]. R7       RRR4       R	tV tR#   + '       g   i     R	tT tR# ; i)
ÚAMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFaili  Tr"   c                ó   € R# )zWe start here.Nr   r   s   &r   rã   ÚGMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.start   r   r   c                ó   € R# )zRainbows end.Nr   r   s   &r   ÚendÚEMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.end$  r   r   c                ó   € R# )z	An event.Nr   r   s   &r   ÚeventÚGMethodicalTests.test_multipleTransitionsFailure.<locals>.WillFail.event(  r   r   r+   Nr   )r.   r/   r0   r1   r   r>   r5   rã   rh  r3   rk  r6   rE   rÛ   r7   r8   rÜ   s   @€r   r^  rd    s§   ù‡ € Ù!Ó#ˆAà�W‰W˜TˆWÓ"ñ!ó #ð!ð �W‰W‹Yñ ó ð ð �W‰W‹Yñó ðð �J‰J�u C°ˆJÔ4Ù×"Ñ" :×.Õ.Ø—
‘
˜5¨°R�
Ô8÷ /×.×.×.Ò.ús   ÂB'Â'B<	r^  Nr  r_  s   f r   Útest_multipleTransitionsFailureÚ/MethodicalTests.test_multipleTransitionsFailure  s   ø€ ÷	9”vö 	9r   c                óž  €  ! R R\         4      pV! 4       pV P                  \        4      ;_uu_ 4       pVP                  4        RRR4       V P	                  R\        XP                  4      4       V P	                  R\        VP                  4      4       VP                  4        V P                  \        4      ;_uu_ 4       pVP                  4        RRR4       V P	                  R\        VP                  4      4       V P	                  R\        VP                  4      4       R#   + '       g   i     Lì; i  + '       g   i     Lo; i)zy
Calling any input method that lacks a transition for the machine's
current state raises an informative L{NoTransition}.
c                   ó  a € ] tR tRt o ]! 4       t]P                  RR7      R 4       t]P                  4       R 4       t]P                  4       R 4       t
]P                  4       R 4       t]P                  ]
]. 4       RtV tR	# )
ÚFMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePathi6  Tr"   c                ó   € R# )zStart state.Nr   r   s   &r   rã   ÚLMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.start9  r   r   c                ó   € R# )z
End state.Nr   r   s   &r   rh  ÚJMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.end=  r   r   c                ó   € R# )zMove from start to end.Nr   r   s   &r   ÚadvanceÚNMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.advanceA  r   r   c                ó   € R# )z%A transition from nowhere to nowhere.Nr   r   s   &r   ÚdeadEndÚNMethodicalTests.test_badTransitionForCurrentState.<locals>.OnlyOnePath.deadEndE  r   r   r   N)r.   r/   r0   r1   r   r>   r5   rã   rh  r3   rw  rz  r6   r7   r8   r9   s   @r   ÚOnlyOnePathrq  6  s�   ø‡ € Ù!Ó#ˆAà�W‰W˜TˆWÓ"ñó #ðð �W‰W‹Yñó ðð �W‰W‹Yñ*ó ð*ð �W‰W‹Yñ8ó ð8ð �J‰J�w  R×(Ò(r   r|  Nrz  rã   rh  )r<   rE   r	   rz  rG   rH   rI   rw  )r   r|  r2   rL   s   &   r   Ú!test_badTransitionForCurrentStateÚ1MethodicalTests.test_badTransitionForCurrentState0  sÓ   € ô	)œ&ô 	)ñ* “-ˆØ×Ñœ|×,Ô,°Ø�O‰OÔ÷ -à�‰�i¤ R§\¡\Ó!2Ô3Ø�‰�gœs 2§<¡<Ó0Ô1Ø�‰ÔØ×Ñœ|×,Ô,°Ø�O‰OÔ÷ -à�‰�i¤ R§\¡\Ó!2Ô3Ø�‰�eœS §¡Ó.Ö/÷ -×,ú÷
 -×,ús   ´D)ÃD<Ä)D9	Ä<E	c                óv   €  ! R R\         4      pV P                  V! 4       P                  4       RRR^/4       R# )zØ
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                   óÂ   a € ] tR tRt o ]! 4       tR t]P                  RRR7      R 4       t]P                  RR7      R	 4       t	]P                  4       R
 4       tRtV tR# )Ú1MethodicalTests.test_saveState.<locals>.Mechanismi^  c                ó   € ^V n         R# rU   ©Úvaluer   s   &r   Ú__init__Ú:MethodicalTests.test_saveState.<locals>.Mechanism.__init__a  s	   € Ø�–
r   úfirst-stateT©Ú
serializedr#   c                ó   € R# ©zFirst state.Nr   r   s   &r   ÚfirstÚ7MethodicalTests.test_saveState.<locals>.Mechanism.firstd  r   r   úsecond-state©r‰  c                ó   € R# ©zSecond state.Nr   r   s   &r   ÚsecondÚ8MethodicalTests.test_saveState.<locals>.Mechanism.secondh  r   r   c                ó"   € R VRV P                   /# ©úmachine-stateú
some-valuerƒ  ©r   r5   s   &&r   ÚsaveÚ6MethodicalTests.test_saveState.<locals>.Mechanism.savel  ó   € ð $ UØ  $§*¡*ðð r   rƒ  N)r.   r/   r0   r1   r   r>   r…  r5   rŒ  r’  Ú
serializerr™  r7   r8   r9   s   @r   rµ   r�  ^  sl   ø‡ € Ù!Ó#ˆAòð �W‰W °tˆWÓ<ñó =ðð �W‰W ˆWÓ/ñ ó 0ð ð �\‰\‹^ñó ör   rµ   r–  r‡  r—  N)r<   r=   r™  r  s   & r   Útest_saveStateÚMethodicalTests.test_saveStateV  s;   € ô	œô 	ð* 	×ÑÙ‹K×ÑÓà Ø˜aðö	
r   c                óT  €  ! R R\         4      pV! 4       pVP                  4        VP                  4       pVP                  V4      pV P	                  VP
                  R4       V P	                  VP                  4       ^4       V P	                  VP                  4       RRR^/4       R# )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                   óÞ  a € ] tR tRt o ]! 4       tR t]P                  RRR7      R 4       t]P                  RR7      R	 4       t	]P                  4       R
 4       t
]P                  4       R 4       t]P                  4       R 4       t]P                  ]
]	].R R7       ]	P                  ]
]	].R R7       ]P                  4       R 4       t]P!                  4       R 4       t]R 4       tRtV tR# )Ú4MethodicalTests.test_restoreState.<locals>.Mechanismiƒ  c                ó"   € ^V n         RV n        R# )rV   FN©r„  Ú	ranOutputr   s   &r   r…  Ú=MethodicalTests.test_restoreState.<locals>.Mechanism.__init__†  s   € Ø�”
Ø!&�–r   r‡  Trˆ  c                ó   € R# r‹  r   r   s   &r   rŒ  Ú:MethodicalTests.test_restoreState.<locals>.Mechanism.firstŠ  r   r   rŽ  r�  c                ó   € R# r‘  r   r   s   &r   r’  Ú;MethodicalTests.test_restoreState.<locals>.Mechanism.secondŽ  r   r   c                ó   € R# r   r   r   s   &r   r3   Ú:MethodicalTests.test_restoreState.<locals>.Mechanism.input’  r   r   c                ó"   € ^V n         RV n        ^# )rÑ   Tr£  r   s   &r   r4   Ú;MethodicalTests.test_restoreState.<locals>.Mechanism.output–  s   € à�”
Ø!%�”Ùr   c                ó   € ^# )rÑ   r   r   s   &r   Úoutput2Ú<MethodicalTests.test_restoreState.<locals>.Mechanism.output2œ  s   € ár   c                ó&   € \        V 4      ^ ,          # ©é    rØ   rÌ   s   &r   r�   Ú=MethodicalTests.test_restoreState.<locals>.Mechanism.<lambda>   s   € ÄDÈÃGÈAÆJr   r‘   c                ó&   € \        V 4      ^ ,          # r²  rØ   rÌ   s   &r   r�   r´  ¡  s   € ÄdÈ1ÃgÈaÆjr   c                ó"   € R VRV P                   /# r•  rƒ  r˜  s   &&r   r™  Ú9MethodicalTests.test_restoreState.<locals>.Mechanism.save£  r›  r   c                ó0   € VR ,          V n         VR,          # )r—  r–  rƒ  )r   Úblobs   &&r   Ú_restoreÚ=MethodicalTests.test_restoreState.<locals>.Mechanism._restoreª  s   € à! ,Õ/�”
Ø˜OÕ,Ð,r   c                ó6   € V ! 4       pVP                  V4       V# r‹   )rº  )Úclsr¹  r   s   && r   ÚfromBlobÚ=MethodicalTests.test_restoreState.<locals>.Mechanism.fromBlob¯  s   € á“u�Ø—‘˜dÔ#Ø�r   )r¤  r„  N)r.   r/   r0   r1   r   r>   r…  r5   rŒ  r’  r3   r4   r¯  r6   rœ  r™  Úunserializerrº  Úclassmethodr¾  r7   r8   r9   s   @r   rµ   r¡  ƒ  s  ø‡ € Ù!Ó#ˆAò'ð �W‰W °tˆWÓ<ñó =ðð �W‰W ˆWÓ/ñ ó 0ð ð �W‰W‹Yñó ðð �X‰X‹Zñó ðð
 �X‰X‹Zñó ðð �J‰J�u˜f v hÑ:NˆJÔOØ�K‰K˜˜v¨ yÑ<PˆKÔQà�\‰\‹^ñó ðð �^‰^Óñ-ó ð-ð ñó ör   rµ   Fr–  rŽ  r—  N)r<   r3   r™  r¾  r=   r¤  )r   rµ   Úm1r¹  Úm2s   &    r   Útest_restoreStateÚ!MethodicalTests.test_restoreState{  sŒ   € ô0	œô 0	ñd ‹[ˆØ
�‰Œ
Ø�w‰w‹yˆØ×Ñ Ó%ˆØ×Ñ˜Ÿ™ uÔ-Ø×Ñ˜Ÿ™› QÔ'Ø×ÑØ�G‰G‹Ià Ø˜aðö	
r   c                ód   €  ! R R\         4      pV! 4       pVP                  ^4      ^.8X  g   Q hR# )zO
L{MethodicalMachine} can operate with type annotations on inputs and outputs.
c                   óø   a € ] tR tRt o ]! 4       t]P                  4       V 3R lR l4       t]P                  4       V 3R lR l4       t	]P                  RR7      R 4       t
]
P                  ]]
]	.R	7       R
tV tR# )ÚAMethodicalTests.test_allowBasicTypeAnnotations.<locals>.MechanismiÈ  c                ó    <€ V ^8„  d   QhRS[ /# )rÑ   Úarg©rD  )Úformatr:   s   "€r   Ú__annotate__ÚNMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanism.__annotate__Ì  s   ø€ ÷ ñ ¡Cñ r   c                ó   € R# )zAn inputNr   ©r   rÊ  s   &&r   Úan_inputÚJMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanism.an_inputË  r   r   c                ó&   <€ V ^8„  d   QhRS[ RS[ /# )rÑ   rÊ  ÚreturnrË  )rÌ  r:   s   "€r   rÍ  rÎ  Ð  s   ø€ ÷ ñ ¡Sð ©Sñ r   c                ó   € V^,           # r´   r   rÐ  s   &&r   Ú	an_outputÚKMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanism.an_outputÏ  s   € à˜Q•w�r   Tr"   c                ó   € R# )zA stateNr   r   s   &r   r5   ÚGMethodicalTests.test_allowBasicTypeAnnotations.<locals>.Mechanism.stateÓ  r   r   r+   r   N)r.   r/   r0   r1   r   r>   r3   rÑ  r4   rÖ  r5   r6   r7   r8   r9   s   @r   rµ   rÈ  È  sw   ø‡ € Ù!Ó#ˆAà�W‰W‹Y÷ó ðð �X‰X‹Z÷ó ðð �W‰W˜TˆWÓ"ñó #ðð �J‰J�x u°y°kˆJ×BÒBr   rµ   N)r<   rÑ  )r   rµ   Ú	mechanisms   &  r   Útest_allowBasicTypeAnnotationsÚ.MethodicalTests.test_allowBasicTypeAnnotationsÃ  s4   € ô
	Cœô 	Cñ" “Kˆ	Ø×!Ñ! !Ó$¨¨Ô+Ð+Ò+r   r   N)r.   r/   r0   r1   Ú__doc__r?   rM   r]   r}   r•   r¥   r·   rÒ   r  r  r-  r:  rF  rS  r`  rm  r}  r�  rÄ  rÛ  r7   r8   r9   s   @r   r   r      sƒ   ø‡ € ñò&@òP<ò('
òR'-òR!*òF>ò*"ò64"òlc7òJFò@ +òDò0
ò$	'òKò$9ò2$0òL#
òJF
÷P,ð ,r   r   N)rÝ  Ú	functoolsr   Úunittestr   Úautomat._methodicalr   r   r   r   Ú r   r	   r
   r   r   r   r   Ú<module>râ     s,   ðñõ Ý ç OÓ Oß .Ý ôM,�hö M,r   