
    \d[                        d Z ddlmZ ddlmZ  G d dej                  Z G d dej                  Z G d d	ej                  Z	 G d
 dej                  Z
 G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d dej                  Z G d  d!ej                  Z G d" d#ej                  Z G d$ d%ej                  Z G d& d'ej                  Zd(S ))zK
Tests for L{twisted.python.usage}, a command line option parsing library.
    )usage)unittestc                   F    e Zd Zg dg dg dg dgZg dddggZd Zd	 Zd
S )WellBehaved)longwdefaultzand a docstring)anothernzno docstring)longonlyNnoshort)	shortlessNexceptzthis one got docstring)aflagfzO

                 flagallicious docstringness for this here

                 floutoc                     d| j         d<   d S )NPONY!myflagoptsselfs    7lib/python3.11/site-packages/twisted/test/test_usage.py
opt_myflagzWellBehaved.opt_myflag!   s    %	(    c                      | d| j         d<   d S )Nz WITH A PONY!myparamr   r   values     r   opt_myparamzWellBehaved.opt_myparam$   s    "'666	)r   N)__name__
__module____qualname__optParametersoptFlagsr   r"    r   r   r   r      s|        333(((%%%???	M	
 	
 	
 
#H& & &7 7 7 7 7r   r   c                   *    e Zd ZdZd Zd Zd Zd ZdS )ParseCorrectnessTestszZ
    Test L{usage.Options.parseOptions} for correct values under
    good conditions.
    c                     d                                 | _        t                      | _        | j                            | j                   dS )zL
        Instantiate and parseOptions a well-behaved Options class.
        A--long Alpha -n Beta --shortless Gamma -f --myflag --myparam TofuN)splitniceArgVr   niceparseOptionsr   s    r   setUpzParseCorrectnessTests.setUp.   sC     V
%'' 	  MM		t}-----r   c                 6   |                      | j        j        d         d           |                      | j        j        d         d           |                      | j        j        d         d           |                      | j        j        d         d           d	S )
z1
        Parameters have correct values.
        r   Alphar
   Betar   r   r   GammaNassertEqualr/   r   r   s    r   test_checkParametersz*ParseCorrectnessTests.test_checkParameters;   s     	/999	2F;;;
3Y???4g>>>>>r   c                     |                      | j        j        d         d           |                      | j        j        d         d           dS )z,
        Flags have correct values.
        r      r   r   Nr6   r   s    r   test_checkFlagsz%ParseCorrectnessTests.test_checkFlagsD   sH     	0!4440!44444r   c                     |                      | j        j        d         d           |                      | j        j        d         d           dS )zB
        Custom flags and parameters have correct values.
        r   r   r   zTofu WITH A PONY!Nr6   r   s    r   test_checkCustomsz'ParseCorrectnessTests.test_checkCustomsK   sI     	17;;;	24GHHHHHr   N)r#   r$   r%   __doc__r1   r8   r;   r=   r(   r   r   r*   r*   (   s_         
. . .? ? ?5 5 5I I I I Ir   r*   c                   L    e Zd Zddddegddddegdddd	egd
dddeggZd ZeZdS )TypedOptionsfoointN  zFoo intfoofloatQ@z	Foo floateggintzEgg int without defaulteggfloatzEgg float without defaultc                     || _         dS )zg
        This option has an underscore in its name to exercise the _ to -
        translation.
        N)underscoreValuer    s     r   opt_under_scorezTypedOptions.opt_under_score[   s    
  %r   )r#   r$   r%   intfloatr&   rI   opt_ur(   r   r   r@   r@   S   se        	4i-	T4e4	48#>	T4!<eD	M% % % EEEr   r@   c                   6    e Zd ZdZd Zd Zd Zd Zd Zd Z	dS )	
TypedTestszK
    Test L{usage.Options.parseOptions} for options with forced types.
    c                 ,    t                      | _        d S N)r@   r   r   s    r   r1   zTypedTests.setUpj   s    !^^


r   c                    g }| j                             |           |                     | j         j        d         d           |                     | j         j        d         t
                     |                     | j         j        d         d           |                     | j         j        d         t                     |                     | j         j        d                    |                     | j         j        d                    dS )z,
        Default values are parsed.
        rA   rB   rC   rD   rE   rF   N)r   r0   r7   r   assertIsInstancerJ   rK   assertIsNoner   argVs     r   test_defaultValueszTypedTests.test_defaultValuesm   s     
