+
    Q�i3V  ã                   ój  € ^ RI t ^ RIt^ RIt^ RIt^ RIt^ RIt^ RIHtHt R t	 ! R R]4      t
]! ]	! 4       '       * R4       ! R R]
4      4       t]! ]	! 4       '       * R4       ! R	 R
]
4      4       t]! ]	! 4       '       * R4       ! R R]4      4       t]! ]	! 4       '       * R4       ! R R]
4      4       tR# )é    N)ÚskipIfÚTestCasec                  óB   €  \        R 4       R#   \         d     R# i ; i)ÚtwistedTF)Ú
__import__ÚImportError© ó    Ú=/usr/lib/python3/dist-packages/automat/_test/test_discover.pyÚisTwistedInstalledr   
   s(   € ðÜ�9Ôñ øô ô Úðús   ‚ ��c                   óf   a a€ ] tR t^t oRtV 3R ltV 3R ltR tR tR t	R t
R tR	 tR
tVtV ;t# )Ú_WritesPythonModulesz?
A helper that enables generating Python module test fixtures.
c                óf  <€ \         \        V `  4        ^ RIHpHp ^ RIHp Wn        W n        W0n        \        \        P                  P                  4       4      V n        \        P                  R,          V n        \        P                   ! 4       V n        V P%                  V P"                  4       R# )r   )Ú	getModuleÚ
PythonPath)ÚFilePathºNNNN)Úsuperr   ÚsetUpÚtwisted.python.modulesr   r   Útwisted.python.filepathr   ÚsetÚsysÚmodulesÚkeysÚoriginalSysModulesÚpathÚsavedSysPathÚtempfileÚmkdtempÚpathDirÚmakeImportable)Úselfr   r   r   Ú	__class__s   &   €r   r   Ú_WritesPythonModules.setUp   sr   ø€ ÜÔ" DÑ/Ô1ç@Ý4à"ŒØ$ŒØ Œä"%¤c§k¡k×&6Ñ&6Ó&8Ó"9ˆÔÜŸH™H Q�KˆÔä×'Ò'Ó)ˆŒØ×Ñ˜DŸL™LÖ)r
   c                ó8  <€ \         \        V `  4        V P                  \        P
                  R &   \        P                  P                  4       V P                  ,
          pV F  p\        P                  V K  	  \        P                  ! V P                  4       R# )r   N)r   r   ÚtearDownr   r   r   r   r   r   ÚshutilÚrmtreer!   )r#   ÚmodulesToDeleteÚmoduler$   s   &  €r   r'   Ú_WritesPythonModules.tearDown(   si   ø€ ÜÔ" DÑ2Ô4à×'Ñ'Œ�‰�‰ÜŸ+™+×*Ñ*Ó,¨t×/FÑ/FÕFˆÛ%ˆFÜ—‘˜FÒ#ñ &ô 	�Š�d—l‘lÖ#r
   c                óD   € \         P                  P                  V4       R # ©N)r   r   Úappend)r#   r   s   &&r   r"   Ú#_WritesPythonModules.makeImportable2   s   € Ü�‰�‰˜Ör
   c                ó<  € V P                  V4      pVP                  V4      p\        VP                  R 4      ;_uu_ 4       pVP	                  \
        P                  ! V4      4       RRR4       V P                  VP                  .4      #   + '       g   i     L,; i)ÚwN)r   ÚchildÚopenr   ÚwriteÚtextwrapÚdedentr   )r#   Úsourcer   Ú
