<s> import codecs <EOL> import inspect <EOL> import os <EOL> import shutil <EOL> import stat <EOL> import sys <EOL> import textwrap <EOL> import tempfile <EOL> import unittest <EOL> import argparse <EOL> from io import StringIO <EOL> from test import support <EOL> class StdIOBuffer ( StringIO ) : <EOL> pass <EOL> class TestCase ( unittest . TestCase ) : <EOL> def assertEqual ( self , obj1 , obj2 ) : <EOL> if obj1 != obj2 : <EOL> print ( '<STR_LIT>' ) <EOL> print ( repr ( obj1 ) ) <EOL> print ( repr ( obj2 ) ) <EOL> print ( obj1 ) <EOL> print ( obj2 ) <EOL> super ( TestCase , self ) . assertEqual ( obj1 , obj2 ) <EOL> def setUp ( self ) : <EOL> env = support . EnvironmentVarGuard ( ) <EOL> env . unset ( "<STR_LIT>" ) <EOL> self . addCleanup ( env . __exit__ ) <EOL> class TempDirMixin ( object ) : <EOL> def setUp ( self ) : <EOL> self . temp_dir = tempfile . mkdtemp ( ) <EOL> self . old_dir = os . getcwd ( ) <EOL> os . chdir ( self . temp_dir ) <EOL> def tearDown ( self ) : <EOL> os . chdir ( self . old_dir ) <EOL> shutil . rmtree ( self . temp_dir , True ) <EOL> def create_readonly_file ( self , filename ) : <EOL> file_path = os . path . join ( self . temp_dir , filename ) <EOL> with open ( file_path , '<STR_LIT:w>' ) as file : <EOL> file . write ( filename ) <EOL> os . chmod ( file_path , stat . S_IREAD ) <EOL> class Sig ( object ) : <EOL> def __init__ ( self , * args , ** kwargs ) : <EOL> self . args = args <EOL> self . kwargs = kwargs <EOL> class NS ( object ) : <EOL> def __init__ ( self , ** kwargs ) : <EOL> self . __dict__ . update ( kwargs ) <EOL> def __repr__ ( self ) : <EOL> sorted_items = sorted ( self . __dict__ . items ( ) ) <EOL> kwarg_str = '<STR_LIT:U+002CU+0020>' . join ( [ '<STR_LIT>' % tup for tup in sorted_items ] ) <EOL> return '<STR_LIT>' % ( type ( self ) . __name__ , kwarg_str ) <EOL> def __eq__ ( self , other ) : <EOL> return vars ( self ) == vars ( other ) <EOL> def __ne__ ( self , other ) : <EOL> return not ( self == other ) <EOL> class ArgumentParserError ( Exception ) : <EOL> def __init__ ( self , message , stdout = None , stderr = None , error_code = None ) : <EOL> Exception . __init__ ( self , message , stdout , stderr ) <EOL> self . message = message <EOL> self . stdout = stdout <EOL> self . stderr = stderr <EOL> self . error_code = error_code <EOL> def stderr_to_parser_error ( parse_args , * args , ** kwargs ) : <EOL> if isinstance ( sys . stderr , StdIOBuffer ) or isinstance ( sys . stdout , StdIOBuffer ) : <EOL> return parse_args ( * args , ** kwargs ) <EOL> old_stdout = sys . stdout <EOL> old_stderr = sys . stderr <EOL> sys . stdout = StdIOBuffer ( ) <EOL> sys . stderr = StdIOBuffer ( ) <EOL> try : <EOL> try : <EOL> result = parse_args ( * args , ** kwargs ) <EOL> for key in list ( vars ( result ) ) : <EOL> if getattr ( result , key ) is sys . stdout : <EOL> setattr ( result , key , old_stdout ) <EOL> if getattr ( result , key ) is sys . stderr : <EOL> setattr ( result , key , old_stderr ) <EOL> return result <EOL> except SystemExit : <EOL> code = sys . exc_info ( ) [ <NUM_LIT:1> ] . code <EOL> stdout = sys . stdout . getvalue ( ) <EOL> stderr = sys . stderr . getvalue ( ) <EOL> raise ArgumentParserError ( "<STR_LIT>" , stdout , stderr , code ) <EOL> finally : <EOL> sys . stdout = old_stdout <EOL> sys . stderr = old_stderr <EOL> class ErrorRaisingArgumentParser ( argparse . ArgumentParser ) : <EOL> def parse_args ( self , * args , ** kwargs ) : <EOL> parse_args = super ( ErrorRaisingArgumentParser , self ) . parse_args <EOL> return stderr_to_parser_error ( parse_args , * args , ** kwargs ) <EOL> def exit ( self , * args , ** kwargs ) : <EOL> exit = super ( ErrorRaisingArgumentParser , self ) . exit <EOL> return stderr_to_parser_error ( exit , * args , ** kwargs ) <EOL> def error ( self , * args , ** kwargs ) : <EOL> error = super ( ErrorRaisingArgumentParser , self ) . error <EOL> return stderr_to_parser_error ( error , * args , ** kwargs ) <EOL> class ParserTesterMetaclass ( type ) : <EOL> """<STR_LIT>""" <EOL> def __init__ ( cls , name , bases , bodydict ) : <EOL> if name == '<STR_LIT>' : <EOL> return <EOL> if not hasattr ( cls , '<STR_LIT>' ) : <EOL> cls . parser_signature = Sig ( ) <EOL> if not hasattr ( cls , '<STR_LIT>' ) : <EOL> cls . parser_class = ErrorRaisingArgumentParser <EOL> def no_groups ( parser , argument_signatures ) : <EOL> """<STR_LIT>""" <EOL> for sig in argument_signatures : <EOL> parser . add_argument ( * sig . args , ** sig . kwargs ) <EOL> def one_group ( parser , argument_signatures ) : <EOL> """<STR_LIT>""" <EOL> group = parser . add_argument_group ( '<STR_LIT:foo>' ) <EOL> for sig in argument_signatures : <EOL> group . add_argument ( * sig . args , ** sig . kwargs ) <EOL> def many_groups ( parser , argument_signatures ) : <EOL> """<STR_LIT>""" <EOL> for i , sig in enumerate ( argument_signatures ) : <EOL> group = parser . add_argument_group ( '<STR_LIT>' % i ) <EOL> group . add_argument ( * sig . args , ** sig . kwargs ) <EOL> def listargs ( parser , args ) : <EOL> """<STR_LIT>""" <EOL> return parser . parse_args ( args ) <EOL> def sysargs ( parser , args ) : <EOL> """<STR_LIT>""" <EOL> old_sys_argv = sys . argv <EOL> sys . argv = [ old_sys_argv [ <NUM_LIT:0> ] ] + args <EOL> try : <EOL> return parser . parse_args ( ) <EOL> finally : <EOL> sys . argv = old_sys_argv <EOL> class AddTests ( object ) : <EOL> def __init__ ( self , tester_cls , add_arguments , parse_args ) : <EOL> self . _add_arguments = add_arguments <EOL> self . _parse_args = parse_args <EOL> add_arguments_name = self . _add_arguments . __name__ <EOL> parse_args_name = self . _parse_args . __name__ <EOL> for test_func in [ self . test_failures , self . test_successes ] : <EOL> func_name = test_func . __name__ <EOL> names = func_name , add_arguments_name , parse_args_name <EOL> test_name = '<STR_LIT:_>' . join ( names ) <EOL> def wrapper ( self , test_func = test_func ) : <EOL> test_func ( self ) <EOL> try : <EOL> wrapper . __name__ = test_name <EOL> except TypeError : <EOL> pass <EOL> setattr ( tester_cls , test_name , wrapper ) <EOL> def _get_parser ( self , tester ) : <EOL> args = tester . parser_signature . args <EOL> kwargs = tester . parser_signature . kwargs <EOL> parser = tester . parser_class ( * args , ** kwargs ) <EOL> self . _add_arguments ( parser , tester . argument_signatures ) <EOL> return parser <EOL> def test_failures ( self , tester ) : <EOL> parser = self . _get_parser ( tester ) <EOL> for args_str in tester . failures : <EOL> args = args_str . split ( ) <EOL> raises = tester . assertRaises <EOL> raises ( ArgumentParserError , parser . parse_args , args ) <EOL> def test_successes ( self , tester ) : <EOL> parser = self . _get_parser ( tester ) <EOL> for args , expected_ns in tester . successes : <EOL> if isinstance ( args , str ) : <EOL> args = args . split ( ) <EOL> result_ns = self . _parse_args ( parser , args ) <EOL> tester . assertEqual ( expected_ns , result_ns ) <EOL> for add_arguments in [ no_groups , one_group , many_groups ] : <EOL> for parse_args in [ listargs , sysargs ] : <EOL> AddTests ( cls , add_arguments , parse_args ) <EOL> bases = TestCase , <EOL> ParserTestCase = ParserTesterMetaclass ( '<STR_LIT>' , bases , { } ) <EOL> class TestOptionalsSingleDash ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT>' ) ) , <EOL> ] <EOL> class TestOptionalsSingleDashCombined ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , const = <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = False , yyy = None , z = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , yyy = None , z = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = False , yyy = None , z = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = False , yyy = None , z = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , yyy = None , z = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , yyy = None , z = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , yyy = None , z = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , yyy = None , z = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = False , yyy = <NUM_LIT> , z = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = False , yyy = <NUM_LIT> , z = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , yyy = <NUM_LIT> , z = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , yyy = <NUM_LIT> , z = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestOptionalsSingleDashLong ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestOptionalsSingleDashSubsetAmbiguous ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) , Sig ( '<STR_LIT>' ) , Sig ( '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( f = None , foobar = None , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = '<STR_LIT:a>' , foobar = None , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = '<STR_LIT:a>' , foobar = None , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = '<STR_LIT>' , foobar = None , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = '<STR_LIT>' , foobar = None , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = None , foobar = '<STR_LIT:a>' , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = None , foobar = None , foorab = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestOptionalsSingleDashAmbiguous ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) , Sig ( '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foobar = None , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foobar = '<STR_LIT:a>' , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foobar = None , foorab = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foobar = '<STR_LIT:a>' , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foobar = None , foorab = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foobar = '<STR_LIT:a>' , foorab = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foobar = None , foorab = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestOptionalsNumeric ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , dest = '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( one = None ) ) , <EOL> ( '<STR_LIT>' , NS ( one = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( one = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( one = '<STR_LIT>' ) ) , <EOL> ] <EOL> class TestOptionalsDoubleDash ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT>' ) ) , <EOL> ] <EOL> class TestOptionalsDoubleDashPartialMatch ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( badger = False , bat = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = False , bat = '<STR_LIT:X>' ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , bat = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , bat = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , bat = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , bat = None ) ) , <EOL> ] <EOL> class TestOptionalsDoubleDashPrefixMatch ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( badger = False , ba = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = False , ba = '<STR_LIT:X>' ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = False , ba = '<STR_LIT:X>' ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , ba = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , ba = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , ba = None ) ) , <EOL> ( '<STR_LIT>' , NS ( badger = True , ba = None ) ) , <EOL> ] <EOL> class TestOptionalsSingleDoubleDash ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , const = <NUM_LIT> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:B>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( f = False , bar = None , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = False , bar = '<STR_LIT:B>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = '<STR_LIT:B>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = <NUM_LIT> ) ) , <EOL> ] <EOL> class TestOptionalsAlternatePrefixChars ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prefix_chars = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , const = <NUM_LIT> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:B>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( f = False , bar = None , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = False , bar = '<STR_LIT:B>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = '<STR_LIT:B>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = <NUM_LIT> ) ) , <EOL> ] <EOL> class TestOptionalsAlternatePrefixCharsAddedHelp ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prefix_chars = '<STR_LIT>' , add_help = True ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , const = <NUM_LIT> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:B>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( f = False , bar = None , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = False , bar = '<STR_LIT:B>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = '<STR_LIT:B>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( f = True , bar = None , baz = <NUM_LIT> ) ) <EOL> ] <EOL> class TestOptionalsAlternatePrefixCharsMultipleShortArgs ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prefix_chars = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = False , y = False , z = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , y = False , z = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , y = True , z = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = True , y = True , z = True ) ) , <EOL> ] <EOL> class TestOptionalsShortLong ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( verbose = False ) ) , <EOL> ( '<STR_LIT>' , NS ( verbose = True ) ) , <EOL> ( '<STR_LIT>' , NS ( verbose = True ) ) , <EOL> ( '<STR_LIT>' , NS ( verbose = True ) ) , <EOL> ( '<STR_LIT>' , NS ( verbose = True ) ) , <EOL> ] <EOL> class TestOptionalsDest ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) , Sig ( '<STR_LIT>' , dest = '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo_bar = '<STR_LIT:f>' , zabbaz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foo_bar = None , zabbaz = '<STR_LIT:g>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo_bar = '<STR_LIT:h>' , zabbaz = '<STR_LIT:i>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo_bar = '<STR_LIT:k>' , zabbaz = '<STR_LIT>' ) ) , <EOL> ] <EOL> class TestOptionalsDefault ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) , Sig ( '<STR_LIT>' , default = <NUM_LIT> ) ] <EOL> failures = [ '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:x>' , y = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = '<STR_LIT:y>' ) ) , <EOL> ] <EOL> class TestOptionalsNargsDefault ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestOptionalsNargs1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , nargs = <NUM_LIT:1> ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' ] ) ) , <EOL> ] <EOL> class TestOptionalsNargs3 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , nargs = <NUM_LIT:3> ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' , '<STR_LIT:b>' , '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestOptionalsNargsOptional ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:?>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , const = <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , default = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , type = int , const = '<STR_LIT>' , default = '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT:2>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( w = None , x = None , y = '<STR_LIT>' , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = None , x = None , y = '<STR_LIT>' , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = '<STR_LIT:2>' , x = None , y = '<STR_LIT>' , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = None , x = <NUM_LIT> , y = '<STR_LIT>' , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = None , x = '<STR_LIT:2>' , y = '<STR_LIT>' , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = None , x = None , y = None , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = None , x = None , y = '<STR_LIT:2>' , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = None , x = None , y = '<STR_LIT>' , z = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( w = None , x = None , y = '<STR_LIT>' , z = <NUM_LIT:2> ) ) , <EOL> ] <EOL> class TestOptionalsNargsZeroOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:*>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:*>' , default = '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ ] , y = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' ] , y = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , y = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestOptionalsNargsOneOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:+>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:+>' , default = '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' ] , y = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , y = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestOptionalsChoices ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , choices = '<STR_LIT:abc>' ) , <EOL> Sig ( '<STR_LIT>' , type = int , choices = range ( <NUM_LIT:5> ) ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( f = None , g = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = '<STR_LIT:a>' , g = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = '<STR_LIT:c>' , g = None ) ) , <EOL> ( '<STR_LIT>' , NS ( f = None , g = <NUM_LIT:0> ) ) , <EOL> ( '<STR_LIT>' , NS ( f = None , g = <NUM_LIT:3> ) ) , <EOL> ( '<STR_LIT>' , NS ( f = '<STR_LIT:b>' , g = <NUM_LIT:4> ) ) , <EOL> ] <EOL> class TestOptionalsRequired ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = int , required = True ) , <EOL> ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = <NUM_LIT:1> ) ) , <EOL> ( '<STR_LIT>' , NS ( x = <NUM_LIT> ) ) , <EOL> ] <EOL> class TestOptionalsActionStore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , action = '<STR_LIT:store>' ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:foo>' ) ) , <EOL> ] <EOL> class TestOptionalsActionStoreConst ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , action = '<STR_LIT>' , const = object ) ] <EOL> failures = [ '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( y = None ) ) , <EOL> ( '<STR_LIT>' , NS ( y = object ) ) , <EOL> ] <EOL> class TestOptionalsActionStoreFalse ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , action = '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( z = True ) ) , <EOL> ( '<STR_LIT>' , NS ( z = False ) ) , <EOL> ] <EOL> class TestOptionalsActionStoreTrue ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( apple = False ) ) , <EOL> ( '<STR_LIT>' , NS ( apple = True ) ) , <EOL> ] <EOL> class TestOptionalsActionAppend ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , action = '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( baz = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( baz = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestOptionalsActionAppendWithDefault ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , action = '<STR_LIT>' , default = [ '<STR_LIT:X>' ] ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( baz = [ '<STR_LIT:X>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( baz = [ '<STR_LIT:X>' , '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( baz = [ '<STR_LIT:X>' , '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestOptionalsActionAppendConst ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , const = Exception ) , <EOL> Sig ( '<STR_LIT:-c>' , action = '<STR_LIT>' , dest = '<STR_LIT:b>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT:-c>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( b = None ) ) , <EOL> ( '<STR_LIT>' , NS ( b = [ Exception ] ) ) , <EOL> ( '<STR_LIT>' , NS ( b = [ Exception , '<STR_LIT:x>' , Exception , '<STR_LIT>' ] ) ) , <EOL> ] <EOL> class TestOptionalsActionAppendConstWithDefault ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , const = Exception , default = [ '<STR_LIT:X>' ] ) , <EOL> Sig ( '<STR_LIT:-c>' , action = '<STR_LIT>' , dest = '<STR_LIT:b>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT:-c>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( b = [ '<STR_LIT:X>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( b = [ '<STR_LIT:X>' , Exception ] ) ) , <EOL> ( '<STR_LIT>' , NS ( b = [ '<STR_LIT:X>' , Exception , '<STR_LIT:x>' , Exception , '<STR_LIT>' ] ) ) , <EOL> ] <EOL> class TestOptionalsActionCount ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , action = '<STR_LIT:count>' ) ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = <NUM_LIT:1> ) ) , <EOL> ] <EOL> class TestPositionalsNargsNone ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestPositionalsNargs1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = <NUM_LIT:1> ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = [ '<STR_LIT:a>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargs2 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = <NUM_LIT:2> ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsZeroOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:*>' ) ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ ] ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsZeroOrMoreDefault ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:*>' , default = '<STR_LIT:bar>' ) ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:bar>' ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsOneOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:+>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptional ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = None ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptionalDefault ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' , default = <NUM_LIT> ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptionalConvertedDefault ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' , type = int , default = '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT:1>' , NS ( foo = <NUM_LIT:1> ) ) , <EOL> ] <EOL> class TestPositionalsNargsNoneNone ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' ) , Sig ( '<STR_LIT:bar>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = '<STR_LIT:b>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsNone1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' ) , Sig ( '<STR_LIT:bar>' , nargs = <NUM_LIT:1> ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargs2None ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = <NUM_LIT:2> ) , Sig ( '<STR_LIT:bar>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = '<STR_LIT:c>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsNoneZeroOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:*>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' , bar = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' , '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsNoneOneOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:+>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' , '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsNoneOptional ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:?>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' , bar = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = '<STR_LIT:b>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsZeroOrMoreNone ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:*>' ) , Sig ( '<STR_LIT:bar>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = [ ] , bar = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' ] , bar = '<STR_LIT:b>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = '<STR_LIT:c>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsOneOrMoreNone ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:+>' ) , Sig ( '<STR_LIT:bar>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' ] , bar = '<STR_LIT:b>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = '<STR_LIT:c>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptionalNone ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' , default = <NUM_LIT> ) , Sig ( '<STR_LIT:bar>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = <NUM_LIT> , bar = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = '<STR_LIT:b>' ) ) , <EOL> ] <EOL> class TestPositionalsNargs2ZeroOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = <NUM_LIT:2> ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:*>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = [ '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargs2OneOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = <NUM_LIT:2> ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:+>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = [ '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargs2Optional ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = <NUM_LIT:2> ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:?>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = None ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = '<STR_LIT:c>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsZeroOrMore1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:*>' ) , Sig ( '<STR_LIT:bar>' , nargs = <NUM_LIT:1> ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = [ ] , bar = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' ] , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = [ '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsOneOrMore1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:+>' ) , Sig ( '<STR_LIT:bar>' , nargs = <NUM_LIT:1> ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' ] , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = [ '<STR_LIT:a>' , '<STR_LIT:b>' ] , bar = [ '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptional1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' ) , Sig ( '<STR_LIT:bar>' , nargs = <NUM_LIT:1> ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = None , bar = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsNoneZeroOrMore1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:foo>' ) , <EOL> Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:*>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = <NUM_LIT:1> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ ] , baz = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] , baz = [ '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsNoneOneOrMore1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:foo>' ) , <EOL> Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:+>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = <NUM_LIT:1> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT:b>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] , baz = [ '<STR_LIT:c>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' , '<STR_LIT:c>' ] , baz = [ '<STR_LIT:d>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsNoneOptional1 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:foo>' ) , <EOL> Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:?>' , default = <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , nargs = <NUM_LIT:1> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = <NUM_LIT> , baz = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = '<STR_LIT:b>' , baz = [ '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptionalOptional ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' ) , <EOL> Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:?>' , default = <NUM_LIT> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = None , bar = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' , bar = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = '<STR_LIT:b>' ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptionalZeroOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:*>' ) ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = None , bar = [ ] ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' , bar = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' , '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsNargsOptionalOneOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' ) , Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:+>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( foo = None , bar = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' , '<STR_LIT:c>' ] ) ) , <EOL> ] <EOL> class TestPositionalsChoicesString ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , choices = set ( '<STR_LIT>' ) ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:h>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:a>' , NS ( spam = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT:g>' , NS ( spam = '<STR_LIT:g>' ) ) , <EOL> ] <EOL> class TestPositionalsChoicesInt ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , type = int , choices = range ( <NUM_LIT:20> ) ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:h>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:4>' , NS ( spam = <NUM_LIT:4> ) ) , <EOL> ( '<STR_LIT>' , NS ( spam = <NUM_LIT:15> ) ) , <EOL> ] <EOL> class TestPositionalsActionAppend ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , nargs = <NUM_LIT:2> ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( spam = [ '<STR_LIT:a>' , [ '<STR_LIT:b>' , '<STR_LIT:c>' ] ] ) ) , <EOL> ] <EOL> class TestOptionalsNumericAndPositionals ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:x>' , nargs = '<STR_LIT:?>' ) , <EOL> Sig ( '<STR_LIT>' , dest = '<STR_LIT:y>' , action = '<STR_LIT:store_true>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = False ) ) , <EOL> ( '<STR_LIT:a>' , NS ( x = '<STR_LIT:a>' , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = True ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:a>' , y = True ) ) , <EOL> ] <EOL> class TestOptionalsAlmostNumericAndPositionals ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:x>' , nargs = '<STR_LIT:?>' ) , <EOL> Sig ( '<STR_LIT>' , dest = '<STR_LIT:y>' , action = '<STR_LIT:store_true>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT>' , y = False ) ) , <EOL> ( '<STR_LIT:a>' , NS ( x = '<STR_LIT:a>' , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = True ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:a>' , y = True ) ) , <EOL> ] <EOL> class TestEmptyAndSpaceContainingArguments ( ParserTestCase ) : <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:x>' , nargs = '<STR_LIT:?>' ) , <EOL> Sig ( '<STR_LIT>' , '<STR_LIT>' , dest = '<STR_LIT:y>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( [ '<STR_LIT>' ] , NS ( x = '<STR_LIT>' , y = None ) ) , <EOL> ( [ '<STR_LIT>' ] , NS ( x = '<STR_LIT>' , y = None ) ) , <EOL> ( [ '<STR_LIT>' ] , NS ( x = '<STR_LIT>' , y = None ) ) , <EOL> ( [ '<STR_LIT>' , '<STR_LIT>' ] , NS ( x = None , y = '<STR_LIT>' ) ) , <EOL> ( [ '<STR_LIT>' , '<STR_LIT>' ] , NS ( x = None , y = '<STR_LIT>' ) ) , <EOL> ( [ '<STR_LIT>' , '<STR_LIT>' ] , NS ( x = None , y = '<STR_LIT>' ) ) , <EOL> ( [ '<STR_LIT>' ] , NS ( x = None , y = '<STR_LIT>' ) ) , <EOL> ( [ '<STR_LIT>' ] , NS ( x = None , y = '<STR_LIT>' ) ) , <EOL> ] <EOL> class TestPrefixCharacterOnlyArguments ( ParserTestCase ) : <EOL> parser_signature = Sig ( prefix_chars = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:->' , dest = '<STR_LIT:x>' , nargs = '<STR_LIT:?>' , const = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:+>' , dest = '<STR_LIT:y>' , type = int , default = <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , dest = '<STR_LIT:z>' , action = '<STR_LIT:store_true>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = <NUM_LIT> , z = False ) ) , <EOL> ( '<STR_LIT:->' , NS ( x = '<STR_LIT>' , y = <NUM_LIT> , z = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:X>' , y = <NUM_LIT> , z = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = - <NUM_LIT:3> , z = False ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = <NUM_LIT> , z = True ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT>' , y = <NUM_LIT> , z = False ) ) , <EOL> ] <EOL> class TestNargsZeroOrMore ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , nargs = '<STR_LIT:*>' ) , Sig ( '<STR_LIT:y>' , nargs = '<STR_LIT:*>' ) ] <EOL> failures = [ ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ ] , y = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' ] , y = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:a>' ] , y = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT:a>' , NS ( x = None , y = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ ] , y = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = [ '<STR_LIT:b>' ] , y = [ '<STR_LIT:a>' ] ) ) , <EOL> ] <EOL> class TestNargsRemainder ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ Sig ( '<STR_LIT:x>' ) , Sig ( '<STR_LIT:y>' , nargs = '<STR_LIT>' ) , Sig ( '<STR_LIT>' ) ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:X>' , NS ( x = '<STR_LIT:X>' , y = [ ] , z = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:X>' , y = [ ] , z = '<STR_LIT>' ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:X>' , y = [ '<STR_LIT:A>' , '<STR_LIT:B>' , '<STR_LIT>' , '<STR_LIT>' ] , z = None ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:X>' , y = [ '<STR_LIT:Y>' , '<STR_LIT>' ] , z = None ) ) , <EOL> ] <EOL> class TestOptionLike ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = float ) , <EOL> Sig ( '<STR_LIT>' , type = float , dest = '<STR_LIT:y>' ) , <EOL> Sig ( '<STR_LIT:z>' , nargs = '<STR_LIT:*>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = None , z = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = <NUM_LIT> , y = None , z = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = <NUM_LIT> , y = None , z = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = <NUM_LIT:0.5> , z = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = - <NUM_LIT:0.5> , z = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = <NUM_LIT:0.5> , z = [ ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = <NUM_LIT:0.5> , z = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT:a>' , NS ( x = None , y = None , z = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = <NUM_LIT:1.0> , y = None , z = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = <NUM_LIT:1.0> , y = None , z = [ '<STR_LIT:a>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = <NUM_LIT:1.0> , z = [ '<STR_LIT:a>' ] ) ) , <EOL> ] <EOL> class TestDefaultSuppress ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' , default = argparse . SUPPRESS ) , <EOL> Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:*>' , default = argparse . SUPPRESS ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , default = argparse . SUPPRESS ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( baz = True ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , baz = True ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] , baz = True ) ) , <EOL> ] <EOL> class TestParserDefaultSuppress ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( argument_default = argparse . SUPPRESS ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' ) , <EOL> Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:*>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( baz = True ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , baz = True ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] , baz = True ) ) , <EOL> ] <EOL> class TestParserDefault42 ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( argument_default = <NUM_LIT> ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT:1.0>' ) , <EOL> Sig ( '<STR_LIT:foo>' , nargs = '<STR_LIT:?>' ) , <EOL> Sig ( '<STR_LIT:bar>' , nargs = '<STR_LIT:*>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = <NUM_LIT> , bar = <NUM_LIT> , baz = <NUM_LIT> , version = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT:a>' , NS ( foo = '<STR_LIT:a>' , bar = <NUM_LIT> , baz = <NUM_LIT> , version = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] , baz = <NUM_LIT> , version = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = <NUM_LIT> , bar = <NUM_LIT> , baz = True , version = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = <NUM_LIT> , baz = True , version = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = '<STR_LIT:a>' , bar = [ '<STR_LIT:b>' ] , baz = True , version = <NUM_LIT> ) ) , <EOL> ] <EOL> class TestArgumentsFromFile ( TempDirMixin , ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( TestArgumentsFromFile , self ) . setUp ( ) <EOL> file_texts = [ <EOL> ( '<STR_LIT:hello>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ] <EOL> for path , text in file_texts : <EOL> file = open ( path , '<STR_LIT:w>' ) <EOL> file . write ( text ) <EOL> file . close ( ) <EOL> parser_signature = Sig ( fromfile_prefix_chars = '<STR_LIT:@>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:x>' ) , <EOL> Sig ( '<STR_LIT:y>' , nargs = '<STR_LIT:+>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:X>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( a = None , x = '<STR_LIT:X>' , y = [ '<STR_LIT:Y>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( a = '<STR_LIT:A>' , x = '<STR_LIT:X>' , y = [ '<STR_LIT:Y>' , '<STR_LIT>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( a = None , x = '<STR_LIT>' , y = [ '<STR_LIT:X>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( a = None , x = '<STR_LIT:X>' , y = [ '<STR_LIT>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( a = '<STR_LIT:A>' , x = '<STR_LIT>' , y = [ '<STR_LIT:Y>' , '<STR_LIT>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( a = '<STR_LIT:B>' , x = '<STR_LIT:X>' , y = [ '<STR_LIT>' , '<STR_LIT>' ] ) ) , <EOL> ( [ "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT:X>" , "<STR_LIT:Y>" ] , NS ( a = '<STR_LIT>' , x = '<STR_LIT:X>' , y = [ '<STR_LIT:Y>' ] ) ) , <EOL> ] <EOL> class TestArgumentsFromFileConverter ( TempDirMixin , ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( TestArgumentsFromFileConverter , self ) . setUp ( ) <EOL> file_texts = [ <EOL> ( '<STR_LIT:hello>' , '<STR_LIT>' ) , <EOL> ] <EOL> for path , text in file_texts : <EOL> file = open ( path , '<STR_LIT:w>' ) <EOL> file . write ( text ) <EOL> file . close ( ) <EOL> class FromFileConverterArgumentParser ( ErrorRaisingArgumentParser ) : <EOL> def convert_arg_line_to_args ( self , arg_line ) : <EOL> for arg in arg_line . split ( ) : <EOL> if not arg . strip ( ) : <EOL> continue <EOL> yield arg <EOL> parser_class = FromFileConverterArgumentParser <EOL> parser_signature = Sig ( fromfile_prefix_chars = '<STR_LIT:@>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:y>' , nargs = '<STR_LIT:+>' ) , <EOL> ] <EOL> failures = [ ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( y = [ '<STR_LIT:hello>' , '<STR_LIT>' , '<STR_LIT:X>' ] ) ) , <EOL> ] <EOL> class TestFileTypeRepr ( TestCase ) : <EOL> def test_r ( self ) : <EOL> type = argparse . FileType ( '<STR_LIT:r>' ) <EOL> self . assertEqual ( "<STR_LIT>" , repr ( type ) ) <EOL> def test_wb_1 ( self ) : <EOL> type = argparse . FileType ( '<STR_LIT:wb>' , <NUM_LIT:1> ) <EOL> self . assertEqual ( "<STR_LIT>" , repr ( type ) ) <EOL> class RFile ( object ) : <EOL> seen = { } <EOL> def __init__ ( self , name ) : <EOL> self . name = name <EOL> def __eq__ ( self , other ) : <EOL> if other in self . seen : <EOL> text = self . seen [ other ] <EOL> else : <EOL> text = self . seen [ other ] = other . read ( ) <EOL> other . close ( ) <EOL> if not isinstance ( text , str ) : <EOL> text = text . decode ( '<STR_LIT:ascii>' ) <EOL> return self . name == other . name == text <EOL> class TestFileTypeR ( TempDirMixin , ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( TestFileTypeR , self ) . setUp ( ) <EOL> for file_name in [ '<STR_LIT:foo>' , '<STR_LIT:bar>' ] : <EOL> file = open ( os . path . join ( self . temp_dir , file_name ) , '<STR_LIT:w>' ) <EOL> file . write ( file_name ) <EOL> file . close ( ) <EOL> self . create_readonly_file ( '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( ) ) , <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( '<STR_LIT:r>' ) ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:foo>' , NS ( x = None , spam = RFile ( '<STR_LIT:foo>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = RFile ( '<STR_LIT:foo>' ) , spam = RFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = RFile ( '<STR_LIT:foo>' ) , spam = RFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = sys . stdin , spam = sys . stdin ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , spam = RFile ( '<STR_LIT>' ) ) ) , <EOL> ] <EOL> class TestFileTypeDefaults ( TempDirMixin , ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( TestFileTypeDefaults , self ) . setUp ( ) <EOL> file = open ( os . path . join ( self . temp_dir , '<STR_LIT>' ) , '<STR_LIT:w>' ) <EOL> file . write ( '<STR_LIT>' ) <EOL> file . close ( ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:-c>' , type = argparse . FileType ( '<STR_LIT:r>' ) , default = '<STR_LIT>' ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ ( '<STR_LIT>' , NS ( c = RFile ( '<STR_LIT>' ) ) ) ] <EOL> class TestFileTypeRB ( TempDirMixin , ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( TestFileTypeRB , self ) . setUp ( ) <EOL> for file_name in [ '<STR_LIT:foo>' , '<STR_LIT:bar>' ] : <EOL> file = open ( os . path . join ( self . temp_dir , file_name ) , '<STR_LIT:w>' ) <EOL> file . write ( file_name ) <EOL> file . close ( ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( '<STR_LIT:rb>' ) ) , <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( '<STR_LIT:rb>' ) ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:foo>' , NS ( x = None , spam = RFile ( '<STR_LIT:foo>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = RFile ( '<STR_LIT:foo>' ) , spam = RFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = RFile ( '<STR_LIT:foo>' ) , spam = RFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = sys . stdin , spam = sys . stdin ) ) , <EOL> ] <EOL> class WFile ( object ) : <EOL> seen = set ( ) <EOL> def __init__ ( self , name ) : <EOL> self . name = name <EOL> def __eq__ ( self , other ) : <EOL> if other not in self . seen : <EOL> text = '<STR_LIT>' <EOL> if '<STR_LIT:b>' in other . mode : <EOL> text = text . encode ( '<STR_LIT:ascii>' ) <EOL> other . write ( text ) <EOL> other . close ( ) <EOL> self . seen . add ( other ) <EOL> return self . name == other . name <EOL> @ unittest . skipIf ( hasattr ( os , '<STR_LIT>' ) and os . geteuid ( ) == <NUM_LIT:0> , <EOL> "<STR_LIT>" ) <EOL> class TestFileTypeW ( TempDirMixin , ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> def setUp ( self ) : <EOL> super ( TestFileTypeW , self ) . setUp ( ) <EOL> self . create_readonly_file ( '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( '<STR_LIT:w>' ) ) , <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( '<STR_LIT:w>' ) ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:foo>' , NS ( x = None , spam = WFile ( '<STR_LIT:foo>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = WFile ( '<STR_LIT:foo>' ) , spam = WFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = WFile ( '<STR_LIT:foo>' ) , spam = WFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = sys . stdout , spam = sys . stdout ) ) , <EOL> ] <EOL> class TestFileTypeWB ( TempDirMixin , ParserTestCase ) : <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( '<STR_LIT:wb>' ) ) , <EOL> Sig ( '<STR_LIT>' , type = argparse . FileType ( '<STR_LIT:wb>' ) ) , <EOL> ] <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT:foo>' , NS ( x = None , spam = WFile ( '<STR_LIT:foo>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = WFile ( '<STR_LIT:foo>' ) , spam = WFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = WFile ( '<STR_LIT:foo>' ) , spam = WFile ( '<STR_LIT:bar>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = sys . stdout , spam = sys . stdout ) ) , <EOL> ] <EOL> class TestTypeCallable ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = complex ) , <EOL> Sig ( '<STR_LIT>' , type = float ) , <EOL> ] <EOL> failures = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( eggs = <NUM_LIT> , spam = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( eggs = <NUM_LIT> , spam = - <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( eggs = None , spam = <NUM_LIT> ) ) , <EOL> ] <EOL> class TestTypeUserDefined ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> class MyType ( TestCase ) : <EOL> def __init__ ( self , value ) : <EOL> self . value = value <EOL> def __eq__ ( self , other ) : <EOL> return ( type ( self ) , self . value ) == ( type ( other ) , other . value ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = MyType ) , <EOL> Sig ( '<STR_LIT>' , type = MyType ) , <EOL> ] <EOL> failures = [ ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = MyType ( '<STR_LIT:b>' ) , spam = MyType ( '<STR_LIT:a>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = MyType ( '<STR_LIT:f>' ) , spam = MyType ( '<STR_LIT:g>' ) ) ) , <EOL> ] <EOL> class TestTypeClassicClass ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> class C : <EOL> def __init__ ( self , value ) : <EOL> self . value = value <EOL> def __eq__ ( self , other ) : <EOL> return ( type ( self ) , self . value ) == ( type ( other ) , other . value ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = C ) , <EOL> Sig ( '<STR_LIT>' , type = C ) , <EOL> ] <EOL> failures = [ ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = C ( '<STR_LIT:b>' ) , spam = C ( '<STR_LIT:a>' ) ) ) , <EOL> ( '<STR_LIT>' , NS ( x = C ( '<STR_LIT:f>' ) , spam = C ( '<STR_LIT:g>' ) ) ) , <EOL> ] <EOL> class TestTypeRegistration ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test ( self ) : <EOL> def get_my_type ( string ) : <EOL> return '<STR_LIT>' % string <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . register ( '<STR_LIT:type>' , '<STR_LIT>' , get_my_type ) <EOL> parser . add_argument ( '<STR_LIT>' , type = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT:y>' , type = '<STR_LIT>' ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT:1>' . split ( ) ) , <EOL> NS ( x = None , y = '<STR_LIT>' ) ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( x = '<STR_LIT>' , y = '<STR_LIT>' ) ) <EOL> class TestActionUserDefined ( ParserTestCase ) : <EOL> """<STR_LIT>""" <EOL> class OptionalAction ( argparse . Action ) : <EOL> def __call__ ( self , parser , namespace , value , option_string = None ) : <EOL> try : <EOL> assert self . dest == '<STR_LIT>' , '<STR_LIT>' % self . dest <EOL> assert option_string == '<STR_LIT>' , '<STR_LIT>' % option_string <EOL> expected_ns = NS ( spam = <NUM_LIT> ) <EOL> if value in [ <NUM_LIT> , <NUM_LIT> ] : <EOL> expected_ns . badger = <NUM_LIT:2> <EOL> elif value in [ <NUM_LIT> ] : <EOL> expected_ns . badger = <NUM_LIT> <EOL> else : <EOL> raise AssertionError ( '<STR_LIT>' % value ) <EOL> assert expected_ns == namespace , ( '<STR_LIT>' % <EOL> ( expected_ns , namespace ) ) <EOL> except AssertionError : <EOL> e = sys . exc_info ( ) [ <NUM_LIT:1> ] <EOL> raise ArgumentParserError ( '<STR_LIT>' % e ) <EOL> setattr ( namespace , '<STR_LIT>' , value ) <EOL> class PositionalAction ( argparse . Action ) : <EOL> def __call__ ( self , parser , namespace , value , option_string = None ) : <EOL> try : <EOL> assert option_string is None , ( '<STR_LIT>' % <EOL> option_string ) <EOL> assert self . dest == '<STR_LIT>' , '<STR_LIT>' % self . dest <EOL> expected_ns = NS ( badger = <NUM_LIT:2> ) <EOL> if value in [ <NUM_LIT> , <NUM_LIT> ] : <EOL> expected_ns . spam = <NUM_LIT> <EOL> elif value in [ <NUM_LIT:1> ] : <EOL> expected_ns . spam = <NUM_LIT> <EOL> elif value in [ <NUM_LIT:2> ] : <EOL> expected_ns . spam = <NUM_LIT> <EOL> else : <EOL> raise AssertionError ( '<STR_LIT>' % value ) <EOL> assert expected_ns == namespace , ( '<STR_LIT>' % <EOL> ( expected_ns , namespace ) ) <EOL> except AssertionError : <EOL> e = sys . exc_info ( ) [ <NUM_LIT:1> ] <EOL> raise ArgumentParserError ( '<STR_LIT>' % e ) <EOL> setattr ( namespace , '<STR_LIT>' , value ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , dest = '<STR_LIT>' , action = OptionalAction , <EOL> type = float , default = <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , action = PositionalAction , <EOL> type = int , nargs = '<STR_LIT:?>' , default = <NUM_LIT:2> ) , <EOL> ] <EOL> failures = [ ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( spam = <NUM_LIT> , badger = <NUM_LIT:2> ) ) , <EOL> ( '<STR_LIT>' , NS ( spam = <NUM_LIT> , badger = <NUM_LIT> ) ) , <EOL> ( '<STR_LIT>' , NS ( spam = <NUM_LIT> , badger = <NUM_LIT:1> ) ) , <EOL> ( '<STR_LIT>' , NS ( spam = <NUM_LIT> , badger = <NUM_LIT> ) ) , <EOL> ] <EOL> class TestActionRegistration ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> class MyAction ( argparse . Action ) : <EOL> def __call__ ( self , parser , namespace , values , option_string = None ) : <EOL> setattr ( namespace , self . dest , '<STR_LIT>' % values ) <EOL> def test ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . register ( '<STR_LIT:action>' , '<STR_LIT>' , self . MyAction ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT>' ) <EOL> self . assertEqual ( parser . parse_args ( [ '<STR_LIT:1>' ] ) , NS ( badger = '<STR_LIT>' ) ) <EOL> self . assertEqual ( parser . parse_args ( [ '<STR_LIT>' ] ) , NS ( badger = '<STR_LIT>' ) ) <EOL> class TestAddSubparsers ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def assertArgumentParserError ( self , * args , ** kwargs ) : <EOL> self . assertRaises ( ArgumentParserError , * args , ** kwargs ) <EOL> def _get_parser ( self , subparser_help = False , prefix_chars = None , <EOL> aliases = False ) : <EOL> if prefix_chars : <EOL> parser = ErrorRaisingArgumentParser ( <EOL> prog = '<STR_LIT>' , description = '<STR_LIT>' , prefix_chars = prefix_chars ) <EOL> parser . add_argument ( <EOL> prefix_chars [ <NUM_LIT:0> ] * <NUM_LIT:2> + '<STR_LIT:foo>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> else : <EOL> parser = ErrorRaisingArgumentParser ( <EOL> prog = '<STR_LIT>' , description = '<STR_LIT>' ) <EOL> parser . add_argument ( <EOL> '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> parser . add_argument ( <EOL> '<STR_LIT:bar>' , type = float , help = '<STR_LIT>' ) <EOL> subparsers_kwargs = { } <EOL> if aliases : <EOL> subparsers_kwargs [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> subparsers_kwargs [ '<STR_LIT:title>' ] = '<STR_LIT>' <EOL> else : <EOL> subparsers_kwargs [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> subparsers = parser . add_subparsers ( ** subparsers_kwargs ) <EOL> self . assertArgumentParserError ( parser . add_subparsers ) <EOL> parser1_kwargs = dict ( description = '<STR_LIT>' ) <EOL> if subparser_help : <EOL> parser1_kwargs [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> if aliases : <EOL> parser1_kwargs [ '<STR_LIT>' ] = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> parser1 = subparsers . add_parser ( '<STR_LIT:1>' , ** parser1_kwargs ) <EOL> parser1 . add_argument ( '<STR_LIT>' , type = int , help = '<STR_LIT>' ) <EOL> parser1 . add_argument ( '<STR_LIT:x>' , choices = '<STR_LIT:abc>' , help = '<STR_LIT>' ) <EOL> parser2_kwargs = dict ( description = '<STR_LIT>' ) <EOL> if subparser_help : <EOL> parser2_kwargs [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> parser2 = subparsers . add_parser ( '<STR_LIT:2>' , ** parser2_kwargs ) <EOL> parser2 . add_argument ( '<STR_LIT>' , choices = '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> parser2 . add_argument ( '<STR_LIT:z>' , type = complex , nargs = '<STR_LIT:*>' , help = '<STR_LIT>' ) <EOL> parser3_kwargs = dict ( description = '<STR_LIT>' ) <EOL> if subparser_help : <EOL> parser3_kwargs [ '<STR_LIT>' ] = '<STR_LIT>' <EOL> parser3 = subparsers . add_parser ( '<STR_LIT:3>' , ** parser3_kwargs ) <EOL> parser3 . add_argument ( '<STR_LIT:t>' , type = int , help = '<STR_LIT>' ) <EOL> parser3 . add_argument ( '<STR_LIT:u>' , nargs = '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> def setUp ( self ) : <EOL> super ( ) . setUp ( ) <EOL> self . parser = self . _get_parser ( ) <EOL> self . command_help_parser = self . _get_parser ( subparser_help = True ) <EOL> def test_parse_args_failures ( self ) : <EOL> for args_str in [ '<STR_LIT>' , '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT>' ] : <EOL> args = args_str . split ( ) <EOL> self . assertArgumentParserError ( self . parser . parse_args , args ) <EOL> def test_parse_args ( self ) : <EOL> self . assertEqual ( <EOL> self . parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( foo = False , bar = <NUM_LIT:0.5> , w = <NUM_LIT:7> , x = '<STR_LIT:b>' ) , <EOL> ) <EOL> self . assertEqual ( <EOL> self . parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( foo = True , bar = <NUM_LIT> , y = '<STR_LIT:2>' , z = [ <NUM_LIT> , - <NUM_LIT> ] ) , <EOL> ) <EOL> self . assertEqual ( <EOL> self . parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( foo = True , bar = <NUM_LIT> , w = None , x = '<STR_LIT:c>' ) , <EOL> ) <EOL> self . assertEqual ( <EOL> self . parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( foo = False , bar = - <NUM_LIT> , t = <NUM_LIT:11> , u = [ '<STR_LIT:a>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:b>' ] ) , <EOL> ) <EOL> def test_parse_known_args ( self ) : <EOL> self . assertEqual ( <EOL> self . parser . parse_known_args ( '<STR_LIT>' . split ( ) ) , <EOL> ( NS ( foo = False , bar = <NUM_LIT:0.5> , w = <NUM_LIT:7> , x = '<STR_LIT:b>' ) , [ ] ) , <EOL> ) <EOL> self . assertEqual ( <EOL> self . parser . parse_known_args ( '<STR_LIT>' . split ( ) ) , <EOL> ( NS ( foo = False , bar = <NUM_LIT:0.5> , w = <NUM_LIT:7> , x = '<STR_LIT:b>' ) , [ '<STR_LIT>' ] ) , <EOL> ) <EOL> self . assertEqual ( <EOL> self . parser . parse_known_args ( '<STR_LIT>' . split ( ) ) , <EOL> ( NS ( foo = False , bar = <NUM_LIT:0.5> , w = <NUM_LIT:7> , x = '<STR_LIT:b>' ) , [ '<STR_LIT>' ] ) , <EOL> ) <EOL> self . assertEqual ( <EOL> self . parser . parse_known_args ( '<STR_LIT>' . split ( ) ) , <EOL> ( NS ( foo = False , bar = <NUM_LIT:0.5> , w = <NUM_LIT:7> , x = '<STR_LIT:b>' ) , [ '<STR_LIT>' , '<STR_LIT>' ] ) , <EOL> ) <EOL> self . assertEqual ( <EOL> self . parser . parse_known_args ( '<STR_LIT>' . split ( ) ) , <EOL> ( NS ( foo = False , bar = <NUM_LIT:0.5> , w = <NUM_LIT:7> , x = '<STR_LIT:b>' ) , [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:Y>' , '<STR_LIT>' ] ) , <EOL> ) <EOL> def test_dest ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) <EOL> subparsers = parser . add_subparsers ( dest = '<STR_LIT:bar>' ) <EOL> parser1 = subparsers . add_parser ( '<STR_LIT:1>' ) <EOL> parser1 . add_argument ( '<STR_LIT>' ) <EOL> self . assertEqual ( NS ( foo = False , bar = '<STR_LIT:1>' , baz = '<STR_LIT:2>' ) , <EOL> parser . parse_args ( '<STR_LIT>' . split ( ) ) ) <EOL> def test_help ( self ) : <EOL> self . assertEqual ( self . parser . format_usage ( ) , <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( self . parser . format_help ( ) , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> def test_help_extra_prefix_chars ( self ) : <EOL> parser = self . _get_parser ( prefix_chars = '<STR_LIT>' ) <EOL> self . assertEqual ( parser . format_usage ( ) , <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( parser . format_help ( ) , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> def test_help_alternate_prefix_chars ( self ) : <EOL> parser = self . _get_parser ( prefix_chars = '<STR_LIT>' ) <EOL> self . assertEqual ( parser . format_usage ( ) , <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( parser . format_help ( ) , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> def test_parser_command_help ( self ) : <EOL> self . assertEqual ( self . command_help_parser . format_usage ( ) , <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( self . command_help_parser . format_help ( ) , <EOL> textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> def test_subparser_title_help ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' , <EOL> description = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT:bar>' , help = '<STR_LIT>' ) <EOL> subparsers = parser . add_subparsers ( title = '<STR_LIT>' , <EOL> description = '<STR_LIT>' , <EOL> help = '<STR_LIT>' ) <EOL> parser1 = subparsers . add_parser ( '<STR_LIT:1>' ) <EOL> parser2 = subparsers . add_parser ( '<STR_LIT:2>' ) <EOL> self . assertEqual ( parser . format_usage ( ) , <EOL> '<STR_LIT>' ) <EOL> self . assertEqual ( parser . format_help ( ) , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> def _test_subparser_help ( self , args_str , expected_help ) : <EOL> try : <EOL> self . parser . parse_args ( args_str . split ( ) ) <EOL> except ArgumentParserError : <EOL> err = sys . exc_info ( ) [ <NUM_LIT:1> ] <EOL> if err . stdout != expected_help : <EOL> print ( repr ( expected_help ) ) <EOL> print ( repr ( err . stdout ) ) <EOL> self . assertEqual ( err . stdout , expected_help ) <EOL> def test_subparser1_help ( self ) : <EOL> self . _test_subparser_help ( '<STR_LIT>' , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> def test_subparser2_help ( self ) : <EOL> self . _test_subparser_help ( '<STR_LIT>' , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> def test_alias_invocation ( self ) : <EOL> parser = self . _get_parser ( aliases = True ) <EOL> self . assertEqual ( <EOL> parser . parse_known_args ( '<STR_LIT>' . split ( ) ) , <EOL> ( NS ( foo = False , bar = <NUM_LIT:0.5> , w = None , x = '<STR_LIT:b>' ) , [ ] ) , <EOL> ) <EOL> self . assertEqual ( <EOL> parser . parse_known_args ( '<STR_LIT>' . split ( ) ) , <EOL> ( NS ( foo = False , bar = <NUM_LIT:0.5> , w = None , x = '<STR_LIT:b>' ) , [ ] ) , <EOL> ) <EOL> def test_error_alias_invocation ( self ) : <EOL> parser = self . _get_parser ( aliases = True ) <EOL> self . assertArgumentParserError ( parser . parse_args , <EOL> '<STR_LIT>' . split ( ) ) <EOL> def test_alias_help ( self ) : <EOL> parser = self . _get_parser ( aliases = True , subparser_help = True ) <EOL> self . maxDiff = None <EOL> self . assertEqual ( parser . format_help ( ) , textwrap . dedent ( """<STR_LIT>""" ) ) <EOL> class TestPositionalsGroups ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def test_nongroup_first ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT:foo>' ) <EOL> group = parser . add_argument_group ( '<STR_LIT:g>' ) <EOL> group . add_argument ( '<STR_LIT:bar>' ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> expected = NS ( foo = '<STR_LIT:1>' , bar = '<STR_LIT:2>' , baz = '<STR_LIT:3>' ) <EOL> result = parser . parse_args ( '<STR_LIT>' . split ( ) ) <EOL> self . assertEqual ( expected , result ) <EOL> def test_group_first ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> group = parser . add_argument_group ( '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT:foo>' ) <EOL> parser . add_argument ( '<STR_LIT:bar>' ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> expected = NS ( foo = '<STR_LIT:1>' , bar = '<STR_LIT:2>' , baz = '<STR_LIT:3>' ) <EOL> result = parser . parse_args ( '<STR_LIT>' . split ( ) ) <EOL> self . assertEqual ( expected , result ) <EOL> def test_interleaved_groups ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> group = parser . add_argument_group ( '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT:foo>' ) <EOL> group . add_argument ( '<STR_LIT:bar>' ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> group = parser . add_argument_group ( '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' ) <EOL> expected = NS ( foo = '<STR_LIT:1>' , bar = '<STR_LIT:2>' , baz = '<STR_LIT:3>' , frell = '<STR_LIT:4>' ) <EOL> result = parser . parse_args ( '<STR_LIT>' . split ( ) ) <EOL> self . assertEqual ( expected , result ) <EOL> class TestParentParsers ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def assertArgumentParserError ( self , * args , ** kwargs ) : <EOL> self . assertRaises ( ArgumentParserError , * args , ** kwargs ) <EOL> def setUp ( self ) : <EOL> super ( ) . setUp ( ) <EOL> self . wxyz_parent = ErrorRaisingArgumentParser ( add_help = False ) <EOL> self . wxyz_parent . add_argument ( '<STR_LIT>' ) <EOL> x_group = self . wxyz_parent . add_argument_group ( '<STR_LIT:x>' ) <EOL> x_group . add_argument ( '<STR_LIT>' ) <EOL> self . wxyz_parent . add_argument ( '<STR_LIT:z>' ) <EOL> self . abcd_parent = ErrorRaisingArgumentParser ( add_help = False ) <EOL> self . abcd_parent . add_argument ( '<STR_LIT:a>' ) <EOL> self . abcd_parent . add_argument ( '<STR_LIT>' ) <EOL> c_group = self . abcd_parent . add_argument_group ( '<STR_LIT:c>' ) <EOL> c_group . add_argument ( '<STR_LIT>' ) <EOL> self . w_parent = ErrorRaisingArgumentParser ( add_help = False ) <EOL> self . w_parent . add_argument ( '<STR_LIT>' ) <EOL> self . z_parent = ErrorRaisingArgumentParser ( add_help = False ) <EOL> self . z_parent . add_argument ( '<STR_LIT:z>' ) <EOL> self . ab_mutex_parent = ErrorRaisingArgumentParser ( add_help = False ) <EOL> group = self . ab_mutex_parent . add_mutually_exclusive_group ( ) <EOL> group . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) <EOL> group . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) <EOL> self . main_program = os . path . basename ( sys . argv [ <NUM_LIT:0> ] ) <EOL> def test_single_parent ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( parents = [ self . wxyz_parent ] ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( w = '<STR_LIT:3>' , y = '<STR_LIT:1>' , z = '<STR_LIT:2>' ) ) <EOL> def test_single_parent_mutex ( self ) : <EOL> self . _test_mutex_ab ( self . ab_mutex_parent . parse_args ) <EOL> parser = ErrorRaisingArgumentParser ( parents = [ self . ab_mutex_parent ] ) <EOL> self . _test_mutex_ab ( parser . parse_args ) <EOL> def test_single_granparent_mutex ( self ) : <EOL> parents = [ self . ab_mutex_parent ] <EOL> parser = ErrorRaisingArgumentParser ( add_help = False , parents = parents ) <EOL> parser = ErrorRaisingArgumentParser ( parents = [ parser ] ) <EOL> self . _test_mutex_ab ( parser . parse_args ) <EOL> def _test_mutex_ab ( self , parse_args ) : <EOL> self . assertEqual ( parse_args ( [ ] ) , NS ( a = False , b = False ) ) <EOL> self . assertEqual ( parse_args ( [ '<STR_LIT>' ] ) , NS ( a = True , b = False ) ) <EOL> self . assertEqual ( parse_args ( [ '<STR_LIT>' ] ) , NS ( a = False , b = True ) ) <EOL> self . assertArgumentParserError ( parse_args , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . assertArgumentParserError ( parse_args , [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> self . assertArgumentParserError ( parse_args , [ '<STR_LIT:-c>' ] ) <EOL> self . assertArgumentParserError ( parse_args , [ '<STR_LIT>' , '<STR_LIT:-c>' ] ) <EOL> self . assertArgumentParserError ( parse_args , [ '<STR_LIT>' , '<STR_LIT:-c>' ] ) <EOL> def test_multiple_parents ( self ) : <EOL> parents = [ self . abcd_parent , self . wxyz_parent ] <EOL> parser = ErrorRaisingArgumentParser ( parents = parents ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( a = '<STR_LIT:3>' , b = None , d = '<STR_LIT:1>' , w = '<STR_LIT:2>' , y = None , z = '<STR_LIT:4>' ) ) <EOL> def test_multiple_parents_mutex ( self ) : <EOL> parents = [ self . ab_mutex_parent , self . wxyz_parent ] <EOL> parser = ErrorRaisingArgumentParser ( parents = parents ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( a = True , b = False , w = '<STR_LIT:2>' , y = None , z = '<STR_LIT:3>' ) ) <EOL> self . assertArgumentParserError ( <EOL> parser . parse_args , '<STR_LIT>' . split ( ) ) <EOL> self . assertArgumentParserError ( <EOL> parser . parse_args , '<STR_LIT>' . split ( ) ) <EOL> def test_conflicting_parents ( self ) : <EOL> self . assertRaises ( <EOL> argparse . ArgumentError , <EOL> argparse . ArgumentParser , <EOL> parents = [ self . w_parent , self . wxyz_parent ] ) <EOL> def test_conflicting_parents_mutex ( self ) : <EOL> self . assertRaises ( <EOL> argparse . ArgumentError , <EOL> argparse . ArgumentParser , <EOL> parents = [ self . abcd_parent , self . ab_mutex_parent ] ) <EOL> def test_same_argument_name_parents ( self ) : <EOL> parents = [ self . wxyz_parent , self . z_parent ] <EOL> parser = ErrorRaisingArgumentParser ( parents = parents ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( w = None , y = None , z = '<STR_LIT:2>' ) ) <EOL> def test_subparser_parents ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> subparsers = parser . add_subparsers ( ) <EOL> abcde_parser = subparsers . add_parser ( '<STR_LIT:bar>' , parents = [ self . abcd_parent ] ) <EOL> abcde_parser . add_argument ( '<STR_LIT:e>' ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( a = '<STR_LIT:3>' , b = '<STR_LIT:1>' , d = '<STR_LIT:2>' , e = '<STR_LIT:4>' ) ) <EOL> def test_subparser_parents_mutex ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> subparsers = parser . add_subparsers ( ) <EOL> parents = [ self . ab_mutex_parent ] <EOL> abc_parser = subparsers . add_parser ( '<STR_LIT:foo>' , parents = parents ) <EOL> c_group = abc_parser . add_argument_group ( '<STR_LIT>' ) <EOL> c_group . add_argument ( '<STR_LIT:c>' ) <EOL> parents = [ self . wxyz_parent , self . ab_mutex_parent ] <EOL> wxyzabe_parser = subparsers . add_parser ( '<STR_LIT:bar>' , parents = parents ) <EOL> wxyzabe_parser . add_argument ( '<STR_LIT:e>' ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( a = True , b = False , c = '<STR_LIT:4>' ) ) <EOL> self . assertEqual ( parser . parse_args ( '<STR_LIT>' . split ( ) ) , <EOL> NS ( a = False , b = True , w = '<STR_LIT:2>' , y = None , z = '<STR_LIT:3>' , e = '<STR_LIT:4>' ) ) <EOL> self . assertArgumentParserError ( <EOL> parser . parse_args , '<STR_LIT>' . split ( ) ) <EOL> self . assertArgumentParserError ( <EOL> parser . parse_args , '<STR_LIT>' . split ( ) ) <EOL> def test_parent_help ( self ) : <EOL> parents = [ self . abcd_parent , self . wxyz_parent ] <EOL> parser = ErrorRaisingArgumentParser ( parents = parents ) <EOL> parser_help = parser . format_help ( ) <EOL> progname = self . main_program <EOL> self . assertEqual ( parser_help , textwrap . dedent ( '''<STR_LIT>''' . format ( progname , '<STR_LIT:U+0020>' if progname else '<STR_LIT>' ) ) ) <EOL> def test_groups_parents ( self ) : <EOL> parent = ErrorRaisingArgumentParser ( add_help = False ) <EOL> g = parent . add_argument_group ( title = '<STR_LIT:g>' , description = '<STR_LIT>' ) <EOL> g . add_argument ( '<STR_LIT>' ) <EOL> g . add_argument ( '<STR_LIT>' ) <EOL> m = parent . add_mutually_exclusive_group ( ) <EOL> m . add_argument ( '<STR_LIT>' ) <EOL> m . add_argument ( '<STR_LIT>' ) <EOL> parser = ErrorRaisingArgumentParser ( parents = [ parent ] ) <EOL> self . assertRaises ( ArgumentParserError , parser . parse_args , <EOL> [ '<STR_LIT>' , '<STR_LIT:Y>' , '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> parser_help = parser . format_help ( ) <EOL> progname = self . main_program <EOL> self . assertEqual ( parser_help , textwrap . dedent ( '''<STR_LIT>''' . format ( progname , '<STR_LIT:U+0020>' if progname else '<STR_LIT>' ) ) ) <EOL> class TestMutuallyExclusiveGroupErrors ( TestCase ) : <EOL> def test_invalid_add_argument_group ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> raises = self . assertRaises <EOL> raises ( TypeError , parser . add_mutually_exclusive_group , title = '<STR_LIT:foo>' ) <EOL> def test_invalid_add_argument ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> group = parser . add_mutually_exclusive_group ( ) <EOL> add_argument = group . add_argument <EOL> raises = self . assertRaises <EOL> raises ( ValueError , add_argument , '<STR_LIT>' , required = True ) <EOL> raises ( ValueError , add_argument , '<STR_LIT:bar>' ) <EOL> raises ( ValueError , add_argument , '<STR_LIT:bar>' , nargs = '<STR_LIT:+>' ) <EOL> raises ( ValueError , add_argument , '<STR_LIT:bar>' , nargs = <NUM_LIT:1> ) <EOL> raises ( ValueError , add_argument , '<STR_LIT:bar>' , nargs = argparse . PARSER ) <EOL> def test_help ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> group1 = parser . add_mutually_exclusive_group ( ) <EOL> group1 . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) <EOL> group1 . add_argument ( '<STR_LIT>' , action = '<STR_LIT>' ) <EOL> group2 = parser . add_mutually_exclusive_group ( ) <EOL> group2 . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) <EOL> group2 . add_argument ( '<STR_LIT>' , action = '<STR_LIT>' ) <EOL> expected = '''<STR_LIT>''' <EOL> self . assertEqual ( parser . format_help ( ) , textwrap . dedent ( expected ) ) <EOL> class MEMixin ( object ) : <EOL> def test_failures_when_not_required ( self ) : <EOL> parse_args = self . get_parser ( required = False ) . parse_args <EOL> error = ArgumentParserError <EOL> for args_string in self . failures : <EOL> self . assertRaises ( error , parse_args , args_string . split ( ) ) <EOL> def test_failures_when_required ( self ) : <EOL> parse_args = self . get_parser ( required = True ) . parse_args <EOL> error = ArgumentParserError <EOL> for args_string in self . failures + [ '<STR_LIT>' ] : <EOL> self . assertRaises ( error , parse_args , args_string . split ( ) ) <EOL> def test_successes_when_not_required ( self ) : <EOL> parse_args = self . get_parser ( required = False ) . parse_args <EOL> successes = self . successes + self . successes_when_not_required <EOL> for args_string , expected_ns in successes : <EOL> actual_ns = parse_args ( args_string . split ( ) ) <EOL> self . assertEqual ( actual_ns , expected_ns ) <EOL> def test_successes_when_required ( self ) : <EOL> parse_args = self . get_parser ( required = True ) . parse_args <EOL> for args_string , expected_ns in self . successes : <EOL> actual_ns = parse_args ( args_string . split ( ) ) <EOL> self . assertEqual ( actual_ns , expected_ns ) <EOL> def test_usage_when_not_required ( self ) : <EOL> format_usage = self . get_parser ( required = False ) . format_usage <EOL> expected_usage = self . usage_when_not_required <EOL> self . assertEqual ( format_usage ( ) , textwrap . dedent ( expected_usage ) ) <EOL> def test_usage_when_required ( self ) : <EOL> format_usage = self . get_parser ( required = True ) . format_usage <EOL> expected_usage = self . usage_when_required <EOL> self . assertEqual ( format_usage ( ) , textwrap . dedent ( expected_usage ) ) <EOL> def test_help_when_not_required ( self ) : <EOL> format_help = self . get_parser ( required = False ) . format_help <EOL> help = self . usage_when_not_required + self . help <EOL> self . assertEqual ( format_help ( ) , textwrap . dedent ( help ) ) <EOL> def test_help_when_required ( self ) : <EOL> format_help = self . get_parser ( required = True ) . format_help <EOL> help = self . usage_when_required + self . help <EOL> self . assertEqual ( format_help ( ) , textwrap . dedent ( help ) ) <EOL> class TestMutuallyExclusiveSimple ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required = None ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> group = parser . add_mutually_exclusive_group ( required = required ) <EOL> group . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , const = '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( bar = '<STR_LIT:X>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( bar = '<STR_LIT>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( bar = None , baz = '<STR_LIT:Y>' ) ) , <EOL> ( '<STR_LIT>' , NS ( bar = None , baz = '<STR_LIT>' ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT>' , NS ( bar = None , baz = None ) ) , <EOL> ] <EOL> usage_when_not_required = '''<STR_LIT>''' <EOL> usage_when_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class TestMutuallyExclusiveLong ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required = None ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> group = parser . add_mutually_exclusive_group ( required = required ) <EOL> group . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( abcde = None , fghij = None , klmno = '<STR_LIT:X>' , pqrst = None ) ) , <EOL> ( '<STR_LIT>' , <EOL> NS ( abcde = '<STR_LIT:Y>' , fghij = None , klmno = '<STR_LIT:X>' , pqrst = None ) ) , <EOL> ( '<STR_LIT>' , NS ( abcde = None , fghij = None , klmno = None , pqrst = '<STR_LIT:X>' ) ) , <EOL> ( '<STR_LIT>' , <EOL> NS ( abcde = None , fghij = '<STR_LIT:Y>' , klmno = None , pqrst = '<STR_LIT:X>' ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT>' , NS ( abcde = None , fghij = None , klmno = None , pqrst = None ) ) , <EOL> ] <EOL> usage_when_not_required = '''<STR_LIT>''' <EOL> usage_when_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class TestMutuallyExclusiveFirstSuppressed ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> group = parser . add_mutually_exclusive_group ( required = required ) <EOL> group . add_argument ( '<STR_LIT>' , help = argparse . SUPPRESS ) <EOL> group . add_argument ( '<STR_LIT>' , action = '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> failures = [ '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:X>' , y = True ) ) , <EOL> ( '<STR_LIT>' , NS ( x = '<STR_LIT:Y>' , y = True ) ) , <EOL> ( '<STR_LIT>' , NS ( x = None , y = False ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT>' , NS ( x = None , y = True ) ) , <EOL> ] <EOL> usage_when_not_required = '''<STR_LIT>''' <EOL> usage_when_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class TestMutuallyExclusiveManySuppressed ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> group = parser . add_mutually_exclusive_group ( required = required ) <EOL> add = group . add_argument <EOL> add ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = argparse . SUPPRESS ) <EOL> add ( '<STR_LIT>' , action = '<STR_LIT>' , help = argparse . SUPPRESS ) <EOL> add ( '<STR_LIT>' , help = argparse . SUPPRESS ) <EOL> return parser <EOL> failures = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( spam = True , badger = True , bladder = None ) ) , <EOL> ( '<STR_LIT>' , NS ( spam = False , badger = False , bladder = None ) ) , <EOL> ( '<STR_LIT>' , NS ( spam = False , badger = True , bladder = '<STR_LIT:B>' ) ) , <EOL> ( '<STR_LIT>' , NS ( spam = True , badger = True , bladder = None ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT>' , NS ( spam = False , badger = True , bladder = None ) ) , <EOL> ] <EOL> usage_when_required = usage_when_not_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class TestMutuallyExclusiveOptionalAndPositional ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> group = parser . add_mutually_exclusive_group ( required = required ) <EOL> group . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' , nargs = '<STR_LIT:*>' , default = '<STR_LIT:X>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> failures = [ <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> '<STR_LIT>' , <EOL> ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( foo = True , spam = None , badger = '<STR_LIT:X>' ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = False , spam = '<STR_LIT:S>' , badger = '<STR_LIT:X>' ) ) , <EOL> ( '<STR_LIT:X>' , NS ( foo = False , spam = None , badger = [ '<STR_LIT:X>' ] ) ) , <EOL> ( '<STR_LIT>' , NS ( foo = False , spam = None , badger = [ '<STR_LIT:X>' , '<STR_LIT:Y>' , '<STR_LIT>' ] ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT>' , NS ( foo = False , spam = None , badger = '<STR_LIT:X>' ) ) , <EOL> ] <EOL> usage_when_not_required = '''<STR_LIT>''' <EOL> usage_when_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class TestMutuallyExclusiveOptionalsMixed ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> group = parser . add_mutually_exclusive_group ( required = required ) <EOL> group . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT:-c>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( a = True , b = False , c = False , x = False , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = False , b = True , c = False , x = False , y = False ) ) , <EOL> ( '<STR_LIT:-c>' , NS ( a = False , b = False , c = True , x = False , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = True , b = False , c = False , x = True , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = False , b = True , c = False , x = False , y = True ) ) , <EOL> ( '<STR_LIT>' , NS ( a = False , b = False , c = True , x = True , y = True ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT>' , NS ( a = False , b = False , c = False , x = False , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = False , b = False , c = False , x = True , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = False , b = False , c = False , x = False , y = True ) ) , <EOL> ] <EOL> usage_when_required = usage_when_not_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class TestMutuallyExclusiveInGroup ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required = None ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> titled_group = parser . add_argument_group ( <EOL> title = '<STR_LIT>' , description = '<STR_LIT>' ) <EOL> mutex_group = titled_group . add_mutually_exclusive_group ( required = required ) <EOL> mutex_group . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> mutex_group . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( bar = '<STR_LIT:X>' , baz = None ) ) , <EOL> ( '<STR_LIT>' , NS ( bar = None , baz = '<STR_LIT:Y>' ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT>' , NS ( bar = None , baz = None ) ) , <EOL> ] <EOL> usage_when_not_required = '''<STR_LIT>''' <EOL> usage_when_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class TestMutuallyExclusiveOptionalsAndPositionalsMixed ( MEMixin , TestCase ) : <EOL> def get_parser ( self , required ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT:x>' , help = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> group = parser . add_mutually_exclusive_group ( required = required ) <EOL> group . add_argument ( '<STR_LIT:a>' , nargs = '<STR_LIT:?>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT:-c>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) <EOL> return parser <EOL> failures = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> successes = [ <EOL> ( '<STR_LIT>' , NS ( a = '<STR_LIT:A>' , b = False , c = False , x = '<STR_LIT:X>' , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = None , b = True , c = False , x = '<STR_LIT:X>' , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = None , b = False , c = True , x = '<STR_LIT:X>' , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = '<STR_LIT:A>' , b = False , c = False , x = '<STR_LIT:X>' , y = True ) ) , <EOL> ( '<STR_LIT>' , NS ( a = None , b = True , c = False , x = '<STR_LIT:X>' , y = True ) ) , <EOL> ] <EOL> successes_when_not_required = [ <EOL> ( '<STR_LIT:X>' , NS ( a = None , b = False , c = False , x = '<STR_LIT:X>' , y = False ) ) , <EOL> ( '<STR_LIT>' , NS ( a = None , b = False , c = False , x = '<STR_LIT:X>' , y = True ) ) , <EOL> ] <EOL> usage_when_required = usage_when_not_required = '''<STR_LIT>''' <EOL> help = '''<STR_LIT>''' <EOL> class MEPBase ( object ) : <EOL> def get_parser ( self , required = None ) : <EOL> parent = super ( MEPBase , self ) . get_parser ( required = required ) <EOL> parser = ErrorRaisingArgumentParser ( <EOL> prog = parent . prog , add_help = False , parents = [ parent ] ) <EOL> return parser <EOL> class TestMutuallyExclusiveGroupErrorsParent ( <EOL> MEPBase , TestMutuallyExclusiveGroupErrors ) : <EOL> pass <EOL> class TestMutuallyExclusiveSimpleParent ( <EOL> MEPBase , TestMutuallyExclusiveSimple ) : <EOL> pass <EOL> class TestMutuallyExclusiveLongParent ( <EOL> MEPBase , TestMutuallyExclusiveLong ) : <EOL> pass <EOL> class TestMutuallyExclusiveFirstSuppressedParent ( <EOL> MEPBase , TestMutuallyExclusiveFirstSuppressed ) : <EOL> pass <EOL> class TestMutuallyExclusiveManySuppressedParent ( <EOL> MEPBase , TestMutuallyExclusiveManySuppressed ) : <EOL> pass <EOL> class TestMutuallyExclusiveOptionalAndPositionalParent ( <EOL> MEPBase , TestMutuallyExclusiveOptionalAndPositional ) : <EOL> pass <EOL> class TestMutuallyExclusiveOptionalsMixedParent ( <EOL> MEPBase , TestMutuallyExclusiveOptionalsMixed ) : <EOL> pass <EOL> class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent ( <EOL> MEPBase , TestMutuallyExclusiveOptionalsAndPositionalsMixed ) : <EOL> pass <EOL> class TestSetDefaults ( TestCase ) : <EOL> def test_set_defaults_no_args ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . set_defaults ( x = '<STR_LIT:foo>' ) <EOL> parser . set_defaults ( y = '<STR_LIT:bar>' , z = <NUM_LIT:1> ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT:foo>' , y = '<STR_LIT:bar>' , z = <NUM_LIT:1> ) , <EOL> parser . parse_args ( [ ] ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT:foo>' , y = '<STR_LIT:bar>' , z = <NUM_LIT:1> ) , <EOL> parser . parse_args ( [ ] , NS ( ) ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT>' , y = '<STR_LIT:bar>' , z = <NUM_LIT:1> ) , <EOL> parser . parse_args ( [ ] , NS ( x = '<STR_LIT>' ) ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT>' , y = '<STR_LIT:bar>' , z = <NUM_LIT:2> ) , <EOL> parser . parse_args ( [ ] , NS ( x = '<STR_LIT>' , z = <NUM_LIT:2> ) ) ) <EOL> def test_set_defaults_with_args ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . set_defaults ( x = '<STR_LIT:foo>' , y = '<STR_LIT:bar>' ) <EOL> parser . add_argument ( '<STR_LIT>' , default = '<STR_LIT>' ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT>' , y = '<STR_LIT:bar>' ) , <EOL> parser . parse_args ( [ ] ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT>' , y = '<STR_LIT:bar>' ) , <EOL> parser . parse_args ( [ ] , NS ( ) ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT>' , y = '<STR_LIT:bar>' ) , <EOL> parser . parse_args ( [ ] , NS ( x = '<STR_LIT>' ) ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT:1>' , y = '<STR_LIT:bar>' ) , <EOL> parser . parse_args ( '<STR_LIT>' . split ( ) ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT:1>' , y = '<STR_LIT:bar>' ) , <EOL> parser . parse_args ( '<STR_LIT>' . split ( ) , NS ( ) ) ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT:1>' , y = '<STR_LIT:bar>' ) , <EOL> parser . parse_args ( '<STR_LIT>' . split ( ) , NS ( x = '<STR_LIT>' ) ) ) <EOL> def test_set_defaults_subparsers ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . set_defaults ( x = '<STR_LIT:foo>' ) <EOL> subparsers = parser . add_subparsers ( ) <EOL> parser_a = subparsers . add_parser ( '<STR_LIT:a>' ) <EOL> parser_a . set_defaults ( y = '<STR_LIT:bar>' ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT:foo>' , y = '<STR_LIT:bar>' ) , <EOL> parser . parse_args ( '<STR_LIT:a>' . split ( ) ) ) <EOL> def test_set_defaults_parents ( self ) : <EOL> parent = ErrorRaisingArgumentParser ( add_help = False ) <EOL> parent . set_defaults ( x = '<STR_LIT:foo>' ) <EOL> parser = ErrorRaisingArgumentParser ( parents = [ parent ] ) <EOL> self . assertEqual ( NS ( x = '<STR_LIT:foo>' ) , parser . parse_args ( [ ] ) ) <EOL> def test_set_defaults_same_as_add_argument ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . set_defaults ( w = '<STR_LIT>' , x = '<STR_LIT:X>' , y = '<STR_LIT:Y>' , z = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , default = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT:y>' , nargs = '<STR_LIT:?>' ) <EOL> parser . add_argument ( '<STR_LIT:z>' , nargs = '<STR_LIT:?>' , default = '<STR_LIT>' ) <EOL> self . assertEqual ( NS ( w = '<STR_LIT>' , x = '<STR_LIT>' , y = '<STR_LIT:Y>' , z = '<STR_LIT>' ) , <EOL> parser . parse_args ( [ ] ) ) <EOL> parser . set_defaults ( w = '<STR_LIT>' , x = '<STR_LIT:X>' , y = '<STR_LIT>' , z = '<STR_LIT>' ) <EOL> self . assertEqual ( NS ( w = '<STR_LIT>' , x = '<STR_LIT:X>' , y = '<STR_LIT>' , z = '<STR_LIT>' ) , <EOL> parser . parse_args ( [ ] ) ) <EOL> def test_set_defaults_same_as_add_argument_group ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . set_defaults ( w = '<STR_LIT>' , x = '<STR_LIT:X>' , y = '<STR_LIT:Y>' , z = '<STR_LIT>' ) <EOL> group = parser . add_argument_group ( '<STR_LIT:foo>' ) <EOL> group . add_argument ( '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT>' , default = '<STR_LIT>' ) <EOL> group . add_argument ( '<STR_LIT:y>' , nargs = '<STR_LIT:?>' ) <EOL> group . add_argument ( '<STR_LIT:z>' , nargs = '<STR_LIT:?>' , default = '<STR_LIT>' ) <EOL> self . assertEqual ( NS ( w = '<STR_LIT>' , x = '<STR_LIT>' , y = '<STR_LIT:Y>' , z = '<STR_LIT>' ) , <EOL> parser . parse_args ( [ ] ) ) <EOL> parser . set_defaults ( w = '<STR_LIT>' , x = '<STR_LIT:X>' , y = '<STR_LIT>' , z = '<STR_LIT>' ) <EOL> self . assertEqual ( NS ( w = '<STR_LIT>' , x = '<STR_LIT:X>' , y = '<STR_LIT>' , z = '<STR_LIT>' ) , <EOL> parser . parse_args ( [ ] ) ) <EOL> class TestGetDefault ( TestCase ) : <EOL> def test_get_default ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> self . assertEqual ( None , parser . get_default ( "<STR_LIT:foo>" ) ) <EOL> self . assertEqual ( None , parser . get_default ( "<STR_LIT:bar>" ) ) <EOL> parser . add_argument ( "<STR_LIT>" ) <EOL> self . assertEqual ( None , parser . get_default ( "<STR_LIT:foo>" ) ) <EOL> self . assertEqual ( None , parser . get_default ( "<STR_LIT:bar>" ) ) <EOL> parser . add_argument ( "<STR_LIT>" , type = int , default = <NUM_LIT> ) <EOL> self . assertEqual ( None , parser . get_default ( "<STR_LIT:foo>" ) ) <EOL> self . assertEqual ( <NUM_LIT> , parser . get_default ( "<STR_LIT:bar>" ) ) <EOL> parser . set_defaults ( foo = "<STR_LIT>" ) <EOL> self . assertEqual ( "<STR_LIT>" , parser . get_default ( "<STR_LIT:foo>" ) ) <EOL> self . assertEqual ( <NUM_LIT> , parser . get_default ( "<STR_LIT:bar>" ) ) <EOL> class TestNamespaceContainsSimple ( TestCase ) : <EOL> def test_empty ( self ) : <EOL> ns = argparse . Namespace ( ) <EOL> self . assertEqual ( '<STR_LIT>' in ns , False ) <EOL> self . assertEqual ( '<STR_LIT>' not in ns , True ) <EOL> self . assertEqual ( '<STR_LIT:x>' in ns , False ) <EOL> def test_non_empty ( self ) : <EOL> ns = argparse . Namespace ( x = <NUM_LIT:1> , y = <NUM_LIT:2> ) <EOL> self . assertEqual ( '<STR_LIT:x>' in ns , True ) <EOL> self . assertEqual ( '<STR_LIT:x>' not in ns , False ) <EOL> self . assertEqual ( '<STR_LIT:y>' in ns , True ) <EOL> self . assertEqual ( '<STR_LIT>' in ns , False ) <EOL> self . assertEqual ( '<STR_LIT>' in ns , False ) <EOL> self . assertEqual ( '<STR_LIT:z>' in ns , False ) <EOL> class TestHelpFormattingMetaclass ( type ) : <EOL> def __init__ ( cls , name , bases , bodydict ) : <EOL> if name == '<STR_LIT>' : <EOL> return <EOL> class AddTests ( object ) : <EOL> def __init__ ( self , test_class , func_suffix , std_name ) : <EOL> self . func_suffix = func_suffix <EOL> self . std_name = std_name <EOL> for test_func in [ self . test_format , <EOL> self . test_print , <EOL> self . test_print_file ] : <EOL> test_name = '<STR_LIT>' % ( test_func . __name__ , func_suffix ) <EOL> def test_wrapper ( self , test_func = test_func ) : <EOL> test_func ( self ) <EOL> try : <EOL> test_wrapper . __name__ = test_name <EOL> except TypeError : <EOL> pass <EOL> setattr ( test_class , test_name , test_wrapper ) <EOL> def _get_parser ( self , tester ) : <EOL> parser = argparse . ArgumentParser ( <EOL> * tester . parser_signature . args , <EOL> ** tester . parser_signature . kwargs ) <EOL> for argument_sig in getattr ( tester , '<STR_LIT>' , [ ] ) : <EOL> parser . add_argument ( * argument_sig . args , <EOL> ** argument_sig . kwargs ) <EOL> group_sigs = getattr ( tester , '<STR_LIT>' , [ ] ) <EOL> for group_sig , argument_sigs in group_sigs : <EOL> group = parser . add_argument_group ( * group_sig . args , <EOL> ** group_sig . kwargs ) <EOL> for argument_sig in argument_sigs : <EOL> group . add_argument ( * argument_sig . args , <EOL> ** argument_sig . kwargs ) <EOL> subparsers_sigs = getattr ( tester , '<STR_LIT>' , [ ] ) <EOL> if subparsers_sigs : <EOL> subparsers = parser . add_subparsers ( ) <EOL> for subparser_sig in subparsers_sigs : <EOL> subparsers . add_parser ( * subparser_sig . args , <EOL> ** subparser_sig . kwargs ) <EOL> return parser <EOL> def _test ( self , tester , parser_text ) : <EOL> expected_text = getattr ( tester , self . func_suffix ) <EOL> expected_text = textwrap . dedent ( expected_text ) <EOL> if expected_text != parser_text : <EOL> print ( repr ( expected_text ) ) <EOL> print ( repr ( parser_text ) ) <EOL> for char1 , char2 in zip ( expected_text , parser_text ) : <EOL> if char1 != char2 : <EOL> print ( '<STR_LIT>' % ( char1 , char2 ) ) <EOL> break <EOL> tester . assertEqual ( expected_text , parser_text ) <EOL> def test_format ( self , tester ) : <EOL> parser = self . _get_parser ( tester ) <EOL> format = getattr ( parser , '<STR_LIT>' % self . func_suffix ) <EOL> self . _test ( tester , format ( ) ) <EOL> def test_print ( self , tester ) : <EOL> parser = self . _get_parser ( tester ) <EOL> print_ = getattr ( parser , '<STR_LIT>' % self . func_suffix ) <EOL> old_stream = getattr ( sys , self . std_name ) <EOL> setattr ( sys , self . std_name , StdIOBuffer ( ) ) <EOL> try : <EOL> print_ ( ) <EOL> parser_text = getattr ( sys , self . std_name ) . getvalue ( ) <EOL> finally : <EOL> setattr ( sys , self . std_name , old_stream ) <EOL> self . _test ( tester , parser_text ) <EOL> def test_print_file ( self , tester ) : <EOL> parser = self . _get_parser ( tester ) <EOL> print_ = getattr ( parser , '<STR_LIT>' % self . func_suffix ) <EOL> sfile = StdIOBuffer ( ) <EOL> print_ ( sfile ) <EOL> parser_text = sfile . getvalue ( ) <EOL> self . _test ( tester , parser_text ) <EOL> for func_suffix , std_name in [ ( '<STR_LIT>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT>' , '<STR_LIT>' ) ] : <EOL> AddTests ( cls , func_suffix , std_name ) <EOL> bases = TestCase , <EOL> HelpTestCase = TestHelpFormattingMetaclass ( '<STR_LIT>' , bases , { } ) <EOL> class TestHelpBiggerOptionals ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , description = '<STR_LIT>' , <EOL> epilog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:foo>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:bar>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '''<STR_LIT>''' <EOL> class TestHelpBiggerOptionalGroups ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , description = '<STR_LIT>' , <EOL> epilog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:foo>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:bar>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT>' , description = '<STR_LIT>' ) , [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:+>' , help = '<STR_LIT>' ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '''<STR_LIT>''' <EOL> class TestHelpBiggerPositionals ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( usage = '<STR_LIT>' , description = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:bar>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpReformatting ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( <EOL> prog = '<STR_LIT>' , <EOL> description = '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT:\n>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' , help = '<STR_LIT>' <EOL> '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:y>' , metavar = '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT:title>' , description = '<STR_LIT:\n>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT:\n>' <EOL> '<STR_LIT:description>' ) , <EOL> [ Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , <EOL> help = '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpWrappingShortNames ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , description = '<STR_LIT>' * <NUM_LIT:30> ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' , help = '<STR_LIT>' * <NUM_LIT:20> ) , <EOL> Sig ( '<STR_LIT:y>' , metavar = '<STR_LIT>' , help = '<STR_LIT>' * <NUM_LIT:20> ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT>' ) , [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' * <NUM_LIT:10> ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpWrappingLongNames ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( usage = '<STR_LIT>' , description = '<STR_LIT>' * <NUM_LIT:30> ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' * <NUM_LIT:30> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:X>' * <NUM_LIT> , help = '<STR_LIT>' * <NUM_LIT:20> ) , <EOL> Sig ( '<STR_LIT:y>' , metavar = '<STR_LIT:y>' * <NUM_LIT> , help = '<STR_LIT>' * <NUM_LIT:20> ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT>' ) , [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:A>' * <NUM_LIT> , help = '<STR_LIT>' * <NUM_LIT:20> ) , <EOL> Sig ( '<STR_LIT:z>' , metavar = '<STR_LIT:z>' * <NUM_LIT> , help = '<STR_LIT>' * <NUM_LIT:20> ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '''<STR_LIT>''' <EOL> class TestHelpUsage ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:+>' , help = '<STR_LIT:w>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:*>' , help = '<STR_LIT:x>' ) , <EOL> Sig ( '<STR_LIT:a>' , help = '<STR_LIT:a>' ) , <EOL> Sig ( '<STR_LIT:b>' , help = '<STR_LIT:b>' , nargs = <NUM_LIT:2> ) , <EOL> Sig ( '<STR_LIT:c>' , help = '<STR_LIT:c>' , nargs = '<STR_LIT:?>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT>' ) , [ <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , help = '<STR_LIT:y>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = <NUM_LIT:3> , help = '<STR_LIT:z>' ) , <EOL> Sig ( '<STR_LIT:d>' , help = '<STR_LIT:d>' , nargs = '<STR_LIT:*>' ) , <EOL> Sig ( '<STR_LIT:e>' , help = '<STR_LIT:e>' , nargs = '<STR_LIT:+>' ) , <EOL> ] ) <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpOnlyUserGroups ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT>' ) , [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT:x>' ) , <EOL> Sig ( '<STR_LIT:a>' , help = '<STR_LIT:a>' ) , <EOL> ] ) , <EOL> ( Sig ( '<STR_LIT>' ) , [ <EOL> Sig ( '<STR_LIT:b>' , help = '<STR_LIT:b>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT:y>' ) , <EOL> ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsageLongProg ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT:P>' * <NUM_LIT> ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:X>' ) , <EOL> Sig ( '<STR_LIT:a>' ) , <EOL> Sig ( '<STR_LIT:b>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsageLongProgOptionsWrap ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT:P>' * <NUM_LIT> ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:X>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:Y>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:a>' ) , <EOL> Sig ( '<STR_LIT:b>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsageLongProgPositionalsWrap ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT:P>' * <NUM_LIT> , add_help = False ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:a>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:b>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:c>' * <NUM_LIT> ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsageOptionalsWrap ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:X>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:Y>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:a>' ) , <EOL> Sig ( '<STR_LIT:b>' ) , <EOL> Sig ( '<STR_LIT:c>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsagePositionalsWrap ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT:a>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:b>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:c>' * <NUM_LIT> ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsageOptionalsPositionalsWrap ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:X>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:Y>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:a>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:b>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:c>' * <NUM_LIT> ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsageOptionalsOnlyWrap ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:X>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT:Y>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT>' , metavar = '<STR_LIT>' * <NUM_LIT> ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpUsagePositionalsOnlyWrap ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT:a>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:b>' * <NUM_LIT> ) , <EOL> Sig ( '<STR_LIT:c>' * <NUM_LIT> ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpVariableExpansion ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , type = int , <EOL> help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT>' , default = <NUM_LIT> , const = '<STR_LIT>' , <EOL> help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , choices = '<STR_LIT:abc>' , <EOL> help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , default = '<STR_LIT>' , choices = [ <NUM_LIT:1> , <NUM_LIT:2> ] , metavar = '<STR_LIT>' , <EOL> help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , default = <NUM_LIT:0.5> , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT>' ) , [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , default = - <NUM_LIT:1> , help = '<STR_LIT>' ) , <EOL> ] ) <EOL> ] <EOL> usage = ( '''<STR_LIT>''' ) <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpVariableExpansionUsageSupplied ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , usage = '<STR_LIT>' ) <EOL> argument_signatures = [ ] <EOL> argument_group_signatures = [ ] <EOL> usage = ( '''<STR_LIT>''' ) <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpVariableExpansionNoArguments ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ ] <EOL> argument_group_signatures = [ ] <EOL> usage = ( '''<STR_LIT>''' ) <EOL> help = usage <EOL> version = '<STR_LIT>' <EOL> class TestHelpSuppressUsage ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , usage = argparse . SUPPRESS ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> help = '''<STR_LIT>''' <EOL> usage = '<STR_LIT>' <EOL> version = '<STR_LIT>' <EOL> class TestHelpSuppressOptional ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = argparse . SUPPRESS ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpSuppressOptionalGroup ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT>' ) , [ Sig ( '<STR_LIT>' , help = argparse . SUPPRESS ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpSuppressPositional ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = argparse . SUPPRESS ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpRequiredOptional ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , required = True , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpAlternatePrefixChars ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , prefix_chars = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpNoHelpOptional ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , add_help = False ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpVersionOptional ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT:1.0>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '''<STR_LIT>''' <EOL> class TestHelpNone ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpTupleMetavar ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT:w>' , nargs = '<STR_LIT:+>' , metavar = ( '<STR_LIT>' , '<STR_LIT>' ) ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT:x>' , nargs = '<STR_LIT:*>' , metavar = ( '<STR_LIT>' , '<STR_LIT>' ) ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT:y>' , nargs = <NUM_LIT:3> , metavar = ( '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ) ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT:z>' , nargs = '<STR_LIT:?>' , metavar = ( '<STR_LIT>' , ) ) , <EOL> ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpRawText ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( <EOL> prog = '<STR_LIT>' , formatter_class = argparse . RawTextHelpFormatter , <EOL> description = '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT:\n>' <EOL> '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' <EOL> '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT:title>' , description = '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) , <EOL> [ Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpRawDescription ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( <EOL> prog = '<STR_LIT>' , formatter_class = argparse . RawDescriptionHelpFormatter , <EOL> description = '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT:\n>' <EOL> '<STR_LIT>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' <EOL> '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT:title>' , description = '<STR_LIT>' <EOL> '<STR_LIT>' <EOL> '<STR_LIT>' ) , <EOL> [ Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpArgumentDefaults ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( <EOL> prog = '<STR_LIT>' , formatter_class = argparse . ArgumentDefaultsHelpFormatter , <EOL> description = '<STR_LIT:description>' ) <EOL> argument_signatures = [ <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , action = '<STR_LIT:store_true>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> Sig ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , default = '<STR_LIT>' , help = '<STR_LIT>' ) , <EOL> ] <EOL> argument_group_signatures = [ <EOL> ( Sig ( '<STR_LIT:title>' , description = '<STR_LIT:description>' ) , <EOL> [ Sig ( '<STR_LIT>' , type = int , default = <NUM_LIT> , help = '<STR_LIT>' ) ] ) , <EOL> ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpVersionAction ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , description = '<STR_LIT:description>' ) <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' ) ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestHelpSubparsersOrdering ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , <EOL> description = '<STR_LIT>' ) <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' ) ] <EOL> subparsers_signatures = [ Sig ( name = name ) <EOL> for name in ( '<STR_LIT:a>' , '<STR_LIT:b>' , '<STR_LIT:c>' , '<STR_LIT:d>' , '<STR_LIT:e>' ) ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '''<STR_LIT>''' <EOL> class TestHelpSubparsersWithHelpOrdering ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , <EOL> description = '<STR_LIT>' ) <EOL> argument_signatures = [ Sig ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' ) ] <EOL> subcommand_data = ( ( '<STR_LIT:a>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT:b>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT:c>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT:d>' , '<STR_LIT>' ) , <EOL> ( '<STR_LIT:e>' , '<STR_LIT>' ) , <EOL> ) <EOL> subparsers_signatures = [ Sig ( name = name , help = help ) <EOL> for name , help in subcommand_data ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '''<STR_LIT>''' <EOL> class TestHelpMetavarTypeFormatter ( HelpTestCase ) : <EOL> """<STR_LIT>""" <EOL> def custom_type ( string ) : <EOL> return string <EOL> parser_signature = Sig ( prog = '<STR_LIT>' , description = '<STR_LIT:description>' , <EOL> formatter_class = argparse . MetavarTypeHelpFormatter ) <EOL> argument_signatures = [ Sig ( '<STR_LIT:a>' , type = int ) , <EOL> Sig ( '<STR_LIT>' , type = custom_type ) , <EOL> Sig ( '<STR_LIT:-c>' , type = float , metavar = '<STR_LIT>' ) ] <EOL> argument_group_signatures = [ ] <EOL> usage = '''<STR_LIT>''' <EOL> help = usage + '''<STR_LIT>''' <EOL> version = '<STR_LIT>' <EOL> class TestInvalidArgumentConstructors ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def assertTypeError ( self , * args , ** kwargs ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> self . assertRaises ( TypeError , parser . add_argument , <EOL> * args , ** kwargs ) <EOL> def assertValueError ( self , * args , ** kwargs ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> self . assertRaises ( ValueError , parser . add_argument , <EOL> * args , ** kwargs ) <EOL> def test_invalid_keyword_arguments ( self ) : <EOL> self . assertTypeError ( '<STR_LIT>' , bar = None ) <EOL> self . assertTypeError ( '<STR_LIT>' , callback = '<STR_LIT:foo>' ) <EOL> self . assertTypeError ( '<STR_LIT>' , callback_args = ( ) ) <EOL> self . assertTypeError ( '<STR_LIT>' , callback_kwargs = { } ) <EOL> def test_missing_destination ( self ) : <EOL> self . assertTypeError ( ) <EOL> for action in [ '<STR_LIT>' , '<STR_LIT:store>' ] : <EOL> self . assertTypeError ( action = action ) <EOL> def test_invalid_option_strings ( self ) : <EOL> self . assertValueError ( '<STR_LIT>' ) <EOL> self . assertValueError ( '<STR_LIT>' ) <EOL> def test_invalid_type ( self ) : <EOL> self . assertValueError ( '<STR_LIT>' , type = '<STR_LIT:int>' ) <EOL> self . assertValueError ( '<STR_LIT>' , type = ( int , float ) ) <EOL> def test_invalid_action ( self ) : <EOL> self . assertValueError ( '<STR_LIT>' , action = '<STR_LIT:foo>' ) <EOL> self . assertValueError ( '<STR_LIT:foo>' , action = '<STR_LIT>' ) <EOL> self . assertValueError ( '<STR_LIT>' , action = ( '<STR_LIT:store>' , '<STR_LIT>' ) ) <EOL> parser = argparse . ArgumentParser ( ) <EOL> try : <EOL> parser . add_argument ( "<STR_LIT>" , action = "<STR_LIT>" ) <EOL> except ValueError : <EOL> e = sys . exc_info ( ) [ <NUM_LIT:1> ] <EOL> expected = '<STR_LIT>' <EOL> msg = '<STR_LIT>' % ( expected , e ) <EOL> self . assertTrue ( expected in str ( e ) , msg ) <EOL> def test_multiple_dest ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( dest = '<STR_LIT:foo>' ) <EOL> try : <EOL> parser . add_argument ( '<STR_LIT:bar>' , dest = '<STR_LIT>' ) <EOL> except ValueError : <EOL> e = sys . exc_info ( ) [ <NUM_LIT:1> ] <EOL> expected = '<STR_LIT>' <EOL> msg = '<STR_LIT>' % ( expected , e ) <EOL> self . assertTrue ( expected in str ( e ) , msg ) <EOL> def test_no_argument_actions ( self ) : <EOL> for action in [ '<STR_LIT>' , '<STR_LIT:store_true>' , '<STR_LIT>' , <EOL> '<STR_LIT>' , '<STR_LIT:count>' ] : <EOL> for attrs in [ dict ( type = int ) , dict ( nargs = '<STR_LIT:+>' ) , <EOL> dict ( choices = '<STR_LIT>' ) ] : <EOL> self . assertTypeError ( '<STR_LIT>' , action = action , ** attrs ) <EOL> def test_no_argument_no_const_actions ( self ) : <EOL> for action in [ '<STR_LIT:store_true>' , '<STR_LIT>' , '<STR_LIT:count>' ] : <EOL> self . assertTypeError ( '<STR_LIT>' , const = '<STR_LIT:foo>' , action = action ) <EOL> self . assertTypeError ( '<STR_LIT>' , nargs = '<STR_LIT:*>' , action = action ) <EOL> def test_more_than_one_argument_actions ( self ) : <EOL> for action in [ '<STR_LIT:store>' , '<STR_LIT>' ] : <EOL> self . assertValueError ( '<STR_LIT>' , nargs = <NUM_LIT:0> , action = action ) <EOL> self . assertValueError ( '<STR_LIT>' , nargs = <NUM_LIT:0> , action = action ) <EOL> for nargs in [ <NUM_LIT:1> , '<STR_LIT:*>' , '<STR_LIT:+>' ] : <EOL> self . assertValueError ( '<STR_LIT>' , const = '<STR_LIT:foo>' , <EOL> nargs = nargs , action = action ) <EOL> self . assertValueError ( '<STR_LIT>' , const = '<STR_LIT:foo>' , <EOL> nargs = nargs , action = action ) <EOL> def test_required_const_actions ( self ) : <EOL> for action in [ '<STR_LIT>' , '<STR_LIT>' ] : <EOL> self . assertTypeError ( '<STR_LIT>' , nargs = '<STR_LIT:+>' , action = action ) <EOL> def test_parsers_action_missing_params ( self ) : <EOL> self . assertTypeError ( '<STR_LIT>' , action = '<STR_LIT>' ) <EOL> self . assertTypeError ( '<STR_LIT>' , action = '<STR_LIT>' , prog = '<STR_LIT>' ) <EOL> self . assertTypeError ( '<STR_LIT>' , action = '<STR_LIT>' , <EOL> parser_class = argparse . ArgumentParser ) <EOL> def test_required_positional ( self ) : <EOL> self . assertTypeError ( '<STR_LIT:foo>' , required = True ) <EOL> def test_user_defined_action ( self ) : <EOL> class Success ( Exception ) : <EOL> pass <EOL> class Action ( object ) : <EOL> def __init__ ( self , <EOL> option_strings , <EOL> dest , <EOL> const , <EOL> default , <EOL> required = False ) : <EOL> if dest == '<STR_LIT>' : <EOL> if const is Success : <EOL> if default is Success : <EOL> raise Success ( ) <EOL> def __call__ ( self , * args , ** kwargs ) : <EOL> pass <EOL> parser = argparse . ArgumentParser ( ) <EOL> self . assertRaises ( Success , parser . add_argument , '<STR_LIT>' , <EOL> action = Action , default = Success , const = Success ) <EOL> self . assertRaises ( Success , parser . add_argument , '<STR_LIT>' , <EOL> action = Action , default = Success , const = Success ) <EOL> class TestActionsReturned ( TestCase ) : <EOL> def test_dest ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> action = parser . add_argument ( '<STR_LIT>' ) <EOL> self . assertEqual ( action . dest , '<STR_LIT:foo>' ) <EOL> action = parser . add_argument ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . assertEqual ( action . dest , '<STR_LIT:bar>' ) <EOL> action = parser . add_argument ( '<STR_LIT>' , '<STR_LIT>' ) <EOL> self . assertEqual ( action . dest , '<STR_LIT:x>' ) <EOL> def test_misc ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> action = parser . add_argument ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , const = <NUM_LIT> , <EOL> default = <NUM_LIT> , type = int , choices = [ <NUM_LIT:1> , <NUM_LIT:2> ] , <EOL> help = '<STR_LIT>' , metavar = '<STR_LIT>' , dest = '<STR_LIT>' ) <EOL> self . assertEqual ( action . nargs , '<STR_LIT:?>' ) <EOL> self . assertEqual ( action . const , <NUM_LIT> ) <EOL> self . assertEqual ( action . default , <NUM_LIT> ) <EOL> self . assertEqual ( action . type , int ) <EOL> self . assertEqual ( action . choices , [ <NUM_LIT:1> , <NUM_LIT:2> ] ) <EOL> self . assertEqual ( action . help , '<STR_LIT>' ) <EOL> self . assertEqual ( action . metavar , '<STR_LIT>' ) <EOL> self . assertEqual ( action . dest , '<STR_LIT>' ) <EOL> class TestConflictHandling ( TestCase ) : <EOL> def test_bad_type ( self ) : <EOL> self . assertRaises ( ValueError , argparse . ArgumentParser , <EOL> conflict_handler = '<STR_LIT:foo>' ) <EOL> def test_conflict_error ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> self . assertRaises ( argparse . ArgumentError , <EOL> parser . add_argument , '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> self . assertRaises ( argparse . ArgumentError , <EOL> parser . add_argument , '<STR_LIT>' ) <EOL> def test_resolve_error ( self ) : <EOL> get_parser = argparse . ArgumentParser <EOL> parser = get_parser ( prog = '<STR_LIT>' , conflict_handler = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , help = '<STR_LIT>' ) <EOL> self . assertEqual ( parser . format_help ( ) , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> parser . add_argument ( '<STR_LIT>' , metavar = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , metavar = '<STR_LIT>' ) <EOL> self . assertEqual ( parser . format_help ( ) , textwrap . dedent ( '''<STR_LIT>''' ) ) <EOL> class TestOptionalsHelpVersionActions ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def _get_error ( self , func , * args , ** kwargs ) : <EOL> try : <EOL> func ( * args , ** kwargs ) <EOL> except ArgumentParserError : <EOL> return sys . exc_info ( ) [ <NUM_LIT:1> ] <EOL> else : <EOL> self . assertRaises ( ArgumentParserError , func , * args , ** kwargs ) <EOL> def assertPrintHelpExit ( self , parser , args_str ) : <EOL> self . assertEqual ( <EOL> parser . format_help ( ) , <EOL> self . _get_error ( parser . parse_args , args_str . split ( ) ) . stdout ) <EOL> def assertArgumentParserError ( self , parser , * args ) : <EOL> self . assertRaises ( ArgumentParserError , parser . parse_args , args ) <EOL> def test_version ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT:1.0>' ) <EOL> self . assertPrintHelpExit ( parser , '<STR_LIT>' ) <EOL> self . assertPrintHelpExit ( parser , '<STR_LIT>' ) <EOL> self . assertRaises ( AttributeError , getattr , parser , '<STR_LIT>' ) <EOL> def test_version_format ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' ) <EOL> msg = self . _get_error ( parser . parse_args , [ '<STR_LIT>' ] ) . stderr <EOL> self . assertEqual ( '<STR_LIT>' , msg ) <EOL> def test_version_no_help ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( add_help = False ) <EOL> parser . add_argument ( '<STR_LIT>' , '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT:1.0>' ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> self . assertRaises ( AttributeError , getattr , parser , '<STR_LIT>' ) <EOL> def test_version_action ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT>' ) <EOL> msg = self . _get_error ( parser . parse_args , [ '<STR_LIT>' ] ) . stderr <EOL> self . assertEqual ( '<STR_LIT>' , msg ) <EOL> def test_no_help ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( add_help = False ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> def test_alternate_help_version ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:version>' ) <EOL> self . assertPrintHelpExit ( parser , '<STR_LIT>' ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> self . assertArgumentParserError ( parser , '<STR_LIT>' ) <EOL> self . assertRaises ( AttributeError , getattr , parser , '<STR_LIT>' ) <EOL> def test_help_version_extra_arguments ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:version>' , version = '<STR_LIT:1.0>' ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT:store_true>' ) <EOL> parser . add_argument ( '<STR_LIT:y>' ) <EOL> valid_prefixes = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT:foo>' , '<STR_LIT>' , '<STR_LIT>' ] <EOL> valid_suffixes = valid_prefixes + [ '<STR_LIT>' , '<STR_LIT>' ] <EOL> for prefix in valid_prefixes : <EOL> for suffix in valid_suffixes : <EOL> format = '<STR_LIT>' % ( prefix , suffix ) <EOL> self . assertPrintHelpExit ( parser , format % '<STR_LIT>' ) <EOL> self . assertPrintHelpExit ( parser , format % '<STR_LIT>' ) <EOL> self . assertRaises ( AttributeError , getattr , parser , '<STR_LIT>' ) <EOL> class TestStrings ( TestCase ) : <EOL> """<STR_LIT>""" <EOL> def assertStringEqual ( self , obj , result_string ) : <EOL> for func in [ str , repr ] : <EOL> self . assertEqual ( func ( obj ) , result_string ) <EOL> def test_optional ( self ) : <EOL> option = argparse . Action ( <EOL> option_strings = [ '<STR_LIT>' , '<STR_LIT>' , '<STR_LIT>' ] , <EOL> dest = '<STR_LIT:b>' , <EOL> type = '<STR_LIT:int>' , <EOL> nargs = '<STR_LIT:+>' , <EOL> default = <NUM_LIT> , <EOL> choices = [ <NUM_LIT:1> , <NUM_LIT:2> , <NUM_LIT:3> ] , <EOL> help = '<STR_LIT>' , <EOL> metavar = '<STR_LIT>' ) <EOL> string = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" ) <EOL> self . assertStringEqual ( option , string ) <EOL> def test_argument ( self ) : <EOL> argument = argparse . Action ( <EOL> option_strings = [ ] , <EOL> dest = '<STR_LIT:x>' , <EOL> type = float , <EOL> nargs = '<STR_LIT:?>' , <EOL> default = <NUM_LIT> , <EOL> choices = [ <NUM_LIT:0.5> , <NUM_LIT> , <NUM_LIT> ] , <EOL> help = '<STR_LIT>' , <EOL> metavar = '<STR_LIT>' ) <EOL> string = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" % float ) <EOL> self . assertStringEqual ( argument , string ) <EOL> def test_namespace ( self ) : <EOL> ns = argparse . Namespace ( foo = <NUM_LIT> , bar = '<STR_LIT>' ) <EOL> string = "<STR_LIT>" <EOL> self . assertStringEqual ( ns , string ) <EOL> def test_parser ( self ) : <EOL> parser = argparse . ArgumentParser ( prog = '<STR_LIT>' ) <EOL> string = ( <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" <EOL> "<STR_LIT>" % argparse . HelpFormatter ) <EOL> self . assertStringEqual ( parser , string ) <EOL> class TestNamespace ( TestCase ) : <EOL> def test_constructor ( self ) : <EOL> ns = argparse . Namespace ( ) <EOL> self . assertRaises ( AttributeError , getattr , ns , '<STR_LIT:x>' ) <EOL> ns = argparse . Namespace ( a = <NUM_LIT> , b = '<STR_LIT>' ) <EOL> self . assertEqual ( ns . a , <NUM_LIT> ) <EOL> self . assertEqual ( ns . b , '<STR_LIT>' ) <EOL> def test_equality ( self ) : <EOL> ns1 = argparse . Namespace ( a = <NUM_LIT:1> , b = <NUM_LIT:2> ) <EOL> ns2 = argparse . Namespace ( b = <NUM_LIT:2> , a = <NUM_LIT:1> ) <EOL> ns3 = argparse . Namespace ( a = <NUM_LIT:1> ) <EOL> ns4 = argparse . Namespace ( b = <NUM_LIT:2> ) <EOL> self . assertEqual ( ns1 , ns2 ) <EOL> self . assertNotEqual ( ns1 , ns3 ) <EOL> self . assertNotEqual ( ns1 , ns4 ) <EOL> self . assertNotEqual ( ns2 , ns3 ) <EOL> self . assertNotEqual ( ns2 , ns4 ) <EOL> self . assertTrue ( ns1 != ns3 ) <EOL> self . assertTrue ( ns1 != ns4 ) <EOL> self . assertTrue ( ns2 != ns3 ) <EOL> self . assertTrue ( ns2 != ns4 ) <EOL> class TestEncoding ( TestCase ) : <EOL> def _test_module_encoding ( self , path ) : <EOL> path , _ = os . path . splitext ( path ) <EOL> path += "<STR_LIT>" <EOL> with codecs . open ( path , '<STR_LIT:r>' , '<STR_LIT:utf-8>' ) as f : <EOL> f . read ( ) <EOL> def test_argparse_module_encoding ( self ) : <EOL> self . _test_module_encoding ( argparse . __file__ ) <EOL> def test_test_argparse_module_encoding ( self ) : <EOL> self . _test_module_encoding ( __file__ ) <EOL> class TestArgumentError ( TestCase ) : <EOL> def test_argument_error ( self ) : <EOL> msg = "<STR_LIT>" <EOL> error = argparse . ArgumentError ( None , msg ) <EOL> self . assertEqual ( str ( error ) , msg ) <EOL> class TestArgumentTypeError ( TestCase ) : <EOL> def test_argument_type_error ( self ) : <EOL> def spam ( string ) : <EOL> raise argparse . ArgumentTypeError ( '<STR_LIT>' ) <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' , add_help = False ) <EOL> parser . add_argument ( '<STR_LIT:x>' , type = spam ) <EOL> try : <EOL> parser . parse_args ( [ '<STR_LIT>' ] ) <EOL> except ArgumentParserError : <EOL> expected = '<STR_LIT>' <EOL> msg = sys . exc_info ( ) [ <NUM_LIT:1> ] . stderr <EOL> self . assertEqual ( expected , msg ) <EOL> else : <EOL> self . fail ( ) <EOL> class TestMessageContentError ( TestCase ) : <EOL> def test_missing_argument_name_in_message ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' , usage = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , type = str ) <EOL> parser . add_argument ( '<STR_LIT>' , type = int , required = True ) <EOL> parser . add_argument ( '<STR_LIT>' , type = str , nargs = '<STR_LIT:+>' ) <EOL> with self . assertRaises ( ArgumentParserError ) as cm : <EOL> parser . parse_args ( [ ] ) <EOL> msg = str ( cm . exception ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> with self . assertRaises ( ArgumentParserError ) as cm : <EOL> parser . parse_args ( [ '<STR_LIT>' ] ) <EOL> msg = str ( cm . exception ) <EOL> self . assertNotIn ( msg , '<STR_LIT>' ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> with self . assertRaises ( ArgumentParserError ) as cm : <EOL> parser . parse_args ( [ '<STR_LIT>' , '<STR_LIT>' ] ) <EOL> msg = str ( cm . exception ) <EOL> self . assertNotIn ( msg , '<STR_LIT>' ) <EOL> self . assertNotIn ( msg , '<STR_LIT>' ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> def test_optional_optional_not_in_message ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' , usage = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , type = str ) <EOL> parser . add_argument ( '<STR_LIT>' , type = int , required = True ) <EOL> parser . add_argument ( '<STR_LIT>' , type = bool , nargs = '<STR_LIT:?>' , <EOL> default = True ) <EOL> with self . assertRaises ( ArgumentParserError ) as cm : <EOL> parser . parse_args ( [ ] ) <EOL> msg = str ( cm . exception ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> self . assertNotIn ( msg , '<STR_LIT>' ) <EOL> with self . assertRaises ( ArgumentParserError ) as cm : <EOL> parser . parse_args ( [ '<STR_LIT>' ] ) <EOL> msg = str ( cm . exception ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> self . assertNotIn ( msg , '<STR_LIT>' ) <EOL> self . assertNotIn ( msg , '<STR_LIT>' ) <EOL> def test_optional_positional_not_in_message ( self ) : <EOL> parser = ErrorRaisingArgumentParser ( prog = '<STR_LIT>' , usage = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , default = '<STR_LIT>' ) <EOL> with self . assertRaises ( ArgumentParserError ) as cm : <EOL> parser . parse_args ( [ ] ) <EOL> msg = str ( cm . exception ) <EOL> self . assertRegex ( msg , '<STR_LIT>' ) <EOL> self . assertNotIn ( msg , '<STR_LIT>' ) <EOL> class TestTypeFunctionCallOnlyOnce ( TestCase ) : <EOL> def test_type_function_call_only_once ( self ) : <EOL> def spam ( string_to_convert ) : <EOL> self . assertEqual ( string_to_convert , '<STR_LIT>' ) <EOL> return '<STR_LIT>' <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , type = spam , default = '<STR_LIT:bar>' ) <EOL> args = parser . parse_args ( '<STR_LIT>' . split ( ) ) <EOL> self . assertEqual ( NS ( foo = '<STR_LIT>' ) , args ) <EOL> class TestTypeFunctionCalledOnDefault ( TestCase ) : <EOL> def test_type_function_call_with_non_string_default ( self ) : <EOL> def spam ( int_to_convert ) : <EOL> self . assertEqual ( int_to_convert , <NUM_LIT:0> ) <EOL> return '<STR_LIT>' <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , type = spam , default = <NUM_LIT:0> ) <EOL> args = parser . parse_args ( [ ] ) <EOL> self . assertEqual ( NS ( foo = <NUM_LIT:0> ) , args ) <EOL> def test_type_function_call_with_string_default ( self ) : <EOL> def spam ( int_to_convert ) : <EOL> return '<STR_LIT>' <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , type = spam , default = '<STR_LIT:0>' ) <EOL> args = parser . parse_args ( [ ] ) <EOL> self . assertEqual ( NS ( foo = '<STR_LIT>' ) , args ) <EOL> def test_no_double_type_conversion_of_default ( self ) : <EOL> def extend ( str_to_convert ) : <EOL> return str_to_convert + '<STR_LIT:*>' <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , type = extend , default = '<STR_LIT:*>' ) <EOL> args = parser . parse_args ( [ ] ) <EOL> self . assertEqual ( NS ( test = '<STR_LIT>' ) , args ) <EOL> def test_issue_15906 ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , dest = '<STR_LIT:test>' , type = str , <EOL> default = [ ] , action = '<STR_LIT>' ) <EOL> args = parser . parse_args ( [ ] ) <EOL> self . assertEqual ( args . test , [ ] ) <EOL> class TestParseKnownArgs ( TestCase ) : <EOL> def test_arguments_tuple ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . parse_args ( ( ) ) <EOL> def test_arguments_list ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . parse_args ( [ ] ) <EOL> def test_arguments_tuple_positional ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT:x>' ) <EOL> parser . parse_args ( ( '<STR_LIT:x>' , ) ) <EOL> def test_arguments_list_positional ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT:x>' ) <EOL> parser . parse_args ( [ '<STR_LIT:x>' ] ) <EOL> def test_optionals ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> args , extras = parser . parse_known_args ( '<STR_LIT>' . split ( ) ) <EOL> self . assertEqual ( NS ( foo = '<STR_LIT:F>' ) , args ) <EOL> self . assertEqual ( [ '<STR_LIT>' , '<STR_LIT>' ] , extras ) <EOL> def test_mixed ( self ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( '<STR_LIT>' , nargs = '<STR_LIT:?>' , const = <NUM_LIT:1> , type = int ) <EOL> parser . add_argument ( '<STR_LIT>' , action = '<STR_LIT>' ) <EOL> parser . add_argument ( '<STR_LIT>' ) <EOL> argv = [ "<STR_LIT:B>" , "<STR_LIT:C>" , "<STR_LIT>" , "<STR_LIT>" , "<STR_LIT:3>" , "<STR_LIT:4>" ] <EOL> args , extras = parser . parse_known_args ( argv ) <EOL> self . assertEqual ( NS ( v = <NUM_LIT:3> , spam = True , badger = "<STR_LIT:B>" ) , args ) <EOL> self . assertEqual ( [ "<STR_LIT:C>" , "<STR_LIT>" , "<STR_LIT:4>" ] , extras ) <EOL> class TestAddArgumentMetavar ( TestCase ) : <EOL> EXPECTED_MESSAGE = "<STR_LIT>" <EOL> def do_test_no_exception ( self , nargs , metavar ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> parser . add_argument ( "<STR_LIT>" , nargs = nargs , metavar = metavar ) <EOL> def do_test_exception ( self , nargs , metavar ) : <EOL> parser = argparse . ArgumentParser ( ) <EOL> with self . assertRaises ( ValueError ) as cm : <EOL> parser . add_argument ( "<STR_LIT>" , nargs = nargs , metavar = metavar ) <EOL> self . assertEqual ( cm . exception . args [ <NUM_LIT:0> ] , self . EXPECTED_MESSAGE ) <EOL> def test_nargs_None_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = None , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_None_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = None , metavar = tuple ( ) ) <EOL> def test_nargs_None_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = None , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_None_metavar_length2 ( self ) : <EOL> self . do_test_exception ( nargs = None , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_None_metavar_length3 ( self ) : <EOL> self . do_test_exception ( nargs = None , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_optional_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:?>" , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_optional_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT:?>" , metavar = tuple ( ) ) <EOL> def test_nargs_optional_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:?>" , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_optional_metavar_length2 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT:?>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_optional_metavar_length3 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT:?>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_zeroormore_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:*>" , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_zeroormore_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT:*>" , metavar = tuple ( ) ) <EOL> def test_nargs_zeroormore_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:*>" , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_zeroormore_metavar_length2 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:*>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_zeroormore_metavar_length3 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT:*>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_oneormore_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:+>" , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_oneormore_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT:+>" , metavar = tuple ( ) ) <EOL> def test_nargs_oneormore_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:+>" , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_oneormore_metavar_length2 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT:+>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_oneormore_metavar_length3 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT:+>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_remainder_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT>" , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_remainder_metavar_length0 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT>" , metavar = tuple ( ) ) <EOL> def test_nargs_remainder_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT>" , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_remainder_metavar_length2 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_remainder_metavar_length3 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_parser_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT>" , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_parser_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT>" , metavar = tuple ( ) ) <EOL> def test_nargs_parser_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = "<STR_LIT>" , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_parser_metavar_length2 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_parser_metavar_length3 ( self ) : <EOL> self . do_test_exception ( nargs = "<STR_LIT>" , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_1_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:1> , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_1_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = <NUM_LIT:1> , metavar = tuple ( ) ) <EOL> def test_nargs_1_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:1> , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_1_metavar_length2 ( self ) : <EOL> self . do_test_exception ( nargs = <NUM_LIT:1> , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_1_metavar_length3 ( self ) : <EOL> self . do_test_exception ( nargs = <NUM_LIT:1> , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_2_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:2> , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_2_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = <NUM_LIT:2> , metavar = tuple ( ) ) <EOL> def test_nargs_2_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:2> , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_2_metavar_length2 ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:2> , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_2_metavar_length3 ( self ) : <EOL> self . do_test_exception ( nargs = <NUM_LIT:2> , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> def test_nargs_3_metavar_string ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:3> , metavar = "<STR_LIT:1>" ) <EOL> def test_nargs_3_metavar_length0 ( self ) : <EOL> self . do_test_exception ( nargs = <NUM_LIT:3> , metavar = tuple ( ) ) <EOL> def test_nargs_3_metavar_length1 ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:3> , metavar = ( "<STR_LIT:1>" ) ) <EOL> def test_nargs_3_metavar_length2 ( self ) : <EOL> self . do_test_exception ( nargs = <NUM_LIT:3> , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" ) ) <EOL> def test_nargs_3_metavar_length3 ( self ) : <EOL> self . do_test_no_exception ( nargs = <NUM_LIT:3> , metavar = ( "<STR_LIT:1>" , "<STR_LIT:2>" , "<STR_LIT:3>" ) ) <EOL> class TestImportStar ( TestCase ) : <EOL> def test ( self ) : <EOL> for name in argparse . __all__ : <EOL> self . assertTrue ( hasattr ( argparse , name ) ) <EOL> def test_all_exports_everything_but_modules ( self ) : <EOL> items = [ <EOL> name <EOL> for name , value in vars ( argparse ) . items ( ) <EOL> if not ( name . startswith ( "<STR_LIT:_>" ) or name == '<STR_LIT>' ) <EOL> if not inspect . ismodule ( value ) <EOL> ] <EOL> self . assertEqual ( sorted ( items ) , sorted ( argparse . __all__ ) ) <EOL> def test_main ( ) : <EOL> support . run_unittest ( __name__ ) <EOL> RFile . seen = { } <EOL> WFile . seen = set ( ) <EOL> if __name__ == '<STR_LIT:__main__>' : <EOL> test_main ( ) </s>