%%%2C888djoh7===4d;;;djoj95AAA$*/(3444$*/*566666r   c                    d                                 }| j                            |           |                     | j        j        d         d           |                     | j        j        d         t                     |                     | j        j        d         d           |                     | j        j        d         t                     |                     | j        j        d         d           |                     | j        j        d         t                     |                     | j        j        d         d	           |                     | j        j        d         t                     d
S )z2
        int and float values are parsed.
        z8--fooint 912 --foofloat -823.1 --eggint 32 --eggfloat 21rA   i  rC   g̸rE       rF   g      5@N)r-   r   r0   r7   r   rR   rJ   rK   rT   s     r   test_parsingValueszTypedTests.test_parsingValuesz   s*    NTTVV
%%%2C888djoh7===4f===djoj95AAA2B777djoh7===4d;;;djoj95AAAAAr   c                 ~    | j                             ddg           |                     | j         j        d           dS )zw
        A dash in an option name is translated to an underscore before being
        dispatched to a handler.
        z--under-scorefooNr   r0   r7   rH   r   s    r   test_underscoreOptionz TypedTests.test_underscoreOption   s@    
 	
% 89993U;;;;;r   c                 ~    | j                             ddg           |                     | j         j        d           dS )zE
        An option name with a dash in it can have an alias.
        z-ubarNr\   r   s    r   test_underscoreOptionAliasz%TypedTests.test_underscoreOptionAlias   s?     	
u...3U;;;;;r   c                     d                                 }|                     t          j        | j        j        |           dS )z7
        Passing wrong values raises an error.
        z--fooint eggN)r-   assertRaisesr   
UsageErrorr0   rT   s     r   test_invalidValueszTypedTests.test_invalidValues   s;     ##%%%*DJ,CTJJJJJr   N)
r#   r$   r%   r>   r1   rV   rY   r]   r`   rd   r(   r   r   rN   rN   e   s         $ $ $7 7 7B B B< < << < <K K K K Kr   rN   c                       e Zd Zg dgZdS )WrongTypedOptions)barwrongNNzBar with wrong coerceheN)r#   r$   r%   r&   r(   r   r   rf   rf      s        LLLMMMMr   rf   c                   6    e Zd Zd Zd ZddddegddddeggZdS )WeirdCallableOptionsc                      t          d          )NOuch)RuntimeErrorr!   s    r   _barzWeirdCallableOptions._bar   s    6"""r   c                      t          d          )NYay)
ValueErrorrn   s    r   _foozWeirdCallableOptions._foo   s    r   rg   NzBar with strange callablefoowrongzFoo with strange callable)r#   r$   r%   ro   rs   r&   r(   r   r   rj   rj      sS        # # #      
T4!<dC	T4!<dCMMMr   rj   c                   $    e Zd ZdZd Zd Zd ZdS )WrongTypedTestszF
    Test L{usage.Options.parseOptions} for wrong coerce options.
    c                     t                      }d                                }|                     t          |j        |           dS )z2
        Using a non-callable type fails.
        z--barwrong eggN)rf   r-   rb   	TypeErrorr0   r   usrU   s      r   test_nonCallablez WrongTypedTests.test_nonCallable   s@       %%'')R_d;;;;;r   c                 P    t                      }g }|                    |           dS )zP
        The coerce functions are not called if no values are provided.
        N)rj   r0   ry   s      r   test_notCalledInDefaultz'WrongTypedTests.test_notCalledInDefault   s,     "##
r   c                 b   t                      }d                                }|                     t          j        |j        |          }|                     t          |          d           t                      }d                                }|                     t          |j        |           dS )zI
        Errors raised by coerce functions are handled properly.
        z--foowrong blahz&Parameter type enforcement failed: Yayz--barwrong blahN)	rj   r-   rb   r   rc   r0   r7   strrm   )r   rz   rU   es       r   test_weirdCallablez"WrongTypedTests.test_weirdCallable   s     "## &&((e.FFQ!IJJJ!## &&((,>>>>>r   N)r#   r$   r%   r>   r{   r}   r   r(   r   r   rv   rv      sK         < < <  ? ? ? ? ?r   rv   c                       e Zd Zd ZdS )OutputTestsc                     t                      }|                     t          j        |j        dg          }|                     t          |          d           dS )zF
        Error output case adjustment does not mangle options
        z-Zzoption -Z not recognizedN)r   rb   r   rc   r0   r7   r   )r   optr   s      r   test_uppercasingzOutputTests.test_uppercasing   sO     mme.0@4&IIQ!;<<<<<r   N)r#   r$   r%   r   r(   r   r   r   r      s#        = = = = =r   r   c                       e Zd ZdgZdgZdS )InquisitionOptions)expectr   )torture-devicetcomfy-chairzset preferred torture deviceN)r#   r$   r%   r'   r&   r(   r   r   r   r      s%        H 	OMMMr   r   c                       e Zd ZddgZdS )HolyQuestOptions)	horsebackhzuse a horse)	for-grailgN)r#   r$   r%   r'   r(   r   r   r   r      s        )HHHr   r   c                   ,    e Zd ZdgZddedfddedfgZdS )	SubCommandOptions)europian-swallowNz$set default swallow type to EuropianinquisitioninquestzPerform an inquisition	holyquestquestzEmbark upon a holy questN)r#   r$   r%   r'   r   r   subCommandsr(   r   r   r   r      s=        JH 
	#57OP	g/1KLKKKr   r   c                   B    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zd
S )SubCommandTestszJ
    Test L{usage.Options.parseOptions} for options with subcommands.
    c                 ~   t                      }|                    ddg           |                     |d                    |                     |j        d           |                     |j        t                     |                     |j        d                    |                     |j        d         d           dS )z-
        A subcommand is recognized.
        --europian-swallowr   r   r   r   r   N)	r   r0   
assertTruer7   
subCommandrR   
subOptionsr   assertFalser   r   s     r   test_simpleSubcommandz%SubCommandTests.test_simpleSubcommand   s     	,m<===,-...}555al,>???h/000&67GGGGGr   c                 ~   t                      }|                    g d           |                     |d                    |                     |j        d           |                     |j        t                     |                     |j        d                    |                     |j        d         d           dS )zA
        Flags and options of a subcommand are assigned.
        )r   --expect--torture-device=featherr   r   r   r   featherN	r   r0   r   r7   r   rR   r   r   r   r   s     r   "test_subcommandWithFlagsAndOptionsz2SubCommandTests.test_subcommandWithFlagsAndOptions  s     	NNNOOO-.///}555al,>???X.///&67CCCCCr   c                 ~   t                      }|                    g d           |                     |d                    |                     |j        d           |                     |j        t                     |                     |j        d                    |                     |j        d         d           dS )zG
        Flags and options of a subcommand alias are assigned.
        )r   r   r   r   r   r   r   r   Nr   r   s     r   'test_subcommandAliasWithFlagsAndOptionsz7SubCommandTests.test_subcommandAliasWithFlagsAndOptions  s     	JJJKKK-.///}555al,>???X.///&67CCCCCr   c                 |   t                      }|                    ddg           |                     |d                    |                     |j        d           |                     |j        t                     |                     |j        d                    |                     |j        d                    dS )zG
        Flags and options of another subcommand are assigned.
        r   z--for-grailr   r   r   N)	r   r0   r   r7   r   rR   r   r   r   r   s     r   )test_anotherSubcommandWithFlagsAndOptionsz9SubCommandTests.test_anotherSubcommandWithFlagsAndOptions#  s     	]3444-.///{333al,<===k2333[122222r   c                     t                      }|                    dg           |                     |d                    |                     |j                   |                     t          |d                     dS )z
        If no subcommand is specified and no default subcommand is assigned,
        a subcommand will not be implied.
        r   r   r   N)r   r0   r   rS   r   r   hasattrr   s     r   test_noSubcommandz!SubCommandTests.test_noSubcommand/  sw    
 	,-...,-...!,'''L1122222r   c                    t                      }d|_        |                    dg           |                     |d                    |                     |j        d           |                     |j        t                     | 	                    |j        d                    |                     |j        d         d           dS )	zK
        Flags and options in the default subcommand are assigned.
        r   r   r   r   r   r   r   N)
r   defaultSubCommandr0   r   r7   r   rR   r   r   r   r   s     r   test_defaultSubcommandz&SubCommandTests.test_defaultSubcommand:  s     '	,-...,-...}555al,>???h/000&67GGGGGr   c                 <    G d dt           j                   G fddt           j                  } |            }|                    dg           |                     t	          |j        d                     |                     |j        j        |           dS )zw
        The parseOptions method from the Options object specified for the
        given subcommand is called.
        c                       e Zd Zd ZdS )DSubCommandTests.test_subCommandParseOptionsHasParent.<locals>.SubOptc                 R    | j         | _        t          j        j        | g|R i | d S rP   )parent	sawParentr   Optionsr0   )r   akws      r   r0   zQSubCommandTests.test_subCommandParseOptionsHasParent.<locals>.SubOpt.parseOptionsN  s4    !%*4:!:::r:::::r   N)r#   r$   r%   r0   r(   r   r   SubOptr   M  s#        ; ; ; ; ;r   r   c                       e Zd Zdd dfgZdS )ASubCommandTests.test_subCommandParseOptionsHasParent.<locals>.Optr[   r   r_   Nr#   r$   r%   r   r   s   r   Optr   R  s"        VU+KKKr   r   r[   r   N)r   r   r0   r   r   r   r7   r   )r   r   r   r   s      @r   $test_subCommandParseOptionsHasParentz4SubCommandTests.test_subCommandParseOptionsHasParentG  s    	; 	; 	; 	; 	;U] 	; 	; 	;
	 	 	 	 	 	 	%- 	 	 	
 CEE	wk::;;;/33333r   c                 @    G d dt           j                   G fddt           j                  } G fddt           j                  } |            }|                    dg            |            }|                    dg           |                     t	          |j        d	                     |                     t	          |j        d	                     |                     |j        j        |           |                     |j        j        |           d
S )zh
        The .parent pointer is correct even when the same Options class is
        used twice.
        c                       e Zd ZdS ):SubCommandTests.test_subCommandInTwoPlaces.<locals>.SubOptN)r#   r$   r%   r(   r   r   r   r   b  s        Dr   r   c                       e Zd Zdd dfgZdS ):SubCommandTests.test_subCommandInTwoPlaces.<locals>.OptFoor[   r   quuxNr   r   s   r   OptFoor   e  "        VV,KKKr   r   c                       e Zd Zdd dfgZdS ):SubCommandTests.test_subCommandInTwoPlaces.<locals>.OptBarr_   br   Nr   r   s   r   OptBarr   j  r   r   r   r[   r_   r   N)r   r   r0   r   r   r   failUnlessIdenticalr   )r   r   r   oFoooBarr   s        @r   test_subCommandInTwoPlacesz*SubCommandTests.test_subCommandInTwoPlaces\  sW   	 	 	 	 	U] 	 	 		 	 	 	 	 	 	U] 	 	 	
	 	 	 	 	 	 	U] 	 	 	
 vxx5'"""vxx5'"""::;;;::;;;  !7>>>  !7>>>>>r   N)r#   r$   r%   r>   r   r   r   r   r   r   r   r   r(   r   r   r   r      s         
H 
H 
H
D 
D 
D
D 
D 
D
3 
3 
3	3 	3 	3H H H4 4 4*? ? ? ? ?r   r   c                   $    e Zd ZdZd Zd Zd ZdS )HelpStringTestsz&
    Test generated help strings.
    c                 ^    d                                 | _        t                      | _        dS )z;
        Instantiate a well-behaved Options class.
        r,   N)r-   r.   r   r/   r   s    r   r1   zHelpStringTests.setUp~  s)     V
%'' 	  MM			r   c                     	 | j                                          dS # t          $ r }|                     |           Y d}~dS d}~ww xY w)z,
        __str__ shouldn't go boom.
        N)r/   __str__	Exceptionfail)r   r   s     r   test_noGoBoomzHelpStringTests.test_noGoBoom  s[    	I 	 	 	IIaLLLLLLLLL	s    
AAAc                    d t          | j                                                  D             }|                     t	          |          dk               |                     |d                             d          dk               dS )zK
        Extra whitespace in flag and parameters docs is stripped.
        c                 D    g | ]}|                     d           dk    |S )r   r   )find).0ss     r   
<listcomp>zJHelpStringTests.test_whitespaceStripFlagsAndParameters.<locals>.<listcomp>  s,    PPPq166'??a;O;O;O;O;Or   r   flagalliciousN)r   r/   
splitlinesr   lenr   )r   liness     r   &test_whitespaceStripFlagsAndParametersz6HelpStringTests.test_whitespaceStripFlagsAndParameters  su     QPC	NN5577PPPE

Q'''ao66!;<<<<<r   N)r#   r$   r%   r>   r1   r   r   r(   r   r   r   r   y  sK         	" 	" 	"  = = = = =r   r   c                       e Zd ZdZd Zd ZdS )PortCoerceTestsz3
    Test the behavior of L{usage.portCoerce}.
    c                     |                      dt          j        d                     |                      dt          j        d                     |                      dt          j        d                     dS )z4
        Test the answers with valid input.
        r   0i  3210i  65535N)r7   r   
portCoercer   s    r   test_validCoercez PortCoerceTests.test_validCoerce  sm     	E,S11222u/77888 0 9 9:::::r   c                 6   |                      t          t          j        d           |                      t          t          j        d           |                      t          t          j        d           |                      t          t          j        d           dS )z"
        Test error path.
         z-21212189r[   N)rb   rr   r   r   r   s    r   test_errorCoercez PortCoerceTests.test_errorCoerce  sv     	*e&6;;;*e&6>>>*e&6AAA*e&6>>>>>r   N)r#   r$   r%   r>   r   r   r(   r   r   r   r     s<         ; ; ;? ? ? ? ?r   r   c                   N    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S )ZshCompleterTestsz
    Test the behavior of the various L{twisted.usage.Completer} classes
    for producing output usable by zsh tab-completion system.
    c                 0   t          j                    }|                    dt           j                  }|                     |d           t          j        dd          }|                    dt           j                  }|                     |d           dS )zX
        Completer produces zsh shell-code that produces no completion matches.
        some-optionz:some-option:some actionTdescrrepeat*:some action:N)r   	Completer
_shellCode_ZSHr7   r   cgots      r   test_completerz ZshCompleterTests.test_completer  s     Oll=%*55o...O-===ll=%*55./////r   c                    t          j                    }|                    dt           j                  }|                     |d           t          j        d          }|                    dt           j                  }|                     |d           t          j        ddd          }|                    dt           j                  }|                     |d           d	S )
zn
        CompleteFiles produces zsh shell-code that completes file names
        according to a glob.
        r   z:some-option (*):_files -g "*"z*.pyz$:some-option (*.py):_files -g "*.py"r   Tr   z%*:some action (*.py):_files -g "*.py"N)r   CompleteFilesr   r   r7   r   s      r   
test_fileszZshCompleterTests.test_files  s    
 !!ll=%*55>???''ll=%*55DEEEmDIIIll=%*55EFFFFFr   c                 0   t          j                    }|                    dt           j                  }|                     |d           t          j        dd          }|                    dt           j                  }|                     |d           dS )zV
        CompleteDirs produces zsh shell-code that completes directory names.
        r   z:some-option:_directoriesr   Tr   z*:some action:_directoriesN)r   CompleteDirsr   r   r7   r   s      r   	test_dirszZshCompleterTests.test_dirs  s       ll=%*559:::]4@@@ll=%*55:;;;;;r   c                    t          j        d          }|                    dt           j                  }|                     |d           t          j        g d          }|                    dt           j                  }|                     |d           t          j        g ddd          }|                    dt           j                  }|                     |d	           d
S )zw
        CompleteList produces zsh shell-code that completes words from a fixed
        list of possibilities.
        ABCr   z:some-option:(A B C)123z:some-option:(1 2 3)r   Tr   z*:some action:(1 2 3)N)r   CompleteListr   r   r7   r   s      r   	test_listzZshCompleterTests.test_list  s    
 u%%ll=%*554555//ll=%*554555mDQQQll=%*55566666r   c                    t          j        d          }|                    dt           j                  }|                     |d           t          j        g d          }|                    dt           j                  }|                     |d           t          j        g ddd          }|                    dt           j                  }d	}|                     ||           d
S )z
        CompleteMultiList produces zsh shell-code that completes multiple
        comma-separated words from a fixed list of possibilities.
        r  r   z-:some-option:_values -s , 'some-option' A B Cr  z-:some-option:_values -s , 'some-option' 1 2 3r   Tr   z.*:some action:_values -s , 'some action' 1 2 3N)r   CompleteMultiListr   r   r7   )r   r  r  expecteds       r   test_multiListz ZshCompleterTests.test_multiList  s    
 #E**ll=%*55MNNN#OOO44ll=%*55MNNN#OOO=QUVVVll=%*55Ch'''''r   c                 0   t          j                    }|                    dt           j                  }|                     |d           t          j        dd          }|                    dt           j                  }|                     |d           dS )zd
        CompleteUsernames produces zsh shell-code that completes system
        usernames.
        r   z:some-option:_usersr   Tr   z*:some action:_usersN)r   CompleteUsernamesr   r   r7   r   r  outs      r   test_usernamesz ZshCompleterTests.test_usernames  s    
 #%%ll=%*553444#-EEEll=%*55455555r   c                 0   t          j                    }|                    dt           j                  }|                     |d           t          j        dd          }|                    dt           j                  }|                     |d           dS )zc
        CompleteGroups produces zsh shell-code that completes system group
        names.
        r   z:group:_groupsr   Tr   z*:some action:_groupsN)r   CompleteGroupsr   r   r7   r  s      r   test_groupszZshCompleterTests.test_groups  s    
  ""ll=%*55./// }TBBBll=%*55566666r   c                 0   t          j                    }|                    dt           j                  }|                     |d           t          j        dd          }|                    dt           j                  }|                     |d           dS )zU
        CompleteHostnames produces zsh shell-code that completes hostnames.
        r   z:some-option:_hostsr   Tr   z*:some action:_hostsN)r   CompleteHostnamesr   r   r7   r  s      r   test_hostnamesz ZshCompleterTests.test_hostnames   s     #%%ll=%*553444#-EEEll=%*55455555r   c                 x   t          j                    }|                    dt           j                  }|                     |                    d                     t          j        dd          }|                    dt           j                  }|                     |                    d                     dS )z
        CompleteUserAtHost produces zsh shell-code that completes hostnames or
        a word of the form <username>@<hostname>.
        r   z:host | user@host:r   Tr   r   N)r   CompleteUserAtHostr   r   r   
startswithr  s      r   test_userAtHostz!ZshCompleterTests.test_userAtHost,  s    
 $&&ll=%*55';<<===$=FFFll=%*55'78899999r   c                 0   t          j                    }|                    dt           j                  }|                     |d           t          j        dd          }|                    dt           j                  }|                     |d           dS )zv
        CompleteNetInterfaces produces zsh shell-code that completes system
        network interface names.
        r   z:some-option:_net_interfacesr   Tr   z*:some action:_net_interfacesN)r   CompleteNetInterfacesr   r   r7   r  s      r   test_netInterfacesz$ZshCompleterTests.test_netInterfaces9  s    
 '))ll=%*55<==='mDIIIll=%*55=>>>>>r   N)r#   r$   r%   r>   r  r  r	  r  r  r  r  r   r$  r'  r(   r   r   r   r     s         

0 
0 
0G G G"
< 
< 
<7 7 7"( ( ($6 6 67 7 7
6 
6 
6: : :? ? ? ? ?r   r   c                       e Zd ZdZd ZdS )CompleterNotImplementedTestszs
    Using an unknown shell constant with the various Completer() classes
    should raise NotImplementedError
    c           
         t           j        t           j        t           j        t           j        t           j        t           j        t           j        t           j        t           j	        t           j
        g
}|D ]K}	  |            }n# t          $ r  |d          }Y nw xY w|                     t          |j        dd           LdS )zM
        Using an unknown shellType should raise NotImplementedError
        Nbad_shell_type)r   r   r  r  r  r  r  r  r  r"  r&  BaseExceptionrb   NotImplementedErrorr   )r   classesclsactions       r   test_unknownShellz.CompleterNotImplementedTests.test_unknownShellM  s    
 O## #$'
  	 	C#  # # #T##V%6>N   	 	s   6
BBBN)r#   r$   r%   r>   r1  r(   r   r   r)  r)  G  s-         
    r   r)  c                   D    e Zd ZdZ G d d          Zd Zd Zd Zd ZdS )	FlagFunctionTestsz*
    Tests for L{usage.flagFunction}.
    c                   $    e Zd ZdZd Zd Zd ZdS )FlagFunctionTests.SomeClassz>
        Dummy class for L{usage.flagFunction} tests.
        c                     dS )z
            A one argument method to be tested by L{usage.flagFunction}.

            @param a: a useless argument to satisfy the function's signature.
            Nr(   )r   r   s     r   oneArgz"FlagFunctionTests.SomeClass.oneArgr        r   c                     dS )zU
            A no argument method to be tested by L{usage.flagFunction}.
            Nr(   r   s    r   noArgz!FlagFunctionTests.SomeClass.noArgy  r8  r   c                     dS )aG  
            A multiple arguments method to be tested by L{usage.flagFunction}.

            @param a: a useless argument to satisfy the function's signature.
            @param b: a useless argument to satisfy the function's signature.
            @param c: a useless argument to satisfy the function's signature.
            Nr(   )r   r   r   r  s       r   manyArgsz$FlagFunctionTests.SomeClass.manyArgs~  r8  r   N)r#   r$   r%   r>   r7  r:  r<  r(   r   r   	SomeClassr5  m  sK        	 		 	 		 	 	
	 	 	 	 	r   r=  c                     |                      dt          j        |                                 j                             dS )zs
        L{usage.flagFunction} returns C{False} if the method checked allows
        exactly one argument.
        FN)assertIsr   flagFunctionr=  r7  r   s    r   test_hasArgzFlagFunctionTests.test_hasArg  s6    
 	eU/0@0@0GHHIIIIIr   c                     |                      dt          j        |                                 j                             dS )zq
        L{usage.flagFunction} returns C{True} if the method checked allows
        exactly no argument.
        TN)r?  r   r@  r=  r:  r   s    r   
test_noArgzFlagFunctionTests.test_noArg  s6    
 	dE.t~~/?/?/EFFGGGGGr   c                     |                      t          j        t          j        |                                 j                  }|                     dt          |                     dS )z
        L{usage.flagFunction} raises L{usage.UsageError} if the method checked
        allows more than one argument.
        z$Invalid Option function for manyArgsNrb   r   rc   r@  r=  r<  r7   r   r   excs     r   test_tooManyArgumentsz'FlagFunctionTests.test_tooManyArguments  sX    
 e0$..2B2B2K
 
 	?SJJJJJr   c                     |                      t          j        t          j        |                                 j        d          }|                     dt          |                     dS )z
        L{usage.flagFunction} uses the given method name in the error message
        raised when the method allows too many arguments.
        flubudufz$Invalid Option function for flubudufNrE  rF  s     r   ,test_tooManyArgumentsAndSpecificErrorMessagez>FlagFunctionTests.test_tooManyArgumentsAndSpecificErrorMessage  sZ    
 e0$..2B2B2KZ
 
 	?SJJJJJr   N)	r#   r$   r%   r>   r=  rA  rC  rH  rK  r(   r   r   r3  r3  h  s                4J J JH H HK K KK K K K Kr   r3  c                       e Zd ZdZd ZdS )OptionsInternalTestsz6
    Tests internal behavior of C{usage.Options}.
    c                      G d dt           j                  } |            }|                     t                              g dd          |j        d         |j        d         |j        d         d           dS )zs
        Options which are synonyms to another option are aliases towards the
        longest option name.
        c                       e Zd Zd ZeZeZdS );OptionsInternalTests.test_optionsAliasesOrder.<locals>.Optsc                     dS )z~
                This is an option method with a very long name, that is going to
                be aliased.
                Nr(   r   s    r   opt_very_very_longzNOptionsInternalTests.test_optionsAliasesOrder.<locals>.Opts.opt_very_very_long  r8  r   N)r#   r$   r%   rR  	opt_shortopt_sr(   r   r   OptsrP    s)           +I&EEEr   rU  )r   shortvery-very-longrW  r   rV  N)r   r   r7   dictfromkeyssynonyms)r   rU  r   s      r   test_optionsAliasesOrderz-OptionsInternalTests.test_optionsAliasesOrder  s    	' 	' 	' 	' 	'5= 	' 	' 	' tvvMM:::<LMM]3'w/"&-0@"A 	
 	
 	
 	
 	
r   N)r#   r$   r%   r>   r[  r(   r   r   rM  rM    s-         
 
 
 
 
r   rM  N)r>   twisted.pythonr   twisted.trialr   r   r   TestCaser*   r@   rN   rf   rj   rv   r   r   r   r   r   r   r   r   r)  r3  rM  r(   r   r   <module>r_     s   
 !           " " " " " "7 7 7 7 7%- 7 7 76(I (I (I (I (IH- (I (I (IV    5=   $8K 8K 8K 8K 8K" 8K 8K 8KvN N N N N N N N
 
 
 
 
5= 
 
 
"? "? "? "? "?h' "? "? "?J= = = = =(# = = =           u}          |? |? |? |? |?h' |? |? |?~!= != != != !=h' != != !=H? ? ? ? ?h' ? ? ?.P? P? P? P? P?) P? P? P?f    8#4   B?K ?K ?K ?K ?K) ?K ?K ?KD
 
 
 
 
8, 
 
 
 
 
r   