moduleNameÚ	directoryr+   Úfs   &&&&   r   ÚwriteSourceIntoÚ$_WritesPythonModules.writeSourceInto5   sn   € Ø—M‘M $Ó'ˆ	à—‘ Ó,ˆô �&—+‘+˜s×#Ô# qØ�G‰G”H—O’O FÓ+Ô,÷ $ð �‰ 	§¡Ð/Ó0Ð0÷ $×#ús   Á&BÂB	c                óv   € \         P                  P                  V4      w  rEV P                  WV4      V,          # r.   )Úosr   Úsplitextr<   )r#   r8   r   r9   ÚpythonModuleNameÚ_s   &&&&  r   Ú
makeModuleÚ_WritesPythonModules.makeModule@   s3   € Ü Ÿg™g×.Ñ.¨zÓ:ÑÐØ×#Ñ# F°*Ó=Ð>NÕOÐOr
   c                ó`   € VP                  4        Uu/ uF  q"P                  VbK  	  up# u upi r.   )ÚiterAttributesÚname)r#   ÚhasIterAttributesÚattrs   && r   ÚattributesAsDictÚ%_WritesPythonModules.attributesAsDictD   s+   € Ø,=×,LÑ,LÔ,NÓOÑ,N D—	‘	˜4’Ñ,NÑOÐOùÒOs   “+c                óD   € VP                  4        V P                  V4      # r.   )ÚloadrJ   )r#   r+   s   &&r   ÚloadModuleAsDictÚ%_WritesPythonModules.loadModuleAsDictG   s   € Ø�‰ŒØ×$Ñ$ VÓ,Ð,r
   c                óD   € V P                  V P                  WV4      4      # r.   )rN   rC   )r#   r8   r   rG   s   &&&&r   ÚmakeModuleAsDictÚ%_WritesPythonModules.makeModuleAsDictK   s   € Ø×$Ñ$ T§_¡_°VÀ4Ó%HÓIÐIr
   )r   r   r   r   r!   r   )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r   r'   r"   r<   rC   rJ   rN   rQ   Ú__static_attributes__Ú__classdictcell__Ú__classcell__©r$   Ú__classdict__s   @@r   r   r      s;   ù‡ € ñõ*õ $òò	1òPòPò-÷Jò Jr
   r   zTwisted is not installed.c                   óH   a a€ ] tR t^Ot oRtV 3R ltR tR tR tRt	Vt
V ;t# )ÚOriginalLocationTestsax  
Tests that L{isOriginalLocation} detects when a
L{PythonAttribute}'s FQPN refers to an object inside the module
where it was defined.

For example: A L{twisted.python.modules.PythonAttribute} with a
name of 'foo.bar' that refers to a 'bar' object defined in module
'baz' does *not* refer to bar's original location, while a
L{PythonAttribute} with a name of 'baz.bar' does.

c                óD   <€ \         \        V `  4        ^RIHp Wn        R# )é   ©ÚisOriginalLocationN)r   r^   r   Ú	_discoverrb   )r#   rb   r$   s   & €r   r   ÚOriginalLocationTests.setUp]   s   ø€ ÜÔ# TÑ0Ô2Ý2à"4Ör
   c                ó�   € RpV P                  WP                  R4      pV P                  V P                  VR,          4      4       R# )zv
L{isOriginalLocation} returns False when the attribute refers to an
object whose source module cannot be determined.
z~        class Fake(object):
            pass
        hasEmptyModule = Fake()
        hasEmptyModule.__module__ = None
        zempty_module_attr.pyz empty_module_attr.hasEmptyModuleN)rQ   r!   ÚassertFalserb   )r#   r8   Ú
moduleDicts   &  r   Útest_failsWithNoModuleÚ,OriginalLocationTests.test_failsWithNoModulec   sD   € ð
ˆð ×*Ñ*¨6·<±<ÐAWÓXˆ
à×ÑØ×#Ñ# JÐ/QÕ$RÓSö	
r
   c                ó   € RpRpV P                  WP                  R4       V P                  W P                  R4      pV P                  V P	                  VR,          4      4       V P                  V P	                  VR,          4      4       VR,          pV P                  V4      pVR,          pV P                  V P	                  V4      4       R	# )
z�
L{isOriginalLocation} returns False when the attribute refers to
an object outside of the module where that object was defined.
zâ        class ImportThisClass(object):
            pass
        importThisObject = ImportThisClass()
        importThisNestingObject = ImportThisClass()
        importThisNestingObject.nestedObject = ImportThisClass()
        zž        from original import (ImportThisClass,
                              importThisObject,
                              importThisNestingObject)
        úoriginal.pyúimporting.pyzimporting.ImportThisClasszimporting.importThisObjectz!importing.importThisNestingObjectz.importing.importThisNestingObject.nestedObjectN)rC   r!   rQ   rf   rb   rJ   )r#   ÚoriginalSourceÚimportingSourceÚimportingDictÚnestingObjectÚnestingObjectDictÚnestedObjects   &      r   Útest_failsWithDifferentModuleÚ3OriginalLocationTests.test_failsWithDifferentModuleu   sË   € ð
ˆðˆð 	�‰˜¯©°mÔDØ×-Ñ-ØŸ\™\¨>ó
ˆð 	×ÑØ×#Ñ# MÐ2MÕ$NÓOô	
ð 	×ÑØ×#Ñ# MÐ2NÕ$OÓPô	
ð &Ð&IÕJˆØ ×1Ñ1°-Ó@ÐØ(Ø<õ
ˆð 	×Ñ˜×0Ñ0°Ó>Ö?r
   c                óŒ  € \         P                  ! R4      pV P                  WP                  R4      pV P	                  V P                  VR,          4      4       V P	                  V P                  VR,          4      4       VR,          pV P                  V4      pVR,          pV P	                  V P                  V4      4       R# )z|
L{isOriginalLocation} returns True when the attribute refers to an
object inside the module where that object was defined.
zé
        class ThisClassWasDefinedHere(object):
            pass
        anObject = ThisClassWasDefinedHere()
        aNestingObject = ThisClassWasDefinedHere()
        aNestingObject.nestedObject = ThisClassWasDefinedHere()
        zm.pyzm.ThisClassWasDefinedHerezm.aNestingObjectzm.aNestingObject.nestedObjectN)r6   r7   rQ   r!   Ú
assertTruerb   rJ   )r#   ÚmSourceÚmDictrp   rq   rr   s   &     r   Útest_succeedsWithSameModuleÚ1OriginalLocationTests.test_succeedsWithSameModule›   s§   € ô
 —/’/ðó
ˆð ×%Ñ% g¯|©|¸VÓDˆØ�‰˜×/Ñ/°Ð6QÕ0RÓSÔTØ�‰˜×/Ñ/°Ð6HÕ0IÓJÔKàÐ0Õ1ˆØ ×1Ñ1°-Ó@ÐØ(Ð)HÕIˆà�‰˜×/Ñ/°Ó=Ö>r
   ra   )rS   rT   rU   rV   rW   r   rh   rs   ry   rX   rY   rZ   r[   s   @@r   r^   r^   O   s%   ù‡ € ñ
õ5ò
ò$$@÷L?ò ?r
   r^   c                   ó~   a a€ ] tR t^´t oRtV 3R ltR tV3R lR ltR tR t	R t
R	 tR
 tR tR tR tRtVtV ;t# )ÚFindMachinesViaWrapperTestsz¹
L{findMachinesViaWrapper} recursively yields FQPN,
L{MethodicalMachine} pairs in and under a given
L{twisted.python.modules.PythonModule} or
L{twisted.python.modules.PythonAttribute}.
c                óD   <€ \         \        V `  4        ^RIHp Wn        R# )r`   ©ÚfindMachinesViaWrapperN)r   r|   r   rc   r   )r#   r   r$   s   & €r   r   Ú!FindMachinesViaWrapperTests.setUp½   s   ø€ ÜÔ)¨4Ñ6Ô8Ý6à&<Ö#r
   c                óÈ   € RpV P                  WP                  R4      pVR,          pV P                  RVP                  4       3\	        V P                  V4      4      4       R# )z¤
When given a L{twisted.python.modules.PythonAttribute} that refers
directly to a L{MethodicalMachine}, L{findMachinesViaWrapper}
yields that machine and its FQPN.
úa        from automat import MethodicalMachine

        rootMachine = MethodicalMachine()
        úroot.pyúroot.rootMachineN©rQ   r!   ÚassertInrM   Úlistr   ©r#   r8   rg   ÚrootMachines   &   r   Útest_yieldsMachineÚ.FindMachinesViaWrapperTests.test_yieldsMachineÃ   s\   € ðˆð ×*Ñ*¨6·<±<ÀÓKˆ
Ø Ð!3Õ4ˆØ�‰Ø ×!1Ñ!1Ó!3Ð4Ü�×,Ñ,¨[Ó9Ó:ö	
r
   c                ó   <€ V ^8„  d   QhRR/# )r`   ÚreturnNr	   )Úformatr\   s   "€r   Ú__annotate__Ú(FindMachinesViaWrapperTests.__annotate__Ö   s   ø€ ÷ 
ñ 
¨ñ 
r
   c                óÈ   € RpV P                  WP                  R4      pVR,          pV P                  RVP                  4       3\	        V P                  V4      4      4       R# )zž
When given a L{twisted.python.modules.PythonAttribute} that refers
directly to a L{TypeMachine}, L{findMachinesViaWrapper} yields that
machine and its FQPN.
ae          from automat import TypeMachineBuilder
        from typing import Protocol, Callable
        class P(Protocol):
            def method(self) -> None: ...
        class C:...
        def buildBuilder() -> Callable[[C], P]:
            builder = TypeMachineBuilder(P, C)
            return builder.build()
        rootMachine = buildBuilder()
        rƒ   r„   Nr…   rˆ   s   &   r   Útest_yieldsTypeMachineÚ2FindMachinesViaWrapperTests.test_yieldsTypeMachineÖ   s\   € ð
ˆð ×*Ñ*¨6·<±<ÀÓKˆ
Ø Ð!3Õ4ˆØ�‰Ø ×!1Ñ!1Ó!3Ð4Ü�×,Ñ,¨[Ó9Ó:ö	
r
   c                óÜ   € RpV P                  WP                  R4      pVR,          pV P                  RVP                  4       P                  3\        V P                  V4      4      4       R# )zÅ
When given a L{twisted.python.modules.PythonAttribute} that refers
to a class that contains a L{MethodicalMachine} as a class
variable, L{findMachinesViaWrapper} yields that machine and
its FQPN.
úŠ        from automat import MethodicalMachine

        class PythonClass(object):
            _classMachine = MethodicalMachine()
        ú	clsmod.pyúclsmod.PythonClassú clsmod.PythonClass._classMachineN)rQ   r!   r†   rM   Ú_classMachiner‡   r   ©r#   r8   rg   ÚPythonClasss   &   r   Útest_yieldsMachineInClassÚ5FindMachinesViaWrapperTests.test_yieldsMachineInClassï   sb   € ðˆð ×*Ñ*¨6·<±<ÀÓMˆ
Ø Ð!5Õ6ˆØ�‰Ø/°×1AÑ1AÓ1C×1QÑ1QÐRÜ�×,Ñ,¨[Ó9Ó:ö	
r
   c                óð   € RpV P                  WP                  R4      pVR,          pV P                  RVP                  4       P                  P
                  3\        V P                  V4      4      4       R# )zÌ
When given a L{twisted.python.modules.PythonAttribute} that refers
to a nested class that contains a L{MethodicalMachine} as a
class variable, L{findMachinesViaWrapper} yields that machine
and its FQPN.
úµ        from automat import MethodicalMachine

        class PythonClass(object):
            class NestedClass(object):
                _classMachine = MethodicalMachine()
        únestedcls.pyúnestedcls.PythonClassú/nestedcls.PythonClass.NestedClass._classMachineN)rQ   r!   r†   rM   ÚNestedClassr™   r‡   r   rš   s   &   r   Útest_yieldsMachineInNestedClassÚ;FindMachinesViaWrapperTests.test_yieldsMachineInNestedClass  sm   € ðˆð ×*Ñ*¨6·<±<ÀÓPˆ
à Ð!8Õ9ˆØ�‰àAØ× Ñ Ó"×.Ñ.×<Ñ<ðô �×,Ñ,¨[Ó9Ó:ö	
r
   c                óæ   € RpV P                  WP                  R4      pV P                  V4      R,          P                  4       pV P	                  RV3\        V P                  V4      4      4       R# )z¯
When given a L{twisted.python.modules.PythonModule} that refers to
a module that contains a L{MethodicalMachine},
L{findMachinesViaWrapper} yields that machine and its FQPN.
r‚   rƒ   r„   N)rC   r!   rN   rM   r†   r‡   r   )r#   r8   r+   r‰   s   &   r   Útest_yieldsMachineInModuleÚ6FindMachinesViaWrapperTests.test_yieldsMachineInModule  se   € ðˆð
 —‘ ¯©°yÓAˆØ×+Ñ+¨FÓ3Ð4FÕG×LÑLÓNˆØ�‰Ø Ð-¬t°D×4OÑ4OÐPVÓ4WÓ/Xö	
r
   c                óú   € RpV P                  WP                  R4      pV P                  V4      R,          P                  4       pV P	                  RVP
                  3\        V P                  V4      4      4       R# )zÂ
When given a L{twisted.python.modules.PythonModule} that refers to
the original module of a class containing a
L{MethodicalMachine}, L{findMachinesViaWrapper} yields that
machine and its FQPN.
r•   r–   r—   r˜   N)rC   r!   rN   rM   r†   r™   r‡   r   ©r#   r8   r+   r›   s   &   r   Ú!test_yieldsMachineInClassInModuleÚ=FindMachinesViaWrapperTests.test_yieldsMachineInClassInModule-  sk   € ðˆð —‘ ¯©°{ÓCˆØ×+Ñ+¨FÓ3Ð4HÕI×NÑNÓPˆØ�‰Ø/°×1JÑ1JÐKÜ�×,Ñ,¨VÓ4Ó5ö	
r
   c                ó  € RpV P                  WP                  R4      pV P                  V4      R,          P                  4       pV P	                  RVP
                  P                  3\        V P                  V4      4      4       R# )zÉ
When given a L{twisted.python.modules.PythonModule} that refers to
the original module of a nested class containing a
L{MethodicalMachine}, L{findMachinesViaWrapper} yields that
machine and its FQPN.
rŸ   r    r¡   r¢   N)	rC   r!   rN   rM   r†   r£   r™   r‡   r   rª   s   &   r   Ú'test_yieldsMachineInNestedClassInModuleÚCFindMachinesViaWrapperTests.test_yieldsMachineInNestedClassInModuleA  sv   € ðˆð —‘ ¯©°~ÓFˆØ×+Ñ+¨FÓ3Ð4KÕL×QÑQÓSˆà�‰àAØ×'Ñ'×5Ñ5ðô �×,Ñ,¨VÓ4Ó5ö	
r
   c                óÐ   € RpRpV P                  WP                  R4       V P                  W P                  R4      pV P                  \        V P	                  V4      4      4       R# )a  
When given a L{twisted.python.modules.PythonAttribute} that refers
to a class imported from another module, any
L{MethodicalMachine}s on that class are ignored.

This behavior ensures that a machine is only discovered on a
class when visiting the module where that class was defined.
z‹
        from automat import MethodicalMachine

        class PythonClass(object):
            _classMachine = MethodicalMachine()
        z2
        from original import PythonClass
        rk   rl   N©rC   r!   rf   r‡   r   )r#   rm   rn   ÚimportingModules   &   r   Útest_ignoresImportedClassÚ5FindMachinesViaWrapperTests.test_ignoresImportedClassZ  sV   € ðˆðˆð 	�‰˜¯©°mÔDØŸ/™/¨/¿<¹<ÈÓXˆà×Ñœ˜d×9Ñ9¸/ÓJÓKÖLr
   c                ó®  € V P                  V P                  .4      pV P                  V P                  4      P                  R4      pVP	                  4        VP                  R4      P                  4        RpV P                  W2P                  R4       VR,          p\        V P                  V4      \        P                  ! ^ 4      R7      pV P                  VR,          4      pVR,          P                  4       pVR,          P                  4       p\        RV3R	VP                  3.\        P                  ! ^ 4      R7      p	V P                  W•4       R
# )zH
L{findMachinesViaWrapper} descends into packages to discover
machines.
Útest_packageú__init__.pyz¸
        from automat import MethodicalMachine


        class PythonClass(object):
            _classMachine = MethodicalMachine()


        rootMachine = MethodicalMachine()
        ú	module.py©Úkeyr+   ztest_package.module.rootMachineztest_package.module.PythonClassz-test_package.module.PythonClass._classMachineN)r   r!   r   r3   ÚmakedirsÚtouchrC   r   Úsortedr   ÚoperatorÚ
itemgetterrN   rM   r™   ÚassertEqual)
r#   Ú
pythonPathÚpackager8   r¶   Úmachinesrg   r‰   r›   ÚexpectedMachiness
   &         r   Útest_descendsIntoPackagesÚ5FindMachinesViaWrapperTests.test_descendsIntoPackagess  s)  € ð
 —_‘_ d§l¡l ^Ó4ˆ
Ø—-‘- §¡Ó-×3Ñ3°NÓCˆØ×ÑÔØ�‰�mÓ$×*Ñ*Ô,ð	ˆð 	�‰˜§¡¨kÔ:à! .Õ1ˆÜØ×'Ñ'¨Ó5¼8×;NÒ;NÈqÓ;Qô
ˆð ×*Ñ*¨<¸Õ+AÓBˆ
Ø Ð!BÕC×HÑHÓJˆØ Ð!BÕC×HÑHÓJˆä!à2°KÐ@àCØ×-Ñ-ððô ×#Ò# AÓ&ô	
Ðð 	×ÑÐ)Ö4r
   c                ó”   € RpV P                  WP                  R4      pV P                  \        V P	                  V4      4      4       R# )zi
L{findMachinesViaWrapper} ignores infinite loops.

Note this test can't fail - it can only run forever!
zh
        class InfiniteLoop(object):
            pass

        InfiniteLoop.loop = InfiniteLoop
        zloop.pyNr±   )r#   r8   r+   s   &  r   Útest_infiniteLoopÚ-FindMachinesViaWrapperTests.test_infiniteLoopŸ  s=   € ðˆð —‘ ¯©°yÓAˆØ×Ñœ˜d×9Ñ9¸&ÓAÓBÖCr
   r~   )rS   rT   rU   rV   rW   r   rŠ   r’   rœ   r¤   r§   r«   r®   r³   rÅ   rÈ   rX   rY   rZ   r[   s   @@r   r|   r|   ´   sO   ù‡ € ñõ=ò
÷&
ð 
ò2
ò(
ò2
ò"
ò(
ò2Mò2*5÷XDò Dr
   r|   c                   ór   a € ] tR tR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V tR# )ÚWrapFQPNTestsi¯  z�
Tests that ensure L{wrapFQPN} loads the
L{twisted.python.modules.PythonModule} or
L{twisted.python.modules.PythonAttribute} for a given FQPN.
c                óv   € ^ RI HpHp ^RIHpHpHpHp Wn        W n        W0n        W@n        WPn        W`n        R# )r   )ÚPythonModuleÚPythonAttribute)ÚwrapFQPNÚInvalidFQPNÚNoModuleÚNoObjectN)r   rÍ   rÎ   rc   rÏ   rÐ   rÑ   rÒ   )r#   rÍ   rÎ   rÏ   rÐ   rÑ   rÒ   s   &      r   r   ÚWrapFQPNTests.setUp·  s,   € ßHßIÓIà(ÔØ.ÔØ ŒØ&ÔØ ŒØ Žr
   c                óÈ   € V P                  WP                  4       V P                  VP                  VP                  4       V P                  VP                  4       V4       R# )z\
Assert that a L{twisted.python.modules.PythonModule} refers to a
particular Python module.
N)ÚassertIsInstancerÍ   rÀ   rG   rS   ÚassertIsrM   )r#   ÚmoduleWrapperr+   s   &&&r   ÚassertModuleWrapperRefersToÚ)WrapFQPNTests.assertModuleWrapperRefersToÂ  sI   € ð
 	×Ñ˜m×->Ñ->Ô?Ø×Ñ˜×+Ñ+¨V¯_©_Ô=Ø�‰�m×(Ñ(Ó*¨FÖ3r
   c                ó´   € V P                  WP                  4       V P                  VP                  V4       V P	                  VP                  4       V4       R# )z_
Assert that a L{twisted.python.modules.PythonAttribute} refers to a
particular Python object.
N)rÕ   rÎ   rÀ   rG   rÖ   rM   )r#   ÚattributeWrapperÚfqpnÚobjs   &&&&r   ÚassertAttributeWrapperRefersToÚ,WrapFQPNTests.assertAttributeWrapperRefersToË  sH   € ð
 	×ÑÐ.×0DÑ0DÔEØ×ÑÐ)×.Ñ.°Ô5Ø�‰Ð&×+Ñ+Ó-¨sÖ3r
   c                ó¨   € V P                  V P                  4      ;_uu_ 4        V P                  R4       RRR4       R#   + '       g   i     R# ; i)z?
L{wrapFQPN} raises L{InvalidFQPN} when given an empty string.
Ú N©ÚassertRaisesrÐ   rÏ   ©r#   s   &r   Útest_failsWithEmptyFQPNÚ%WrapFQPNTests.test_failsWithEmptyFQPNÔ  s6   € ð ×Ñ˜t×/Ñ/×0Õ0Ø�M‰M˜"Ô÷ 1×0×0Ò0úó   ¤A Á A	c                óº   € R F@  pV P                  V P                  4      ;_uu_ 4        V P                  V4       RRR4       KB  	  R#   + '       g   i     KW  ; i)zS"
L{wrapFQPN} raises L{InvalidFQPN} when given a badly-dotted
FQPN.  (e.g., x..y).
N)z.failszfails.zthis..failsrâ   ©r#   Úbads   & r   Útest_failsWithBadDottingÚ&WrapFQPNTests.test_failsWithBadDottingÛ  sC   € ó
 7ˆCØ×"Ñ" 4×#3Ñ#3×4Õ4Ø—‘˜cÔ"÷ 5Ñ4ó 7ß4×4Ð4úó   ©A	Á	Ac                ó¦   € ^ RI pV P                  R4      pV P                  W P                  4       V P	                  VP                  4       V4       R# )zw
L{wrapFQPN} returns a L{twisted.python.modules.PythonModule}
referring to the single module a dotless FQPN describes.
Nr?   )r?   rÏ   rÕ   rÍ   rÖ   rM   )r#   r?   r×   s   &  r   Útest_singleModuleÚWrapFQPNTests.test_singleModuleä  s@   € ó
 	àŸ™ dÓ+ˆà×Ñ˜m×->Ñ->Ô?Ø�‰�m×(Ñ(Ó*¨BÖ/r
   c                ó¨   € V P                  V P                  4      ;_uu_ 4        V P                  R4       RRR4       R#   + '       g   i     R# ; i)zf
L{wrapFQPN} raises L{NoModule} when given a dotless FQPN that does
not refer to a module or package.
zthis is not an acceptable name!N)rã   rÑ   rÏ   rä   s   &r   Ú*test_failsWithMissingSingleModuleOrPackageÚ8WrapFQPNTests.test_failsWithMissingSingleModuleOrPackageð  s5   € ð
 ×Ñ˜tŸ}™}×-Õ-Ø�M‰MÐ;Ô<÷ .×-×-Ò-úrç   c                óP   € ^ RI pV P                  V P                  R4      V4       R# )zx
L{wrapFQPN} returns a L{twisted.python.modules.PythonModule}
referring to the single package a dotless FQPN describes.
NÚxml)rõ   rØ   rÏ   ©r#   rõ   s   & r   Útest_singlePackageÚ WrapFQPNTests.test_singlePackageø  s    € ó
 	à×(Ñ(¨¯©°uÓ)=¸sÖCr
   c                ód   € ^ RI pV P                  V P                  R4      VP                  4       R# )zy
L{wrapFQPN} returns a L{twisted.python.modules.PythonModule}
referring to the deepest package described by dotted FQPN.
Nz	xml.etree)Ú	xml.etreerØ   rÏ   Úetreerö   s   & r   Útest_multiplePackagesÚ#WrapFQPNTests.test_multiplePackages  s$   € ó
 	à×(Ñ(¨¯©°{Ó)CÀSÇYÁYÖOr
   c                óx   € ^ RI pV P                  V P                  R4      VP                  P                  4       R# )zx
L{wrapFQPN} returns a L{twisted.python.modules.PythonModule}
referring to the deepest module described by dotted FQPN.
Nzxml.etree.ElementTree)Úxml.etree.ElementTreerØ   rÏ   rû   ÚElementTreerö   s   & r   Ú test_multiplePackagesFinalModuleÚ.WrapFQPNTests.test_multiplePackagesFinalModule
  s.   € ó
 	%à×(Ñ(Ø�M‰MÐ1Ó2°C·I±I×4IÑ4Iö	
r
   c                óf   € ^ RI pV P                  V P                  R4      RVP                  4       R# )z‡
L{wrapFQPN} returns a L{twisted.python.modules.PythonAttribute}
referring to the deepest object an FQPN names, traversing one module.
Nzos.path)r?   rÞ   rÏ   r   )r#   r?   s   & r   Útest_singleModuleObjectÚ%WrapFQPNTests.test_singleModuleObject  s)   € ó
 	à×+Ñ+Ø�M‰M˜)Ó$ i°·±ö	
r
   c                óÞ   € ^ RI p^ RIpRVP                  P                  P                  3RVP
                  P                  33 F&  w  r4V P                  V P                  V4      W44       K(  	  R# )zœ
L{wrapFQPN} returns a L{twisted.python.modules.PythonAttribute}
referring to the deepest object described by an FQPN,
descending through several packages.
Nz xml.etree.ElementTree.fromstringz!automat.MethodicalMachine.__doc__)	rÿ   Úautomatrû   r   Ú
fromstringÚMethodicalMachinerW   rÞ   rÏ   )r#   rõ   r  rÜ   rÝ   s   &    r   Útest_multiplePackagesObjectÚ)WrapFQPNTests.test_multiplePackagesObject   sa   € ó 	%Ûð 0°·±×1FÑ1F×1QÑ1QÐRØ0°'×2KÑ2K×2SÑ2SÐTó
‰IˆDð ×/Ñ/°·±¸dÓ0CÀTÖOó	
r
   c                óº   € R F@  pV P                  V P                  4      ;_uu_ 4        V P                  V4       RRR4       KB  	  R#   + '       g   i     KW  ; i)zj
L{wrapFQPN} raises L{NoObject} when given an FQPN that contains a
missing attribute, module, or package.
N)zxml.etree.nope!z*xml.etree.nope!.but.the.rest.is.believable)rã   rÒ   rÏ   ré   s   & r   Ú4test_failsWithMultiplePackagesMissingModuleOrPackageÚBWrapFQPNTests.test_failsWithMultiplePackagesMissingModuleOrPackage/  sC   € ó
 UˆCØ×"Ñ" 4§=¡=×1Õ1Ø—‘˜cÔ"÷ 2Ñ1ó Uß1×1Ð1úrí   )rÐ   rÑ   rÒ   rÎ   rÍ   rÏ   N)rS   rT   rU   rV   rW   r   rØ   rÞ   rå   rë   rï   rò   r÷   rü   r  r  r
  r  rX   rY   )r\   s   @r   rË   rË   ¯  sS   ø‡ € ñò	!ò4ò4òò#ò
0ò=òDòPò	
ò	
òP÷#ð #r
   rË   c                   ó@   a a€ ] tR tRt oRtRtV 3R ltR tRtVt	V ;t
# )ÚFindMachinesIntegrationTestsi9  zg
Integration tests to check that L{findMachines} yields all
machines discoverable at or below an FQPN.
zÚ
    from automat import MethodicalMachine

    class PythonClass(object):
        _machine = MethodicalMachine()
        ignored = "i am ignored"

    rootLevel = MethodicalMachine()

    ignored = "i am ignored"
    c                óÎ  <€ \         \        V `  4        ^RIHp Wn        V P                  V P                  4      P                  R4      pVP                  4        V P                  V P                  .4      V n
        V P                  V P                  VP                  R4       VP                  R4      pVP                  4        VP                  R4      P                  4        V P                  V P                  VP                  R4       V P!                  V P                  R,          4      V n        V P!                  V P                  R,          R,          R,          4      V n        R# )r`   )ÚfindMachinesr¶   r·   Ú
subpackager¸   r+   N)r   r  r   rc   r  r   r!   r3   r»   r   rÁ   r<   ÚSOURCEr   r¼   rC   rN   ÚpackageDictrg   )r#   r  Ú
packageDirÚsubPackageDirr$   s   &   €r   r   Ú"FindMachinesIntegrationTests.setUpL  s  ø€ ÜÔ*¨DÑ7Ô9Ý,à(Ôà—]‘] 4§<¡<Ó0×6Ñ6°~ÓFˆ
Ø×ÑÔØŸ/™/¨4¯<©<¨.Ó9ˆŒØ×Ñ˜TŸ[™[¨*¯/©/¸=ÔIà"×(Ñ(¨Ó6ˆØ×ÑÔ Ø×Ñ˜MÓ*×0Ñ0Ô2à�‰˜Ÿ™ ]×%7Ñ%7¸ÔEà×0Ñ0°·±ÀÕ1PÓQˆÔØ×/Ñ/Ø�O‰O˜NÕ+¨LÕ9¸(ÕCó
ˆŽr
   c                ó  € \        V P                  R4      \        P                  ! ^ 4      R7      pV P                  R,          P                  4       pV P                  R,          P                  4       pV P                  R,          pVP                  4       pV P                  R,          pVP                  4       p\        RV3RVP                  3RV3RVP                  3.\        P                  ! ^ 4      R7      pV P                  W�4       R	# )
zo
Given a top-level package FQPN, L{findMachines} discovers all
L{MethodicalMachine} instances in and below it.
r¶   r¹   ztest_package.rootLevelztest_package.PythonClassz(test_package.subpackage.module.rootLevelz*test_package.subpackage.module.PythonClassz!test_package.PythonClass._machinez3test_package.subpackage.module.PythonClass._machineN)	r½   r  r¾   r¿   r  rM   rg   Ú_machinerÀ   )	r#   rÃ   ÚtpRootLevelÚtpPythonClassÚmRLAttrÚ
mRootLevelÚmPCAttrÚmPythonClassrÄ   s	   &        r   Útest_discoverAllÚ-FindMachinesIntegrationTests.test_discoverAllb  sï   € ô
 ˜$×+Ñ+¨NÓ;Ä×ATÒATÐUVÓAWÔXˆà×&Ñ&Ð'?Õ@×EÑEÓGˆØ×(Ñ(Ð)CÕD×IÑIÓKˆà—/‘/Ð"LÕMˆØ—\‘\“^ˆ
Ø—/‘/Ð"NÕOˆØ—|‘|“~ˆä!à)¨;Ð7Ø4°m×6LÑ6LÐMØ;¸ZÐHàIØ ×)Ñ)ðð	ô ×#Ò# AÓ&ô
Ðð 	×ÑÐ)Ö4r
   )r  rg   r  rÁ   )rS   rT   rU   rV   rW   r  r   r!  rX   rY   rZ   r[   s   @@r   r  r  9  s    ù‡ € ñð

€Fõ
÷,5ò 5r
   r  )r¾   r?   r(   r   r6   r   Úunittestr   r   r   r   r^   r|   rË   r  r	   r
   r   Ú<module>r$     së   ðÛ Û 	Û Û 
Û Û ß %òô9J˜8ô 9Jñx ÑÓ Ô Ð"=Ó>ôa?Ð0ó a?ó ?ða?ñH ÑÓ Ô Ð"=Ó>ôwDÐ"6ó wDó ?ðwDñt ÑÓ Ô Ð"=Ó>ôF#�Hó F#ó ?ðF#ñR ÑÓ Ô Ð"=Ó>ôD5Ð#7ó D5ó ?òD5r
   