Merged revisions 78586-78593 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r78586 | benjamin.peterson | 2010-03-02 16:03:03 -0600 (Tue, 02 Mar 2010) | 1 line

  remove coding cookie as mandated by PEP 8
........
  r78587 | benjamin.peterson | 2010-03-02 16:05:59 -0600 (Tue, 02 Mar 2010) | 1 line

  set svn:eol-style
........
  r78588 | benjamin.peterson | 2010-03-02 16:08:40 -0600 (Tue, 02 Mar 2010) | 1 line

  remove another coding cookie
........
  r78589 | georg.brandl | 2010-03-02 16:17:38 -0600 (Tue, 02 Mar 2010) | 1 line

  Add some x-refs.
........
  r78590 | benjamin.peterson | 2010-03-02 16:20:10 -0600 (Tue, 02 Mar 2010) | 1 line

  enable running of argparse tests and fix two that failed in the new environment
........
  r78591 | benjamin.peterson | 2010-03-02 16:23:33 -0600 (Tue, 02 Mar 2010) | 1 line

  prevent warning filter adjustment from altering other tests
........
  r78592 | benjamin.peterson | 2010-03-02 16:24:30 -0600 (Tue, 02 Mar 2010) | 1 line

  use test_main() in __main__ section
........
  r78593 | benjamin.peterson | 2010-03-02 16:26:25 -0600 (Tue, 02 Mar 2010) | 1 line

  convert deprecated fail* methods to assert* variants
........

1 files changed, 4210 insertions, 4206 deletions

diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index 61f8e46..849facb 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -1,4206 +1,4210 @@
-# -*- coding: utf-8 -*-

-

-# Copyright © 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.

-#

-# Licensed under the Apache License, Version 2.0 (the "License"); you may not

-# use this file except in compliance with the License. You may obtain a copy

-# of the License at

-#

-#     http://www.apache.org/licenses/LICENSE-2.0

-#

-# Unless required by applicable law or agreed to in writing, software

-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

-# License for the specific language governing permissions and limitations

-# under the License.

-

-import codecs

-import os

-import shutil

-import sys

-import textwrap

-import tempfile

-import unittest

-import argparse

-

-try:

-    from StringIO import StringIO

-except ImportError:

-    from io import StringIO

-

-try:

-    set

-except NameError:

-    from sets import Set as set

-

-try:

-    sorted

-except NameError:

-

-    def sorted(iterable, reverse=False):

-        result = list(iterable)

-        result.sort()

-        if reverse:

-            result.reverse()

-        return result

-

-# silence Python 2.6 buggy warnings about Exception.message

-if sys.version_info[:2] == (2, 6):

-    import warnings

-    warnings.filterwarnings(

-        action='ignore',

-        message='BaseException.message has been deprecated as of Python 2.6',

-        category=DeprecationWarning)

-

-# silence warnings about version argument - these are expected

-import warnings

-warnings.filterwarnings(

-    action='ignore',

-    message='The "version" argument to ArgumentParser is deprecated.',

-    category=DeprecationWarning)

-warnings.filterwarnings(

-    action='ignore',

-    message='The format_version method is deprecated',

-    category=DeprecationWarning)

-warnings.filterwarnings(

-    action='ignore',

-    message='The print_version method is deprecated',

-    category=DeprecationWarning)

-

-

-class TestCase(unittest.TestCase):

-

-    def assertEqual(self, obj1, obj2):

-        if obj1 != obj2:

-            print('')

-            print(repr(obj1))

-            print(repr(obj2))

-            print(obj1)

-            print(obj2)

-        super(TestCase, self).assertEqual(obj1, obj2)

-

-

-class TempDirMixin(object):

-

-    def setUp(self):

-        self.temp_dir = tempfile.mkdtemp()

-        self.old_dir = os.getcwd()

-        os.chdir(self.temp_dir)

-

-    def tearDown(self):

-        os.chdir(self.old_dir)

-        while True:

-            try:

-                shutil.rmtree(self.temp_dir)

-            except WindowsError:

-                continue

-            else:

-                break

-

-

-class Sig(object):

-

-    def __init__(self, *args, **kwargs):

-        self.args = args

-        self.kwargs = kwargs

-

-

-class NS(object):

-

-    def __init__(self, **kwargs):

-        self.__dict__.update(kwargs)

-

-    def __repr__(self):

-        sorted_items = sorted(self.__dict__.items())

-        kwarg_str = ', '.join(['%s=%r' % tup for tup in sorted_items])

-        return '%s(%s)' % (type(self).__name__, kwarg_str)

-

-    def __eq__(self, other):

-        return vars(self) == vars(other)

-

-    def __ne__(self, other):

-        return not (self == other)

-

-

-class ArgumentParserError(Exception):

-

-    def __init__(self, message, stdout=None, stderr=None, error_code=None):

-        Exception.__init__(self, message, stdout, stderr)

-        self.message = message

-        self.stdout = stdout

-        self.stderr = stderr

-        self.error_code = error_code

-

-

-def stderr_to_parser_error(parse_args, *args, **kwargs):

-    # if this is being called recursively and stderr or stdout is already being

-    # redirected, simply call the function and let the enclosing function

-    # catch the exception

-    if isinstance(sys.stderr, StringIO) or isinstance(sys.stdout, StringIO):

-        return parse_args(*args, **kwargs)

-

-    # if this is not being called recursively, redirect stderr and

-    # use it as the ArgumentParserError message

-    old_stdout = sys.stdout

-    old_stderr = sys.stderr

-    sys.stdout = StringIO()

-    sys.stderr = StringIO()

-    try:

-        try:

-            result = parse_args(*args, **kwargs)

-            for key in list(vars(result)):

-                if getattr(result, key) is sys.stdout:

-                    setattr(result, key, old_stdout)

-                if getattr(result, key) is sys.stderr:

-                    setattr(result, key, old_stderr)

-            return result

-        except SystemExit:

-            code = sys.exc_info()[1].code

-            stdout = sys.stdout.getvalue()

-            stderr = sys.stderr.getvalue()

-            raise ArgumentParserError("SystemExit", stdout, stderr, code)

-    finally:

-        sys.stdout = old_stdout

-        sys.stderr = old_stderr

-

-

-class ErrorRaisingArgumentParser(argparse.ArgumentParser):

-

-    def parse_args(self, *args, **kwargs):

-        parse_args = super(ErrorRaisingArgumentParser, self).parse_args

-        return stderr_to_parser_error(parse_args, *args, **kwargs)

-

-    def exit(self, *args, **kwargs):

-        exit = super(ErrorRaisingArgumentParser, self).exit

-        return stderr_to_parser_error(exit, *args, **kwargs)

-

-    def error(self, *args, **kwargs):

-        error = super(ErrorRaisingArgumentParser, self).error

-        return stderr_to_parser_error(error, *args, **kwargs)

-

-

-class ParserTesterMetaclass(type):

-    """Adds parser tests using the class attributes.

-

-    Classes of this type should specify the following attributes:

-

-    argument_signatures -- a list of Sig objects which specify

-        the signatures of Argument objects to be created

-    failures -- a list of args lists that should cause the parser

-        to fail

-    successes -- a list of (initial_args, options, remaining_args) tuples

-        where initial_args specifies the string args to be parsed,

-        options is a dict that should match the vars() of the options

-        parsed out of initial_args, and remaining_args should be any

-        remaining unparsed arguments

-    """

-

-    def __init__(cls, name, bases, bodydict):

-        if name == 'ParserTestCase':

-            return

-

-        # default parser signature is empty

-        if not hasattr(cls, 'parser_signature'):

-            cls.parser_signature = Sig()

-        if not hasattr(cls, 'parser_class'):

-            cls.parser_class = ErrorRaisingArgumentParser

-

-        # ---------------------------------------

-        # functions for adding optional arguments

-        # ---------------------------------------

-        def no_groups(parser, argument_signatures):

-            """Add all arguments directly to the parser"""

-            for sig in argument_signatures:

-                parser.add_argument(*sig.args, **sig.kwargs)

-

-        def one_group(parser, argument_signatures):

-            """Add all arguments under a single group in the parser"""

-            group = parser.add_argument_group('foo')

-            for sig in argument_signatures:

-                group.add_argument(*sig.args, **sig.kwargs)

-

-        def many_groups(parser, argument_signatures):

-            """Add each argument in its own group to the parser"""

-            for i, sig in enumerate(argument_signatures):

-                group = parser.add_argument_group('foo:%i' % i)

-                group.add_argument(*sig.args, **sig.kwargs)

-

-        # --------------------------

-        # functions for parsing args

-        # --------------------------

-        def listargs(parser, args):

-            """Parse the args by passing in a list"""

-            return parser.parse_args(args)

-

-        def sysargs(parser, args):

-            """Parse the args by defaulting to sys.argv"""

-            old_sys_argv = sys.argv

-            sys.argv = [old_sys_argv[0]] + args

-            try:

-                return parser.parse_args()

-            finally:

-                sys.argv = old_sys_argv

-

-        # class that holds the combination of one optional argument

-        # addition method and one arg parsing method

-        class AddTests(object):

-

-            def __init__(self, tester_cls, add_arguments, parse_args):

-                self._add_arguments = add_arguments

-                self._parse_args = parse_args

-

-                add_arguments_name = self._add_arguments.__name__

-                parse_args_name = self._parse_args.__name__

-                for test_func in [self.test_failures, self.test_successes]:

-                    func_name = test_func.__name__

-                    names = func_name, add_arguments_name, parse_args_name

-                    test_name = '_'.join(names)

-

-                    def wrapper(self, test_func=test_func):

-                        test_func(self)

-                    try:

-                        wrapper.__name__ = test_name

-                    except TypeError:

-                        pass

-                    setattr(tester_cls, test_name, wrapper)

-

-            def _get_parser(self, tester):

-                args = tester.parser_signature.args

-                kwargs = tester.parser_signature.kwargs

-                parser = tester.parser_class(*args, **kwargs)

-                self._add_arguments(parser, tester.argument_signatures)

-                return parser

-

-            def test_failures(self, tester):

-                parser = self._get_parser(tester)

-                for args_str in tester.failures:

-                    args = args_str.split()

-                    raises = tester.assertRaises

-                    raises(ArgumentParserError, parser.parse_args, args)

-

-            def test_successes(self, tester):

-                parser = self._get_parser(tester)

-                for args, expected_ns in tester.successes:

-                    if isinstance(args, str):

-                        args = args.split()

-                    result_ns = self._parse_args(parser, args)

-                    tester.assertEqual(expected_ns, result_ns)

-

-        # add tests for each combination of an optionals adding method

-        # and an arg parsing method

-        for add_arguments in [no_groups, one_group, many_groups]:

-            for parse_args in [listargs, sysargs]:

-                AddTests(cls, add_arguments, parse_args)

-

-bases = TestCase,

-ParserTestCase = ParserTesterMetaclass('ParserTestCase', bases, {})

-

-# ===============

-# Optionals tests

-# ===============

-

-class TestOptionalsSingleDash(ParserTestCase):

-    """Test an Optional with a single-dash option string"""

-

-    argument_signatures = [Sig('-x')]

-    failures = ['-x', 'a', '--foo', '-x --foo', '-x -y']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a', NS(x='a')),

-        ('-xa', NS(x='a')),

-        ('-x -1', NS(x='-1')),

-        ('-x-1', NS(x='-1')),

-    ]

-

-

-class TestOptionalsSingleDashCombined(ParserTestCase):

-    """Test an Optional with a single-dash option string"""

-

-    argument_signatures = [

-        Sig('-x', action='store_true'),

-        Sig('-yyy', action='store_const', const=42),

-        Sig('-z'),

-    ]

-    failures = ['a', '--foo', '-xa', '-x --foo', '-x -z', '-z -x',

-                '-yx', '-yz a', '-yyyx', '-yyyza', '-xyza']

-    successes = [

-        ('', NS(x=False, yyy=None, z=None)),

-        ('-x', NS(x=True, yyy=None, z=None)),

-        ('-za', NS(x=False, yyy=None, z='a')),

-        ('-z a', NS(x=False, yyy=None, z='a')),

-        ('-xza', NS(x=True, yyy=None, z='a')),

-        ('-xz a', NS(x=True, yyy=None, z='a')),

-        ('-x -za', NS(x=True, yyy=None, z='a')),

-        ('-x -z a', NS(x=True, yyy=None, z='a')),

-        ('-y', NS(x=False, yyy=42, z=None)),

-        ('-yyy', NS(x=False, yyy=42, z=None)),

-        ('-x -yyy -za', NS(x=True, yyy=42, z='a')),

-        ('-x -yyy -z a', NS(x=True, yyy=42, z='a')),

-    ]

-

-

-class TestOptionalsSingleDashLong(ParserTestCase):

-    """Test an Optional with a multi-character single-dash option string"""

-

-    argument_signatures = [Sig('-foo')]

-    failures = ['-foo', 'a', '--foo', '-foo --foo', '-foo -y', '-fooa']

-    successes = [

-        ('', NS(foo=None)),

-        ('-foo a', NS(foo='a')),

-        ('-foo -1', NS(foo='-1')),

-        ('-fo a', NS(foo='a')),

-        ('-f a', NS(foo='a')),

-    ]

-

-

-class TestOptionalsSingleDashSubsetAmbiguous(ParserTestCase):

-    """Test Optionals where option strings are subsets of each other"""

-

-    argument_signatures = [Sig('-f'), Sig('-foobar'), Sig('-foorab')]

-    failures = ['-f', '-foo', '-fo', '-foo b', '-foob', '-fooba', '-foora']

-    successes = [

-        ('', NS(f=None, foobar=None, foorab=None)),

-        ('-f a', NS(f='a', foobar=None, foorab=None)),

-        ('-fa', NS(f='a', foobar=None, foorab=None)),

-        ('-foa', NS(f='oa', foobar=None, foorab=None)),

-        ('-fooa', NS(f='ooa', foobar=None, foorab=None)),

-        ('-foobar a', NS(f=None, foobar='a', foorab=None)),

-        ('-foorab a', NS(f=None, foobar=None, foorab='a')),

-    ]

-

-

-class TestOptionalsSingleDashAmbiguous(ParserTestCase):

-    """Test Optionals that partially match but are not subsets"""

-

-    argument_signatures = [Sig('-foobar'), Sig('-foorab')]

-    failures = ['-f', '-f a', '-fa', '-foa', '-foo', '-fo', '-foo b']

-    successes = [

-        ('', NS(foobar=None, foorab=None)),

-        ('-foob a', NS(foobar='a', foorab=None)),

-        ('-foor a', NS(foobar=None, foorab='a')),

-        ('-fooba a', NS(foobar='a', foorab=None)),

-        ('-foora a', NS(foobar=None, foorab='a')),

-        ('-foobar a', NS(foobar='a', foorab=None)),

-        ('-foorab a', NS(foobar=None, foorab='a')),

-    ]

-

-

-class TestOptionalsNumeric(ParserTestCase):

-    """Test an Optional with a short opt string"""

-

-    argument_signatures = [Sig('-1', dest='one')]

-    failures = ['-1', 'a', '-1 --foo', '-1 -y', '-1 -1', '-1 -2']

-    successes = [

-        ('', NS(one=None)),

-        ('-1 a', NS(one='a')),

-        ('-1a', NS(one='a')),

-        ('-1-2', NS(one='-2')),

-    ]

-

-

-class TestOptionalsDoubleDash(ParserTestCase):

-    """Test an Optional with a double-dash option string"""

-

-    argument_signatures = [Sig('--foo')]

-    failures = ['--foo', '-f', '-f a', 'a', '--foo -x', '--foo --bar']

-    successes = [

-        ('', NS(foo=None)),

-        ('--foo a', NS(foo='a')),

-        ('--foo=a', NS(foo='a')),

-        ('--foo -2.5', NS(foo='-2.5')),

-        ('--foo=-2.5', NS(foo='-2.5')),

-    ]

-

-

-class TestOptionalsDoubleDashPartialMatch(ParserTestCase):

-    """Tests partial matching with a double-dash option string"""

-

-    argument_signatures = [

-        Sig('--badger', action='store_true'),

-        Sig('--bat'),

-    ]

-    failures = ['--bar', '--b', '--ba', '--b=2', '--ba=4', '--badge 5']

-    successes = [

-        ('', NS(badger=False, bat=None)),

-        ('--bat X', NS(badger=False, bat='X')),

-        ('--bad', NS(badger=True, bat=None)),

-        ('--badg', NS(badger=True, bat=None)),

-        ('--badge', NS(badger=True, bat=None)),

-        ('--badger', NS(badger=True, bat=None)),

-    ]

-

-

-class TestOptionalsDoubleDashPrefixMatch(ParserTestCase):

-    """Tests when one double-dash option string is a prefix of another"""

-

-    argument_signatures = [

-        Sig('--badger', action='store_true'),

-        Sig('--ba'),

-    ]

-    failures = ['--bar', '--b', '--ba', '--b=2', '--badge 5']

-    successes = [

-        ('', NS(badger=False, ba=None)),

-        ('--ba X', NS(badger=False, ba='X')),

-        ('--ba=X', NS(badger=False, ba='X')),

-        ('--bad', NS(badger=True, ba=None)),

-        ('--badg', NS(badger=True, ba=None)),

-        ('--badge', NS(badger=True, ba=None)),

-        ('--badger', NS(badger=True, ba=None)),

-    ]

-

-

-class TestOptionalsSingleDoubleDash(ParserTestCase):

-    """Test an Optional with single- and double-dash option strings"""

-

-    argument_signatures = [

-        Sig('-f', action='store_true'),

-        Sig('--bar'),

-        Sig('-baz', action='store_const', const=42),

-    ]

-    failures = ['--bar', '-fbar', '-fbaz', '-bazf', '-b B', 'B']

-    successes = [

-        ('', NS(f=False, bar=None, baz=None)),

-        ('-f', NS(f=True, bar=None, baz=None)),

-        ('--ba B', NS(f=False, bar='B', baz=None)),

-        ('-f --bar B', NS(f=True, bar='B', baz=None)),

-        ('-f -b', NS(f=True, bar=None, baz=42)),

-        ('-ba -f', NS(f=True, bar=None, baz=42)),

-    ]

-

-

-class TestOptionalsAlternatePrefixChars(ParserTestCase):

-    """Test an Optional with a double-dash option string"""

-

-    parser_signature = Sig(prefix_chars='+:/', add_help=False)

-    argument_signatures = [

-        Sig('+f', action='store_true'),

-        Sig('::bar'),

-        Sig('/baz', action='store_const', const=42),

-    ]

-    failures = ['--bar', '-fbar', '-b B', 'B', '-f', '--bar B', '-baz']

-    successes = [

-        ('', NS(f=False, bar=None, baz=None)),

-        ('+f', NS(f=True, bar=None, baz=None)),

-        ('::ba B', NS(f=False, bar='B', baz=None)),

-        ('+f ::bar B', NS(f=True, bar='B', baz=None)),

-        ('+f /b', NS(f=True, bar=None, baz=42)),

-        ('/ba +f', NS(f=True, bar=None, baz=42)),

-    ]

-

-

-class TestOptionalsShortLong(ParserTestCase):

-    """Test a combination of single- and double-dash option strings"""

-

-    argument_signatures = [

-        Sig('-v', '--verbose', '-n', '--noisy', action='store_true'),

-    ]

-    failures = ['--x --verbose', '-N', 'a', '-v x']

-    successes = [

-        ('', NS(verbose=False)),

-        ('-v', NS(verbose=True)),

-        ('--verbose', NS(verbose=True)),

-        ('-n', NS(verbose=True)),

-        ('--noisy', NS(verbose=True)),

-    ]

-

-

-class TestOptionalsDest(ParserTestCase):

-    """Tests various means of setting destination"""

-

-    argument_signatures = [Sig('--foo-bar'), Sig('--baz', dest='zabbaz')]

-    failures = ['a']

-    successes = [

-        ('--foo-bar f', NS(foo_bar='f', zabbaz=None)),

-        ('--baz g', NS(foo_bar=None, zabbaz='g')),

-        ('--foo-bar h --baz i', NS(foo_bar='h', zabbaz='i')),

-        ('--baz j --foo-bar k', NS(foo_bar='k', zabbaz='j')),

-    ]

-

-

-class TestOptionalsDefault(ParserTestCase):

-    """Tests specifying a default for an Optional"""

-

-    argument_signatures = [Sig('-x'), Sig('-y', default=42)]

-    failures = ['a']

-    successes = [

-        ('', NS(x=None, y=42)),

-        ('-xx', NS(x='x', y=42)),

-        ('-yy', NS(x=None, y='y')),

-    ]

-

-

-class TestOptionalsNargsDefault(ParserTestCase):

-    """Tests not specifying the number of args for an Optional"""

-

-    argument_signatures = [Sig('-x')]

-    failures = ['a', '-x']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a', NS(x='a')),

-    ]

-

-

-class TestOptionalsNargs1(ParserTestCase):

-    """Tests specifying the 1 arg for an Optional"""

-

-    argument_signatures = [Sig('-x', nargs=1)]

-    failures = ['a', '-x']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a', NS(x=['a'])),

-    ]

-

-

-class TestOptionalsNargs3(ParserTestCase):

-    """Tests specifying the 3 args for an Optional"""

-

-    argument_signatures = [Sig('-x', nargs=3)]

-    failures = ['a', '-x', '-x a', '-x a b', 'a -x', 'a -x b']

-    successes = [

-        ('', NS(x=None)),

-        ('-x a b c', NS(x=['a', 'b', 'c'])),

-    ]

-

-

-class TestOptionalsNargsOptional(ParserTestCase):

-    """Tests specifying an Optional arg for an Optional"""

-

-    argument_signatures = [

-        Sig('-w', nargs='?'),

-        Sig('-x', nargs='?', const=42),

-        Sig('-y', nargs='?', default='spam'),

-        Sig('-z', nargs='?', type=int, const='42', default='84'),

-    ]

-    failures = ['2']

-    successes = [

-        ('', NS(w=None, x=None, y='spam', z=84)),

-        ('-w', NS(w=None, x=None, y='spam', z=84)),

-        ('-w 2', NS(w='2', x=None, y='spam', z=84)),

-        ('-x', NS(w=None, x=42, y='spam', z=84)),

-        ('-x 2', NS(w=None, x='2', y='spam', z=84)),

-        ('-y', NS(w=None, x=None, y=None, z=84)),

-        ('-y 2', NS(w=None, x=None, y='2', z=84)),

-        ('-z', NS(w=None, x=None, y='spam', z=42)),

-        ('-z 2', NS(w=None, x=None, y='spam', z=2)),

-    ]

-

-

-class TestOptionalsNargsZeroOrMore(ParserTestCase):

-    """Tests specifying an args for an Optional that accepts zero or more"""

-

-    argument_signatures = [

-        Sig('-x', nargs='*'),

-        Sig('-y', nargs='*', default='spam'),

-    ]

-    failures = ['a']

-    successes = [

-        ('', NS(x=None, y='spam')),

-        ('-x', NS(x=[], y='spam')),

-        ('-x a', NS(x=['a'], y='spam')),

-        ('-x a b', NS(x=['a', 'b'], y='spam')),

-        ('-y', NS(x=None, y=[])),

-        ('-y a', NS(x=None, y=['a'])),

-        ('-y a b', NS(x=None, y=['a', 'b'])),

-    ]

-

-

-class TestOptionalsNargsOneOrMore(ParserTestCase):

-    """Tests specifying an args for an Optional that accepts one or more"""

-

-    argument_signatures = [

-        Sig('-x', nargs='+'),

-        Sig('-y', nargs='+', default='spam'),

-    ]

-    failures = ['a', '-x', '-y', 'a -x', 'a -y b']

-    successes = [

-        ('', NS(x=None, y='spam')),

-        ('-x a', NS(x=['a'], y='spam')),

-        ('-x a b', NS(x=['a', 'b'], y='spam')),

-        ('-y a', NS(x=None, y=['a'])),

-        ('-y a b', NS(x=None, y=['a', 'b'])),

-    ]

-

-

-class TestOptionalsChoices(ParserTestCase):

-    """Tests specifying the choices for an Optional"""

-

-    argument_signatures = [

-        Sig('-f', choices='abc'),

-        Sig('-g', type=int, choices=range(5))]

-    failures = ['a', '-f d', '-fad', '-ga', '-g 6']

-    successes = [

-        ('', NS(f=None, g=None)),

-        ('-f a', NS(f='a', g=None)),

-        ('-f c', NS(f='c', g=None)),

-        ('-g 0', NS(f=None, g=0)),

-        ('-g 03', NS(f=None, g=3)),

-        ('-fb -g4', NS(f='b', g=4)),

-    ]

-

-

-class TestOptionalsRequired(ParserTestCase):

-    """Tests the an optional action that is required"""

-

-    argument_signatures = [

-        Sig('-x', type=int, required=True),

-    ]

-    failures = ['a', '']

-    successes = [

-        ('-x 1', NS(x=1)),

-        ('-x42', NS(x=42)),

-    ]

-

-

-class TestOptionalsActionStore(ParserTestCase):

-    """Tests the store action for an Optional"""

-

-    argument_signatures = [Sig('-x', action='store')]

-    failures = ['a', 'a -x']

-    successes = [

-        ('', NS(x=None)),

-        ('-xfoo', NS(x='foo')),

-    ]

-

-

-class TestOptionalsActionStoreConst(ParserTestCase):

-    """Tests the store_const action for an Optional"""

-

-    argument_signatures = [Sig('-y', action='store_const', const=object)]

-    failures = ['a']

-    successes = [

-        ('', NS(y=None)),

-        ('-y', NS(y=object)),

-    ]

-

-

-class TestOptionalsActionStoreFalse(ParserTestCase):

-    """Tests the store_false action for an Optional"""

-

-    argument_signatures = [Sig('-z', action='store_false')]

-    failures = ['a', '-za', '-z a']

-    successes = [

-        ('', NS(z=True)),

-        ('-z', NS(z=False)),

-    ]

-

-

-class TestOptionalsActionStoreTrue(ParserTestCase):

-    """Tests the store_true action for an Optional"""

-

-    argument_signatures = [Sig('--apple', action='store_true')]

-    failures = ['a', '--apple=b', '--apple b']

-    successes = [

-        ('', NS(apple=False)),

-        ('--apple', NS(apple=True)),

-    ]

-

-

-class TestOptionalsActionAppend(ParserTestCase):

-    """Tests the append action for an Optional"""

-

-    argument_signatures = [Sig('--baz', action='append')]

-    failures = ['a', '--baz', 'a --baz', '--baz a b']

-    successes = [

-        ('', NS(baz=None)),

-        ('--baz a', NS(baz=['a'])),

-        ('--baz a --baz b', NS(baz=['a', 'b'])),

-    ]

-

-

-class TestOptionalsActionAppendWithDefault(ParserTestCase):

-    """Tests the append action for an Optional"""

-

-    argument_signatures = [Sig('--baz', action='append', default=['X'])]

-    failures = ['a', '--baz', 'a --baz', '--baz a b']

-    successes = [

-        ('', NS(baz=['X'])),

-        ('--baz a', NS(baz=['X', 'a'])),

-        ('--baz a --baz b', NS(baz=['X', 'a', 'b'])),

-    ]

-

-

-class TestOptionalsActionAppendConst(ParserTestCase):

-    """Tests the append_const action for an Optional"""

-

-    argument_signatures = [

-        Sig('-b', action='append_const', const=Exception),

-        Sig('-c', action='append', dest='b'),

-    ]

-    failures = ['a', '-c', 'a -c', '-bx', '-b x']

-    successes = [

-        ('', NS(b=None)),

-        ('-b', NS(b=[Exception])),

-        ('-b -cx -b -cyz', NS(b=[Exception, 'x', Exception, 'yz'])),

-    ]

-

-

-class TestOptionalsActionAppendConstWithDefault(ParserTestCase):

-    """Tests the append_const action for an Optional"""

-

-    argument_signatures = [

-        Sig('-b', action='append_const', const=Exception, default=['X']),

-        Sig('-c', action='append', dest='b'),

-    ]

-    failures = ['a', '-c', 'a -c', '-bx', '-b x']

-    successes = [

-        ('', NS(b=['X'])),

-        ('-b', NS(b=['X', Exception])),

-        ('-b -cx -b -cyz', NS(b=['X', Exception, 'x', Exception, 'yz'])),

-    ]

-

-

-class TestOptionalsActionCount(ParserTestCase):

-    """Tests the count action for an Optional"""

-

-    argument_signatures = [Sig('-x', action='count')]

-    failures = ['a', '-x a', '-x b', '-x a -x b']

-    successes = [

-        ('', NS(x=None)),

-        ('-x', NS(x=1)),

-    ]

-

-

-# ================

-# Positional tests

-# ================

-

-class TestPositionalsNargsNone(ParserTestCase):

-    """Test a Positional that doesn't specify nargs"""

-

-    argument_signatures = [Sig('foo')]

-    failures = ['', '-x', 'a b']

-    successes = [

-        ('a', NS(foo='a')),

-    ]

-

-

-class TestPositionalsNargs1(ParserTestCase):

-    """Test a Positional that specifies an nargs of 1"""

-

-    argument_signatures = [Sig('foo', nargs=1)]

-    failures = ['', '-x', 'a b']

-    successes = [

-        ('a', NS(foo=['a'])),

-    ]

-

-

-class TestPositionalsNargs2(ParserTestCase):

-    """Test a Positional that specifies an nargs of 2"""

-

-    argument_signatures = [Sig('foo', nargs=2)]

-    failures = ['', 'a', '-x', 'a b c']

-    successes = [

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsZeroOrMore(ParserTestCase):

-    """Test a Positional that specifies unlimited nargs"""

-

-    argument_signatures = [Sig('foo', nargs='*')]

-    failures = ['-x']

-    successes = [

-        ('', NS(foo=[])),

-        ('a', NS(foo=['a'])),

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase):

-    """Test a Positional that specifies unlimited nargs and a default"""

-

-    argument_signatures = [Sig('foo', nargs='*', default='bar')]

-    failures = ['-x']

-    successes = [

-        ('', NS(foo='bar')),

-        ('a', NS(foo=['a'])),

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsOneOrMore(ParserTestCase):

-    """Test a Positional that specifies one or more nargs"""

-

-    argument_signatures = [Sig('foo', nargs='+')]

-    failures = ['', '-x']

-    successes = [

-        ('a', NS(foo=['a'])),

-        ('a b', NS(foo=['a', 'b'])),

-    ]

-

-

-class TestPositionalsNargsOptional(ParserTestCase):

-    """Tests an Optional Positional"""

-

-    argument_signatures = [Sig('foo', nargs='?')]

-    failures = ['-x', 'a b']

-    successes = [

-        ('', NS(foo=None)),

-        ('a', NS(foo='a')),

-    ]

-

-

-class TestPositionalsNargsOptionalDefault(ParserTestCase):

-    """Tests an Optional Positional with a default value"""

-

-    argument_signatures = [Sig('foo', nargs='?', default=42)]

-    failures = ['-x', 'a b']

-    successes = [

-        ('', NS(foo=42)),

-        ('a', NS(foo='a')),

-    ]

-

-

-class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase):

-    """Tests an Optional Positional with a default value

-    that needs to be converted to the appropriate type.

-    """

-

-    argument_signatures = [

-        Sig('foo', nargs='?', type=int, default='42'),

-    ]

-    failures = ['-x', 'a b', '1 2']

-    successes = [

-        ('', NS(foo=42)),

-        ('1', NS(foo=1)),

-    ]

-

-

-class TestPositionalsNargsNoneNone(ParserTestCase):

-    """Test two Positionals that don't specify nargs"""

-

-    argument_signatures = [Sig('foo'), Sig('bar')]

-    failures = ['', '-x', 'a', 'a b c']

-    successes = [

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargsNone1(ParserTestCase):

-    """Test a Positional with no nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', 'a', 'a b c']

-    successes = [

-        ('a b', NS(foo='a', bar=['b'])),

-    ]

-

-

-class TestPositionalsNargs2None(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar')]

-    failures = ['', '--foo', 'a', 'a b', 'a b c d']

-    successes = [

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsNoneZeroOrMore(ParserTestCase):

-    """Test a Positional with no nargs followed by one with unlimited"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs='*')]

-    failures = ['', '--foo']

-    successes = [

-        ('a', NS(foo='a', bar=[])),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsNargsNoneOneOrMore(ParserTestCase):

-    """Test a Positional with no nargs followed by one with one or more"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs='+')]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsNargsNoneOptional(ParserTestCase):

-    """Test a Positional with no nargs followed by one with an Optional"""

-

-    argument_signatures = [Sig('foo'), Sig('bar', nargs='?')]

-    failures = ['', '--foo', 'a b c']

-    successes = [

-        ('a', NS(foo='a', bar=None)),

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargsZeroOrMoreNone(ParserTestCase):

-    """Test a Positional with unlimited nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs='*'), Sig('bar')]

-    failures = ['', '--foo']

-    successes = [

-        ('a', NS(foo=[], bar='a')),

-        ('a b', NS(foo=['a'], bar='b')),

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsOneOrMoreNone(ParserTestCase):

-    """Test a Positional with one or more nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs='+'), Sig('bar')]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo=['a'], bar='b')),

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsOptionalNone(ParserTestCase):

-    """Test a Positional with an Optional nargs followed by one with none"""

-

-    argument_signatures = [Sig('foo', nargs='?', default=42), Sig('bar')]

-    failures = ['', '--foo', 'a b c']

-    successes = [

-        ('a', NS(foo=42, bar='a')),

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargs2ZeroOrMore(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one with unlimited"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='*')]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo=['a', 'b'], bar=[])),

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargs2OneOrMore(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one with one or more"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='+')]

-    failures = ['', '--foo', 'a', 'a b']

-    successes = [

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargs2Optional(ParserTestCase):

-    """Test a Positional with 2 nargs followed by one optional"""

-

-    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='?')]

-    failures = ['', '--foo', 'a', 'a b c d']

-    successes = [

-        ('a b', NS(foo=['a', 'b'], bar=None)),

-        ('a b c', NS(foo=['a', 'b'], bar='c')),

-    ]

-

-

-class TestPositionalsNargsZeroOrMore1(ParserTestCase):

-    """Test a Positional with unlimited nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo', nargs='*'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', ]

-    successes = [

-        ('a', NS(foo=[], bar=['a'])),

-        ('a b', NS(foo=['a'], bar=['b'])),

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargsOneOrMore1(ParserTestCase):

-    """Test a Positional with one or more nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo', nargs='+'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo=['a'], bar=['b'])),

-        ('a b c', NS(foo=['a', 'b'], bar=['c'])),

-    ]

-

-

-class TestPositionalsNargsOptional1(ParserTestCase):

-    """Test a Positional with an Optional nargs followed by one with 1"""

-

-    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs=1)]

-    failures = ['', '--foo', 'a b c']

-    successes = [

-        ('a', NS(foo=None, bar=['a'])),

-        ('a b', NS(foo='a', bar=['b'])),

-    ]

-

-

-class TestPositionalsNargsNoneZeroOrMore1(ParserTestCase):

-    """Test three Positionals: no nargs, unlimited nargs and 1 nargs"""

-

-    argument_signatures = [

-        Sig('foo'),

-        Sig('bar', nargs='*'),

-        Sig('baz', nargs=1),

-    ]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo='a', bar=[], baz=['b'])),

-        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),

-    ]

-

-

-class TestPositionalsNargsNoneOneOrMore1(ParserTestCase):

-    """Test three Positionals: no nargs, one or more nargs and 1 nargs"""

-

-    argument_signatures = [

-        Sig('foo'),

-        Sig('bar', nargs='+'),

-        Sig('baz', nargs=1),

-    ]

-    failures = ['', '--foo', 'a', 'b']

-    successes = [

-        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),

-        ('a b c d', NS(foo='a', bar=['b', 'c'], baz=['d'])),

-    ]

-

-

-class TestPositionalsNargsNoneOptional1(ParserTestCase):

-    """Test three Positionals: no nargs, optional narg and 1 nargs"""

-

-    argument_signatures = [

-        Sig('foo'),

-        Sig('bar', nargs='?', default=0.625),

-        Sig('baz', nargs=1),

-    ]

-    failures = ['', '--foo', 'a']

-    successes = [

-        ('a b', NS(foo='a', bar=0.625, baz=['b'])),

-        ('a b c', NS(foo='a', bar='b', baz=['c'])),

-    ]

-

-

-class TestPositionalsNargsOptionalOptional(ParserTestCase):

-    """Test two optional nargs"""

-

-    argument_signatures = [

-        Sig('foo', nargs='?'),

-        Sig('bar', nargs='?', default=42),

-    ]

-    failures = ['--foo', 'a b c']

-    successes = [

-        ('', NS(foo=None, bar=42)),

-        ('a', NS(foo='a', bar=42)),

-        ('a b', NS(foo='a', bar='b')),

-    ]

-

-

-class TestPositionalsNargsOptionalZeroOrMore(ParserTestCase):

-    """Test an Optional narg followed by unlimited nargs"""

-

-    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='*')]

-    failures = ['--foo']

-    successes = [

-        ('', NS(foo=None, bar=[])),

-        ('a', NS(foo='a', bar=[])),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsNargsOptionalOneOrMore(ParserTestCase):

-    """Test an Optional narg followed by one or more nargs"""

-

-    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='+')]

-    failures = ['', '--foo']

-    successes = [

-        ('a', NS(foo=None, bar=['a'])),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('a b c', NS(foo='a', bar=['b', 'c'])),

-    ]

-

-

-class TestPositionalsChoicesString(ParserTestCase):

-    """Test a set of single-character choices"""

-

-    argument_signatures = [Sig('spam', choices=set('abcdefg'))]

-    failures = ['', '--foo', 'h', '42', 'ef']

-    successes = [

-        ('a', NS(spam='a')),

-        ('g', NS(spam='g')),

-    ]

-

-

-class TestPositionalsChoicesInt(ParserTestCase):

-    """Test a set of integer choices"""

-

-    argument_signatures = [Sig('spam', type=int, choices=range(20))]

-    failures = ['', '--foo', 'h', '42', 'ef']

-    successes = [

-        ('4', NS(spam=4)),

-        ('15', NS(spam=15)),

-    ]

-

-

-class TestPositionalsActionAppend(ParserTestCase):

-    """Test the 'append' action"""

-

-    argument_signatures = [

-        Sig('spam', action='append'),

-        Sig('spam', action='append', nargs=2),

-    ]

-    failures = ['', '--foo', 'a', 'a b', 'a b c d']

-    successes = [

-        ('a b c', NS(spam=['a', ['b', 'c']])),

-    ]

-

-# ========================================

-# Combined optionals and positionals tests

-# ========================================

-

-class TestOptionalsNumericAndPositionals(ParserTestCase):

-    """Tests negative number args when numeric options are present"""

-

-    argument_signatures = [

-        Sig('x', nargs='?'),

-        Sig('-4', dest='y', action='store_true'),

-    ]

-    failures = ['-2', '-315']

-    successes = [

-        ('', NS(x=None, y=False)),

-        ('a', NS(x='a', y=False)),

-        ('-4', NS(x=None, y=True)),

-        ('-4 a', NS(x='a', y=True)),

-    ]

-

-

-class TestOptionalsAlmostNumericAndPositionals(ParserTestCase):

-    """Tests negative number args when almost numeric options are present"""

-

-    argument_signatures = [

-        Sig('x', nargs='?'),

-        Sig('-k4', dest='y', action='store_true'),

-    ]

-    failures = ['-k3']

-    successes = [

-        ('', NS(x=None, y=False)),

-        ('-2', NS(x='-2', y=False)),

-        ('a', NS(x='a', y=False)),

-        ('-k4', NS(x=None, y=True)),

-        ('-k4 a', NS(x='a', y=True)),

-    ]

-

-

-class TestEmptyAndSpaceContainingArguments(ParserTestCase):

-

-    argument_signatures = [

-        Sig('x', nargs='?'),

-        Sig('-y', '--yyy', dest='y'),

-    ]

-    failures = ['-y']

-    successes = [

-        ([''], NS(x='', y=None)),

-        (['a badger'], NS(x='a badger', y=None)),

-        (['-a badger'], NS(x='-a badger', y=None)),

-        (['-y', ''], NS(x=None, y='')),

-        (['-y', 'a badger'], NS(x=None, y='a badger')),

-        (['-y', '-a badger'], NS(x=None, y='-a badger')),

-        (['--yyy=a badger'], NS(x=None, y='a badger')),

-        (['--yyy=-a badger'], NS(x=None, y='-a badger')),

-    ]

-

-

-class TestPrefixCharacterOnlyArguments(ParserTestCase):

-

-    parser_signature = Sig(prefix_chars='-+')

-    argument_signatures = [

-        Sig('-', dest='x', nargs='?', const='badger'),

-        Sig('+', dest='y', type=int, default=42),

-        Sig('-+-', dest='z', action='store_true'),

-    ]

-    failures = ['-y', '+ -']

-    successes = [

-        ('', NS(x=None, y=42, z=False)),

-        ('-', NS(x='badger', y=42, z=False)),

-        ('- X', NS(x='X', y=42, z=False)),

-        ('+ -3', NS(x=None, y=-3, z=False)),

-        ('-+-', NS(x=None, y=42, z=True)),

-        ('- ===', NS(x='===', y=42, z=False)),

-    ]

-

-

-class TestNargsZeroOrMore(ParserTestCase):

-    """Tests specifying an args for an Optional that accepts zero or more"""

-

-    argument_signatures = [Sig('-x', nargs='*'), Sig('y', nargs='*')]

-    failures = []

-    successes = [

-        ('', NS(x=None, y=[])),

-        ('-x', NS(x=[], y=[])),

-        ('-x a', NS(x=['a'], y=[])),

-        ('-x a -- b', NS(x=['a'], y=['b'])),

-        ('a', NS(x=None, y=['a'])),

-        ('a -x', NS(x=[], y=['a'])),

-        ('a -x b', NS(x=['b'], y=['a'])),

-    ]

-

-

-class TestNargsRemainder(ParserTestCase):

-    """Tests specifying a positional with nargs=REMAINDER"""

-

-    argument_signatures = [Sig('x'), Sig('y', nargs='...'), Sig('-z')]

-    failures = ['', '-z', '-z Z']

-    successes = [

-        ('X', NS(x='X', y=[], z=None)),

-        ('-z Z X', NS(x='X', y=[], z='Z')),

-        ('X A B -z Z', NS(x='X', y=['A', 'B', '-z', 'Z'], z=None)),

-        ('X Y --foo', NS(x='X', y=['Y', '--foo'], z=None)),

-    ]

-

-

-class TestOptionLike(ParserTestCase):

-    """Tests options that may or may not be arguments"""

-

-    argument_signatures = [

-        Sig('-x', type=float),

-        Sig('-3', type=float, dest='y'),

-        Sig('z', nargs='*'),

-    ]

-    failures = ['-x', '-y2.5', '-xa', '-x -a',

-                '-x -3', '-x -3.5', '-3 -3.5',

-                '-x -2.5', '-x -2.5 a', '-3 -.5',

-                'a x -1', '-x -1 a', '-3 -1 a']

-    successes = [

-        ('', NS(x=None, y=None, z=[])),

-        ('-x 2.5', NS(x=2.5, y=None, z=[])),

-        ('-x 2.5 a', NS(x=2.5, y=None, z=['a'])),

-        ('-3.5', NS(x=None, y=0.5, z=[])),

-        ('-3-.5', NS(x=None, y=-0.5, z=[])),

-        ('-3 .5', NS(x=None, y=0.5, z=[])),

-        ('a -3.5', NS(x=None, y=0.5, z=['a'])),

-        ('a', NS(x=None, y=None, z=['a'])),

-        ('a -x 1', NS(x=1.0, y=None, z=['a'])),

-        ('-x 1 a', NS(x=1.0, y=None, z=['a'])),

-        ('-3 1 a', NS(x=None, y=1.0, z=['a'])),

-    ]

-

-

-class TestDefaultSuppress(ParserTestCase):

-    """Test actions with suppressed defaults"""

-

-    argument_signatures = [

-        Sig('foo', nargs='?', default=argparse.SUPPRESS),

-        Sig('bar', nargs='*', default=argparse.SUPPRESS),

-        Sig('--baz', action='store_true', default=argparse.SUPPRESS),

-    ]

-    failures = ['-x']

-    successes = [

-        ('', NS()),

-        ('a', NS(foo='a')),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('--baz', NS(baz=True)),

-        ('a --baz', NS(foo='a', baz=True)),

-        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),

-    ]

-

-

-class TestParserDefaultSuppress(ParserTestCase):

-    """Test actions with a parser-level default of SUPPRESS"""

-

-    parser_signature = Sig(argument_default=argparse.SUPPRESS)

-    argument_signatures = [

-        Sig('foo', nargs='?'),

-        Sig('bar', nargs='*'),

-        Sig('--baz', action='store_true'),

-    ]

-    failures = ['-x']

-    successes = [

-        ('', NS()),

-        ('a', NS(foo='a')),

-        ('a b', NS(foo='a', bar=['b'])),

-        ('--baz', NS(baz=True)),

-        ('a --baz', NS(foo='a', baz=True)),

-        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),

-    ]

-

-

-class TestParserDefault42(ParserTestCase):

-    """Test actions with a parser-level default of 42"""

-

-    parser_signature = Sig(argument_default=42, version='1.0')

-    argument_signatures = [

-        Sig('foo', nargs='?'),

-        Sig('bar', nargs='*'),

-        Sig('--baz', action='store_true'),

-    ]

-    failures = ['-x']

-    successes = [

-        ('', NS(foo=42, bar=42, baz=42)),

-        ('a', NS(foo='a', bar=42, baz=42)),

-        ('a b', NS(foo='a', bar=['b'], baz=42)),

-        ('--baz', NS(foo=42, bar=42, baz=True)),

-        ('a --baz', NS(foo='a', bar=42, baz=True)),

-        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),

-    ]

-

-

-class TestArgumentsFromFile(TempDirMixin, ParserTestCase):

-    """Test reading arguments from a file"""

-

-    def setUp(self):

-        super(TestArgumentsFromFile, self).setUp()

-        file_texts = [

-            ('hello', 'hello world!\n'),

-            ('recursive', '-a\n'

-                          'A\n'

-                          '@hello'),

-            ('invalid', '@no-such-path\n'),

-        ]

-        for path, text in file_texts:

-            file = open(path, 'w')

-            file.write(text)

-            file.close()

-

-    parser_signature = Sig(fromfile_prefix_chars='@')

-    argument_signatures = [

-        Sig('-a'),

-        Sig('x'),

-        Sig('y', nargs='+'),

-    ]

-    failures = ['', '-b', 'X', '@invalid', '@missing']

-    successes = [

-        ('X Y', NS(a=None, x='X', y=['Y'])),

-        ('X -a A Y Z', NS(a='A', x='X', y=['Y', 'Z'])),

-        ('@hello X', NS(a=None, x='hello world!', y=['X'])),

-        ('X @hello', NS(a=None, x='X', y=['hello world!'])),

-        ('-a B @recursive Y Z', NS(a='A', x='hello world!', y=['Y', 'Z'])),

-        ('X @recursive Z -a B', NS(a='B', x='X', y=['hello world!', 'Z'])),

-    ]

-

-

-class TestArgumentsFromFileConverter(TempDirMixin, ParserTestCase):

-    """Test reading arguments from a file"""

-

-    def setUp(self):

-        super(TestArgumentsFromFileConverter, self).setUp()

-        file_texts = [

-            ('hello', 'hello world!\n'),

-        ]

-        for path, text in file_texts:

-            file = open(path, 'w')

-            file.write(text)

-            file.close()

-

-    class FromFileConverterArgumentParser(ErrorRaisingArgumentParser):

-

-        def convert_arg_line_to_args(self, arg_line):

-            for arg in arg_line.split():

-                if not arg.strip():

-                    continue

-                yield arg

-    parser_class = FromFileConverterArgumentParser

-    parser_signature = Sig(fromfile_prefix_chars='@')

-    argument_signatures = [

-        Sig('y', nargs='+'),

-    ]

-    failures = []

-    successes = [

-        ('@hello X', NS(y=['hello', 'world!', 'X'])),

-    ]

-

-

-# =====================

-# Type conversion tests

-# =====================

-

-class TestFileTypeRepr(TestCase):

-

-    def test_r(self):

-        type = argparse.FileType('r')

-        self.assertEqual("FileType('r')", repr(type))

-

-    def test_wb_1(self):

-        type = argparse.FileType('wb', 1)

-        self.assertEqual("FileType('wb', 1)", repr(type))

-

-

-class RFile(object):

-    seen = {}

-

-    def __init__(self, name):

-        self.name = name

-

-    def __eq__(self, other):

-        if other in self.seen:

-            text = self.seen[other]

-        else:

-            text = self.seen[other] = other.read()

-            other.close()

-        if not isinstance(text, str):

-            text = text.decode('ascii')

-        return self.name == other.name == text

-

-

-class TestFileTypeR(TempDirMixin, ParserTestCase):

-    """Test the FileType option/argument type for reading files"""

-

-    def setUp(self):

-        super(TestFileTypeR, self).setUp()

-        for file_name in ['foo', 'bar']:

-            file = open(os.path.join(self.temp_dir, file_name), 'w')

-            file.write(file_name)

-            file.close()

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType()),

-        Sig('spam', type=argparse.FileType('r')),

-    ]

-    failures = ['-x', '']

-    successes = [

-        ('foo', NS(x=None, spam=RFile('foo'))),

-        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),

-    ]

-

-

-class TestFileTypeRB(TempDirMixin, ParserTestCase):

-    """Test the FileType option/argument type for reading files"""

-

-    def setUp(self):

-        super(TestFileTypeRB, self).setUp()

-        for file_name in ['foo', 'bar']:

-            file = open(os.path.join(self.temp_dir, file_name), 'w')

-            file.write(file_name)

-            file.close()

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType('rb')),

-        Sig('spam', type=argparse.FileType('rb')),

-    ]

-    failures = ['-x', '']

-    successes = [

-        ('foo', NS(x=None, spam=RFile('foo'))),

-        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),

-        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),

-    ]

-

-

-class WFile(object):

-    seen = set()

-

-    def __init__(self, name):

-        self.name = name

-

-    def __eq__(self, other):

-        if other not in self.seen:

-            text = 'Check that file is writable.'

-            if 'b' in other.mode:

-                text = text.encode('ascii')

-            other.write(text)

-            other.close()

-            self.seen.add(other)

-        return self.name == other.name

-

-

-class TestFileTypeW(TempDirMixin, ParserTestCase):

-    """Test the FileType option/argument type for writing files"""

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType('w')),

-        Sig('spam', type=argparse.FileType('w')),

-    ]

-    failures = ['-x', '']

-    successes = [

-        ('foo', NS(x=None, spam=WFile('foo'))),

-        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),

-    ]

-

-

-class TestFileTypeWB(TempDirMixin, ParserTestCase):

-

-    argument_signatures = [

-        Sig('-x', type=argparse.FileType('wb')),

-        Sig('spam', type=argparse.FileType('wb')),

-    ]

-    failures = ['-x', '']

-    successes = [

-        ('foo', NS(x=None, spam=WFile('foo'))),

-        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),

-        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),

-    ]

-

-

-class TestTypeCallable(ParserTestCase):

-    """Test some callables as option/argument types"""

-

-    argument_signatures = [

-        Sig('--eggs', type=complex),

-        Sig('spam', type=float),

-    ]

-    failures = ['a', '42j', '--eggs a', '--eggs 2i']

-    successes = [

-        ('--eggs=42 42', NS(eggs=42, spam=42.0)),

-        ('--eggs 2j -- -1.5', NS(eggs=2j, spam=-1.5)),

-        ('1024.675', NS(eggs=None, spam=1024.675)),

-    ]

-

-

-class TestTypeUserDefined(ParserTestCase):

-    """Test a user-defined option/argument type"""

-

-    class MyType(TestCase):

-

-        def __init__(self, value):

-            self.value = value

-

-        def __eq__(self, other):

-            return (type(self), self.value) == (type(other), other.value)

-

-    argument_signatures = [

-        Sig('-x', type=MyType),

-        Sig('spam', type=MyType),

-    ]

-    failures = []

-    successes = [

-        ('a -x b', NS(x=MyType('b'), spam=MyType('a'))),

-        ('-xf g', NS(x=MyType('f'), spam=MyType('g'))),

-    ]

-

-

-class TestTypeClassicClass(ParserTestCase):

-    """Test a classic class type"""

-

-    class C:

-

-        def __init__(self, value):

-            self.value = value

-

-        def __eq__(self, other):

-            return (type(self), self.value) == (type(other), other.value)

-

-    argument_signatures = [

-        Sig('-x', type=C),

-        Sig('spam', type=C),

-    ]

-    failures = []

-    successes = [

-        ('a -x b', NS(x=C('b'), spam=C('a'))),

-        ('-xf g', NS(x=C('f'), spam=C('g'))),

-    ]

-

-

-class TestTypeRegistration(TestCase):

-    """Test a user-defined type by registering it"""

-

-    def test(self):

-

-        def get_my_type(string):

-            return 'my_type{%s}' % string

-

-        parser = argparse.ArgumentParser()

-        parser.register('type', 'my_type', get_my_type)

-        parser.add_argument('-x', type='my_type')

-        parser.add_argument('y', type='my_type')

-

-        self.assertEqual(parser.parse_args('1'.split()),

-                         NS(x=None, y='my_type{1}'))

-        self.assertEqual(parser.parse_args('-x 1 42'.split()),

-                         NS(x='my_type{1}', y='my_type{42}'))

-

-

-# ============

-# Action tests

-# ============

-

-class TestActionUserDefined(ParserTestCase):

-    """Test a user-defined option/argument action"""

-

-    class OptionalAction(argparse.Action):

-

-        def __call__(self, parser, namespace, value, option_string=None):

-            try:

-                # check destination and option string

-                assert self.dest == 'spam', 'dest: %s' % self.dest

-                assert option_string == '-s', 'flag: %s' % option_string

-                # when option is before argument, badger=2, and when

-                # option is after argument, badger=<whatever was set>

-                expected_ns = NS(spam=0.25)

-                if value in [0.125, 0.625]:

-                    expected_ns.badger = 2

-                elif value in [2.0]:

-                    expected_ns.badger = 84

-                else:

-                    raise AssertionError('value: %s' % value)

-                assert expected_ns == namespace, ('expected %s, got %s' %

-                                                  (expected_ns, namespace))

-            except AssertionError:

-                e = sys.exc_info()[1]

-                raise ArgumentParserError('opt_action failed: %s' % e)

-            setattr(namespace, 'spam', value)

-

-    class PositionalAction(argparse.Action):

-

-        def __call__(self, parser, namespace, value, option_string=None):

-            try:

-                assert option_string is None, ('option_string: %s' %

-                                               option_string)

-                # check destination

-                assert self.dest == 'badger', 'dest: %s' % self.dest

-                # when argument is before option, spam=0.25, and when

-                # option is after argument, spam=<whatever was set>

-                expected_ns = NS(badger=2)

-                if value in [42, 84]:

-                    expected_ns.spam = 0.25

-                elif value in [1]:

-                    expected_ns.spam = 0.625

-                elif value in [2]:

-                    expected_ns.spam = 0.125

-                else:

-                    raise AssertionError('value: %s' % value)

-                assert expected_ns == namespace, ('expected %s, got %s' %

-                                                  (expected_ns, namespace))

-            except AssertionError:

-                e = sys.exc_info()[1]

-                raise ArgumentParserError('arg_action failed: %s' % e)

-            setattr(namespace, 'badger', value)

-

-    argument_signatures = [

-        Sig('-s', dest='spam', action=OptionalAction,

-            type=float, default=0.25),

-        Sig('badger', action=PositionalAction,

-            type=int, nargs='?', default=2),

-    ]

-    failures = []

-    successes = [

-        ('-s0.125', NS(spam=0.125, badger=2)),

-        ('42', NS(spam=0.25, badger=42)),

-        ('-s 0.625 1', NS(spam=0.625, badger=1)),

-        ('84 -s2', NS(spam=2.0, badger=84)),

-    ]

-

-

-class TestActionRegistration(TestCase):

-    """Test a user-defined action supplied by registering it"""

-

-    class MyAction(argparse.Action):

-

-        def __call__(self, parser, namespace, values, option_string=None):

-            setattr(namespace, self.dest, 'foo[%s]' % values)

-

-    def test(self):

-

-        parser = argparse.ArgumentParser()

-        parser.register('action', 'my_action', self.MyAction)

-        parser.add_argument('badger', action='my_action')

-

-        self.assertEqual(parser.parse_args(['1']), NS(badger='foo[1]'))

-        self.assertEqual(parser.parse_args(['42']), NS(badger='foo[42]'))

-

-

-# ================

-# Subparsers tests

-# ================

-

-class TestAddSubparsers(TestCase):

-    """Test the add_subparsers method"""

-

-    def assertArgumentParserError(self, *args, **kwargs):

-        self.assertRaises(ArgumentParserError, *args, **kwargs)

-

-    def _get_parser(self, subparser_help=False):

-        # create a parser with a subparsers argument

-        parser = ErrorRaisingArgumentParser(

-            prog='PROG', description='main description')

-        parser.add_argument(

-            '--foo', action='store_true', help='foo help')

-        parser.add_argument(

-            'bar', type=float, help='bar help')

-

-        # check that only one subparsers argument can be added

-        subparsers = parser.add_subparsers(help='command help')

-        self.assertArgumentParserError(parser.add_subparsers)

-

-        # add first sub-parser

-        parser1_kwargs = dict(description='1 description')

-        if subparser_help:

-            parser1_kwargs['help'] = '1 help'

-        parser1 = subparsers.add_parser('1', **parser1_kwargs)

-        parser1.add_argument('-w', type=int, help='w help')

-        parser1.add_argument('x', choices='abc', help='x help')

-

-        # add second sub-parser

-        parser2_kwargs = dict(description='2 description')

-        if subparser_help:

-            parser2_kwargs['help'] = '2 help'

-        parser2 = subparsers.add_parser('2', **parser2_kwargs)

-        parser2.add_argument('-y', choices='123', help='y help')

-        parser2.add_argument('z', type=complex, nargs='*', help='z help')

-

-        # return the main parser

-        return parser

-

-    def setUp(self):

-        self.parser = self._get_parser()

-        self.command_help_parser = self._get_parser(subparser_help=True)

-

-    def test_parse_args_failures(self):

-        # check some failure cases:

-        for args_str in ['', 'a', 'a a', '0.5 a', '0.5 1',

-                         '0.5 1 -y', '0.5 2 -w']:

-            args = args_str.split()

-            self.assertArgumentParserError(self.parser.parse_args, args)

-

-    def test_parse_args(self):

-        # check some non-failure cases:

-        self.assertEqual(

-            self.parser.parse_args('0.5 1 b -w 7'.split()),

-            NS(foo=False, bar=0.5, w=7, x='b'),

-        )

-        self.assertEqual(

-            self.parser.parse_args('0.25 --foo 2 -y 2 3j -- -1j'.split()),

-            NS(foo=True, bar=0.25, y='2', z=[3j, -1j]),

-        )

-        self.assertEqual(

-            self.parser.parse_args('--foo 0.125 1 c'.split()),

-            NS(foo=True, bar=0.125, w=None, x='c'),

-        )

-

-    def test_dest(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.add_argument('--foo', action='store_true')

-        subparsers = parser.add_subparsers(dest='bar')

-        parser1 = subparsers.add_parser('1')

-        parser1.add_argument('baz')

-        self.assertEqual(NS(foo=False, bar='1', baz='2'),

-                         parser.parse_args('1 2'.split()))

-

-    def test_help(self):

-        self.assertEqual(self.parser.format_usage(),

-                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')

-        self.assertEqual(self.parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [--foo] bar {1,2} ...

-

-            main description

-

-            positional arguments:

-              bar         bar help

-              {1,2}       command help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              --foo       foo help

-            '''))

-

-    def test_parser_command_help(self):

-        self.assertEqual(self.command_help_parser.format_usage(),

-                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')

-        self.assertEqual(self.command_help_parser.format_help(),

-                         textwrap.dedent('''\

-            usage: PROG [-h] [--foo] bar {1,2} ...

-

-            main description

-

-            positional arguments:

-              bar         bar help

-              {1,2}       command help

-                1         1 help

-                2         2 help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              --foo       foo help

-            '''))

-

-    def test_subparser_title_help(self):

-        parser = ErrorRaisingArgumentParser(prog='PROG',

-                                            description='main description')

-        parser.add_argument('--foo', action='store_true', help='foo help')

-        parser.add_argument('bar', help='bar help')

-        subparsers = parser.add_subparsers(title='subcommands',

-                                           description='command help',

-                                           help='additional text')

-        parser1 = subparsers.add_parser('1')

-        parser2 = subparsers.add_parser('2')

-        self.assertEqual(parser.format_usage(),

-                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')

-        self.assertEqual(parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [--foo] bar {1,2} ...

-

-            main description

-

-            positional arguments:

-              bar         bar help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              --foo       foo help

-

-            subcommands:

-              command help

-

-              {1,2}       additional text

-            '''))

-

-    def _test_subparser_help(self, args_str, expected_help):

-        try:

-            self.parser.parse_args(args_str.split())

-        except ArgumentParserError:

-            err = sys.exc_info()[1]

-            if err.stdout != expected_help:

-                print(repr(expected_help))

-                print(repr(err.stdout))

-            self.assertEqual(err.stdout, expected_help)

-

-    def test_subparser1_help(self):

-        self._test_subparser_help('5.0 1 -h', textwrap.dedent('''\

-            usage: PROG bar 1 [-h] [-w W] {a,b,c}

-

-            1 description

-

-            positional arguments:

-              {a,b,c}     x help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -w W        w help

-            '''))

-

-    def test_subparser2_help(self):

-        self._test_subparser_help('5.0 2 -h', textwrap.dedent('''\

-            usage: PROG bar 2 [-h] [-y {1,2,3}] [z [z ...]]

-

-            2 description

-

-            positional arguments:

-              z           z help

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -y {1,2,3}  y help

-            '''))

-

-# ============

-# Groups tests

-# ============

-

-class TestPositionalsGroups(TestCase):

-    """Tests that order of group positionals matches construction order"""

-

-    def test_nongroup_first(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.add_argument('foo')

-        group = parser.add_argument_group('g')

-        group.add_argument('bar')

-        parser.add_argument('baz')

-        expected = NS(foo='1', bar='2', baz='3')

-        result = parser.parse_args('1 2 3'.split())

-        self.assertEqual(expected, result)

-

-    def test_group_first(self):

-        parser = ErrorRaisingArgumentParser()

-        group = parser.add_argument_group('xxx')

-        group.add_argument('foo')

-        parser.add_argument('bar')

-        parser.add_argument('baz')

-        expected = NS(foo='1', bar='2', baz='3')

-        result = parser.parse_args('1 2 3'.split())

-        self.assertEqual(expected, result)

-

-    def test_interleaved_groups(self):

-        parser = ErrorRaisingArgumentParser()

-        group = parser.add_argument_group('xxx')

-        parser.add_argument('foo')

-        group.add_argument('bar')

-        parser.add_argument('baz')

-        group = parser.add_argument_group('yyy')

-        group.add_argument('frell')

-        expected = NS(foo='1', bar='2', baz='3', frell='4')

-        result = parser.parse_args('1 2 3 4'.split())

-        self.assertEqual(expected, result)

-

-# ===================

-# Parent parser tests

-# ===================

-

-class TestParentParsers(TestCase):

-    """Tests that parsers can be created with parent parsers"""

-

-    def assertArgumentParserError(self, *args, **kwargs):

-        self.assertRaises(ArgumentParserError, *args, **kwargs)

-

-    def setUp(self):

-        self.wxyz_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.wxyz_parent.add_argument('--w')

-        x_group = self.wxyz_parent.add_argument_group('x')

-        x_group.add_argument('-y')

-        self.wxyz_parent.add_argument('z')

-

-        self.abcd_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.abcd_parent.add_argument('a')

-        self.abcd_parent.add_argument('-b')

-        c_group = self.abcd_parent.add_argument_group('c')

-        c_group.add_argument('--d')

-

-        self.w_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.w_parent.add_argument('--w')

-

-        self.z_parent = ErrorRaisingArgumentParser(add_help=False)

-        self.z_parent.add_argument('z')

-

-        # parents with mutually exclusive groups

-        self.ab_mutex_parent = ErrorRaisingArgumentParser(add_help=False)

-        group = self.ab_mutex_parent.add_mutually_exclusive_group()

-        group.add_argument('-a', action='store_true')

-        group.add_argument('-b', action='store_true')

-

-    def test_single_parent(self):

-        parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent])

-        self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()),

-                         NS(w='3', y='1', z='2'))

-

-    def test_single_parent_mutex(self):

-        self._test_mutex_ab(self.ab_mutex_parent.parse_args)

-        parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent])

-        self._test_mutex_ab(parser.parse_args)

-

-    def test_single_granparent_mutex(self):

-        parents = [self.ab_mutex_parent]

-        parser = ErrorRaisingArgumentParser(add_help=False, parents=parents)

-        parser = ErrorRaisingArgumentParser(parents=[parser])

-        self._test_mutex_ab(parser.parse_args)

-

-    def _test_mutex_ab(self, parse_args):

-        self.assertEqual(parse_args([]), NS(a=False, b=False))

-        self.assertEqual(parse_args(['-a']), NS(a=True, b=False))

-        self.assertEqual(parse_args(['-b']), NS(a=False, b=True))

-        self.assertArgumentParserError(parse_args, ['-a', '-b'])

-        self.assertArgumentParserError(parse_args, ['-b', '-a'])

-        self.assertArgumentParserError(parse_args, ['-c'])

-        self.assertArgumentParserError(parse_args, ['-a', '-c'])

-        self.assertArgumentParserError(parse_args, ['-b', '-c'])

-

-    def test_multiple_parents(self):

-        parents = [self.abcd_parent, self.wxyz_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        self.assertEqual(parser.parse_args('--d 1 --w 2 3 4'.split()),

-                         NS(a='3', b=None, d='1', w='2', y=None, z='4'))

-

-    def test_multiple_parents_mutex(self):

-        parents = [self.ab_mutex_parent, self.wxyz_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        self.assertEqual(parser.parse_args('-a --w 2 3'.split()),

-                         NS(a=True, b=False, w='2', y=None, z='3'))

-        self.assertArgumentParserError(

-            parser.parse_args, '-a --w 2 3 -b'.split())

-        self.assertArgumentParserError(

-            parser.parse_args, '-a -b --w 2 3'.split())

-

-    def test_conflicting_parents(self):

-        self.assertRaises(

-            argparse.ArgumentError,

-            argparse.ArgumentParser,

-            parents=[self.w_parent, self.wxyz_parent])

-

-    def test_conflicting_parents_mutex(self):

-        self.assertRaises(

-            argparse.ArgumentError,

-            argparse.ArgumentParser,

-            parents=[self.abcd_parent, self.ab_mutex_parent])

-

-    def test_same_argument_name_parents(self):

-        parents = [self.wxyz_parent, self.z_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        self.assertEqual(parser.parse_args('1 2'.split()),

-                         NS(w=None, y=None, z='2'))

-

-    def test_subparser_parents(self):

-        parser = ErrorRaisingArgumentParser()

-        subparsers = parser.add_subparsers()

-        abcde_parser = subparsers.add_parser('bar', parents=[self.abcd_parent])

-        abcde_parser.add_argument('e')

-        self.assertEqual(parser.parse_args('bar -b 1 --d 2 3 4'.split()),

-                         NS(a='3', b='1', d='2', e='4'))

-

-    def test_subparser_parents_mutex(self):

-        parser = ErrorRaisingArgumentParser()

-        subparsers = parser.add_subparsers()

-        parents = [self.ab_mutex_parent]

-        abc_parser = subparsers.add_parser('foo', parents=parents)

-        c_group = abc_parser.add_argument_group('c_group')

-        c_group.add_argument('c')

-        parents = [self.wxyz_parent, self.ab_mutex_parent]

-        wxyzabe_parser = subparsers.add_parser('bar', parents=parents)

-        wxyzabe_parser.add_argument('e')

-        self.assertEqual(parser.parse_args('foo -a 4'.split()),

-                         NS(a=True, b=False, c='4'))

-        self.assertEqual(parser.parse_args('bar -b  --w 2 3 4'.split()),

-                         NS(a=False, b=True, w='2', y=None, z='3', e='4'))

-        self.assertArgumentParserError(

-            parser.parse_args, 'foo -a -b 4'.split())

-        self.assertArgumentParserError(

-            parser.parse_args, 'bar -b -a 4'.split())

-

-    def test_parent_help(self):

-        parents = [self.abcd_parent, self.wxyz_parent]

-        parser = ErrorRaisingArgumentParser(parents=parents)

-        parser_help = parser.format_help()

-        self.assertEqual(parser_help, textwrap.dedent('''\

-            usage: test_argparse.py [-h] [-b B] [--d D] [--w W] [-y Y] a z

-

-            positional arguments:

-              a

-              z

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -b B

-              --w W

-

-            c:

-              --d D

-

-            x:

-              -y Y

-        '''))

-

-    def test_groups_parents(self):

-        parent = ErrorRaisingArgumentParser(add_help=False)

-        g = parent.add_argument_group(title='g', description='gd')

-        g.add_argument('-w')

-        g.add_argument('-x')

-        m = parent.add_mutually_exclusive_group()

-        m.add_argument('-y')

-        m.add_argument('-z')

-        parser = ErrorRaisingArgumentParser(parents=[parent])

-

-        self.assertRaises(ArgumentParserError, parser.parse_args,

-            ['-y', 'Y', '-z', 'Z'])

-

-        parser_help = parser.format_help()

-        self.assertEqual(parser_help, textwrap.dedent('''\

-            usage: test_argparse.py [-h] [-w W] [-x X] [-y Y | -z Z]

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -y Y

-              -z Z

-

-            g:

-              gd

-

-              -w W

-              -x X

-        '''))

-

-# ==============================

-# Mutually exclusive group tests

-# ==============================

-

-class TestMutuallyExclusiveGroupErrors(TestCase):

-

-    def test_invalid_add_argument_group(self):

-        parser = ErrorRaisingArgumentParser()

-        raises = self.assertRaises

-        raises(TypeError, parser.add_mutually_exclusive_group, title='foo')

-

-    def test_invalid_add_argument(self):

-        parser = ErrorRaisingArgumentParser()

-        group = parser.add_mutually_exclusive_group()

-        add_argument = group.add_argument

-        raises = self.assertRaises

-        raises(ValueError, add_argument, '--foo', required=True)

-        raises(ValueError, add_argument, 'bar')

-        raises(ValueError, add_argument, 'bar', nargs='+')

-        raises(ValueError, add_argument, 'bar', nargs=1)

-        raises(ValueError, add_argument, 'bar', nargs=argparse.PARSER)

-

-

-class MEMixin(object):

-

-    def test_failures_when_not_required(self):

-        parse_args = self.get_parser(required=False).parse_args

-        error = ArgumentParserError

-        for args_string in self.failures:

-            self.assertRaises(error, parse_args, args_string.split())

-

-    def test_failures_when_required(self):

-        parse_args = self.get_parser(required=True).parse_args

-        error = ArgumentParserError

-        for args_string in self.failures + ['']:

-            self.assertRaises(error, parse_args, args_string.split())

-

-    def test_successes_when_not_required(self):

-        parse_args = self.get_parser(required=False).parse_args

-        successes = self.successes + self.successes_when_not_required

-        for args_string, expected_ns in successes:

-            actual_ns = parse_args(args_string.split())

-            self.assertEqual(actual_ns, expected_ns)

-

-    def test_successes_when_required(self):

-        parse_args = self.get_parser(required=True).parse_args

-        for args_string, expected_ns in self.successes:

-            actual_ns = parse_args(args_string.split())

-            self.assertEqual(actual_ns, expected_ns)

-

-    def test_usage_when_not_required(self):

-        format_usage = self.get_parser(required=False).format_usage

-        expected_usage = self.usage_when_not_required

-        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))

-

-    def test_usage_when_required(self):

-        format_usage = self.get_parser(required=True).format_usage

-        expected_usage = self.usage_when_required

-        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))

-

-    def test_help_when_not_required(self):

-        format_help = self.get_parser(required=False).format_help

-        help = self.usage_when_not_required + self.help

-        self.assertEqual(format_help(), textwrap.dedent(help))

-

-    def test_help_when_required(self):

-        format_help = self.get_parser(required=True).format_help

-        help = self.usage_when_required + self.help

-        self.assertEqual(format_help(), textwrap.dedent(help))

-

-

-class TestMutuallyExclusiveSimple(MEMixin, TestCase):

-

-    def get_parser(self, required=None):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('--bar', help='bar help')

-        group.add_argument('--baz', nargs='?', const='Z', help='baz help')

-        return parser

-

-    failures = ['--bar X --baz Y', '--bar X --baz']

-    successes = [

-        ('--bar X', NS(bar='X', baz=None)),

-        ('--bar X --bar Z', NS(bar='Z', baz=None)),

-        ('--baz Y', NS(bar=None, baz='Y')),

-        ('--baz', NS(bar=None, baz='Z')),

-    ]

-    successes_when_not_required = [

-        ('', NS(bar=None, baz=None)),

-    ]

-

-    usage_when_not_required = '''\

-        usage: PROG [-h] [--bar BAR | --baz [BAZ]]

-        '''

-    usage_when_required = '''\

-        usage: PROG [-h] (--bar BAR | --baz [BAZ])

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help   show this help message and exit

-          --bar BAR    bar help

-          --baz [BAZ]  baz help

-        '''

-

-

-class TestMutuallyExclusiveLong(MEMixin, TestCase):

-

-    def get_parser(self, required=None):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        parser.add_argument('--abcde', help='abcde help')

-        parser.add_argument('--fghij', help='fghij help')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('--klmno', help='klmno help')

-        group.add_argument('--pqrst', help='pqrst help')

-        return parser

-

-    failures = ['--klmno X --pqrst Y']

-    successes = [

-        ('--klmno X', NS(abcde=None, fghij=None, klmno='X', pqrst=None)),

-        ('--abcde Y --klmno X',

-            NS(abcde='Y', fghij=None, klmno='X', pqrst=None)),

-        ('--pqrst X', NS(abcde=None, fghij=None, klmno=None, pqrst='X')),

-        ('--pqrst X --fghij Y',

-            NS(abcde=None, fghij='Y', klmno=None, pqrst='X')),

-    ]

-    successes_when_not_required = [

-        ('', NS(abcde=None, fghij=None, klmno=None, pqrst=None)),

-    ]

-

-    usage_when_not_required = '''\

-    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]

-                [--klmno KLMNO | --pqrst PQRST]

-    '''

-    usage_when_required = '''\

-    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]

-                (--klmno KLMNO | --pqrst PQRST)

-    '''

-    help = '''\

-

-    optional arguments:

-      -h, --help     show this help message and exit

-      --abcde ABCDE  abcde help

-      --fghij FGHIJ  fghij help

-      --klmno KLMNO  klmno help

-      --pqrst PQRST  pqrst help

-    '''

-

-

-class TestMutuallyExclusiveFirstSuppressed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('-x', help=argparse.SUPPRESS)

-        group.add_argument('-y', action='store_false', help='y help')

-        return parser

-

-    failures = ['-x X -y']

-    successes = [

-        ('-x X', NS(x='X', y=True)),

-        ('-x X -x Y', NS(x='Y', y=True)),

-        ('-y', NS(x=None, y=False)),

-    ]

-    successes_when_not_required = [

-        ('', NS(x=None, y=True)),

-    ]

-

-    usage_when_not_required = '''\

-        usage: PROG [-h] [-y]

-        '''

-    usage_when_required = '''\

-        usage: PROG [-h] -y

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -y          y help

-        '''

-

-

-class TestMutuallyExclusiveManySuppressed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        add = group.add_argument

-        add('--spam', action='store_true', help=argparse.SUPPRESS)

-        add('--badger', action='store_false', help=argparse.SUPPRESS)

-        add('--bladder', help=argparse.SUPPRESS)

-        return parser

-

-    failures = [

-        '--spam --badger',

-        '--badger --bladder B',

-        '--bladder B --spam',

-    ]

-    successes = [

-        ('--spam', NS(spam=True, badger=True, bladder=None)),

-        ('--badger', NS(spam=False, badger=False, bladder=None)),

-        ('--bladder B', NS(spam=False, badger=True, bladder='B')),

-        ('--spam --spam', NS(spam=True, badger=True, bladder=None)),

-    ]

-    successes_when_not_required = [

-        ('', NS(spam=False, badger=True, bladder=None)),

-    ]

-

-    usage_when_required = usage_when_not_required = '''\

-        usage: PROG [-h]

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-        '''

-

-

-class TestMutuallyExclusiveOptionalAndPositional(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('--foo', action='store_true', help='FOO')

-        group.add_argument('--spam', help='SPAM')

-        group.add_argument('badger', nargs='*', default='X', help='BADGER')

-        return parser

-

-    failures = [

-        '--foo --spam S',

-        '--spam S X',

-        'X --foo',

-        'X Y Z --spam S',

-        '--foo X Y',

-    ]

-    successes = [

-        ('--foo', NS(foo=True, spam=None, badger='X')),

-        ('--spam S', NS(foo=False, spam='S', badger='X')),

-        ('X', NS(foo=False, spam=None, badger=['X'])),

-        ('X Y Z', NS(foo=False, spam=None, badger=['X', 'Y', 'Z'])),

-    ]

-    successes_when_not_required = [

-        ('', NS(foo=False, spam=None, badger='X')),

-    ]

-

-    usage_when_not_required = '''\

-        usage: PROG [-h] [--foo | --spam SPAM | badger [badger ...]]

-        '''

-    usage_when_required = '''\

-        usage: PROG [-h] (--foo | --spam SPAM | badger [badger ...])

-        '''

-    help = '''\

-

-        positional arguments:

-          badger       BADGER

-

-        optional arguments:

-          -h, --help   show this help message and exit

-          --foo        FOO

-          --spam SPAM  SPAM

-        '''

-

-

-class TestMutuallyExclusiveOptionalsMixed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        parser.add_argument('-x', action='store_true', help='x help')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('-a', action='store_true', help='a help')

-        group.add_argument('-b', action='store_true', help='b help')

-        parser.add_argument('-y', action='store_true', help='y help')

-        group.add_argument('-c', action='store_true', help='c help')

-        return parser

-

-    failures = ['-a -b', '-b -c', '-a -c', '-a -b -c']

-    successes = [

-        ('-a', NS(a=True, b=False, c=False, x=False, y=False)),

-        ('-b', NS(a=False, b=True, c=False, x=False, y=False)),

-        ('-c', NS(a=False, b=False, c=True, x=False, y=False)),

-        ('-a -x', NS(a=True, b=False, c=False, x=True, y=False)),

-        ('-y -b', NS(a=False, b=True, c=False, x=False, y=True)),

-        ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True)),

-    ]

-    successes_when_not_required = [

-        ('', NS(a=False, b=False, c=False, x=False, y=False)),

-        ('-x', NS(a=False, b=False, c=False, x=True, y=False)),

-        ('-y', NS(a=False, b=False, c=False, x=False, y=True)),

-    ]

-

-    usage_when_required = usage_when_not_required = '''\

-        usage: PROG [-h] [-x] [-a] [-b] [-y] [-c]

-        '''

-    help = '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -x          x help

-          -a          a help

-          -b          b help

-          -y          y help

-          -c          c help

-        '''

-

-

-class TestMutuallyExclusiveOptionalsAndPositionalsMixed(MEMixin, TestCase):

-

-    def get_parser(self, required):

-        parser = ErrorRaisingArgumentParser(prog='PROG')

-        parser.add_argument('x', help='x help')

-        parser.add_argument('-y', action='store_true', help='y help')

-        group = parser.add_mutually_exclusive_group(required=required)

-        group.add_argument('a', nargs='?', help='a help')

-        group.add_argument('-b', action='store_true', help='b help')

-        group.add_argument('-c', action='store_true', help='c help')

-        return parser

-

-    failures = ['X A -b', '-b -c', '-c X A']

-    successes = [

-        ('X A', NS(a='A', b=False, c=False, x='X', y=False)),

-        ('X -b', NS(a=None, b=True, c=False, x='X', y=False)),

-        ('X -c', NS(a=None, b=False, c=True, x='X', y=False)),

-        ('X A -y', NS(a='A', b=False, c=False, x='X', y=True)),

-        ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True)),

-    ]

-    successes_when_not_required = [

-        ('X', NS(a=None, b=False, c=False, x='X', y=False)),

-        ('X -y', NS(a=None, b=False, c=False, x='X', y=True)),

-    ]

-

-    usage_when_required = usage_when_not_required = '''\

-        usage: PROG [-h] [-y] [-b] [-c] x [a]

-        '''

-    help = '''\

-

-        positional arguments:

-          x           x help

-          a           a help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -y          y help

-          -b          b help

-          -c          c help

-        '''

-

-# =================================================

-# Mutually exclusive group in parent parser tests

-# =================================================

-

-class MEPBase(object):

-

-    def get_parser(self, required=None):

-        parent = super(MEPBase, self).get_parser(required=required)

-        parser = ErrorRaisingArgumentParser(

-            prog=parent.prog, add_help=False, parents=[parent])

-        return parser

-

-

-class TestMutuallyExclusiveGroupErrorsParent(

-    MEPBase, TestMutuallyExclusiveGroupErrors):

-    pass

-

-

-class TestMutuallyExclusiveSimpleParent(

-    MEPBase, TestMutuallyExclusiveSimple):

-    pass

-

-

-class TestMutuallyExclusiveLongParent(

-    MEPBase, TestMutuallyExclusiveLong):

-    pass

-

-

-class TestMutuallyExclusiveFirstSuppressedParent(

-    MEPBase, TestMutuallyExclusiveFirstSuppressed):

-    pass

-

-

-class TestMutuallyExclusiveManySuppressedParent(

-    MEPBase, TestMutuallyExclusiveManySuppressed):

-    pass

-

-

-class TestMutuallyExclusiveOptionalAndPositionalParent(

-    MEPBase, TestMutuallyExclusiveOptionalAndPositional):

-    pass

-

-

-class TestMutuallyExclusiveOptionalsMixedParent(

-    MEPBase, TestMutuallyExclusiveOptionalsMixed):

-    pass

-

-

-class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent(

-    MEPBase, TestMutuallyExclusiveOptionalsAndPositionalsMixed):

-    pass

-

-# =================

-# Set default tests

-# =================

-

-class TestSetDefaults(TestCase):

-

-    def test_set_defaults_no_args(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(x='foo')

-        parser.set_defaults(y='bar', z=1)

-        self.assertEqual(NS(x='foo', y='bar', z=1),

-                         parser.parse_args([]))

-        self.assertEqual(NS(x='foo', y='bar', z=1),

-                         parser.parse_args([], NS()))

-        self.assertEqual(NS(x='baz', y='bar', z=1),

-                         parser.parse_args([], NS(x='baz')))

-        self.assertEqual(NS(x='baz', y='bar', z=2),

-                         parser.parse_args([], NS(x='baz', z=2)))

-

-    def test_set_defaults_with_args(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(x='foo', y='bar')

-        parser.add_argument('-x', default='xfoox')

-        self.assertEqual(NS(x='xfoox', y='bar'),

-                         parser.parse_args([]))

-        self.assertEqual(NS(x='xfoox', y='bar'),

-                         parser.parse_args([], NS()))

-        self.assertEqual(NS(x='baz', y='bar'),

-                         parser.parse_args([], NS(x='baz')))

-        self.assertEqual(NS(x='1', y='bar'),

-                         parser.parse_args('-x 1'.split()))

-        self.assertEqual(NS(x='1', y='bar'),

-                         parser.parse_args('-x 1'.split(), NS()))

-        self.assertEqual(NS(x='1', y='bar'),

-                         parser.parse_args('-x 1'.split(), NS(x='baz')))

-

-    def test_set_defaults_subparsers(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(x='foo')

-        subparsers = parser.add_subparsers()

-        parser_a = subparsers.add_parser('a')

-        parser_a.set_defaults(y='bar')

-        self.assertEqual(NS(x='foo', y='bar'),

-                         parser.parse_args('a'.split()))

-

-    def test_set_defaults_parents(self):

-        parent = ErrorRaisingArgumentParser(add_help=False)

-        parent.set_defaults(x='foo')

-        parser = ErrorRaisingArgumentParser(parents=[parent])

-        self.assertEqual(NS(x='foo'), parser.parse_args([]))

-

-    def test_set_defaults_same_as_add_argument(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(w='W', x='X', y='Y', z='Z')

-        parser.add_argument('-w')

-        parser.add_argument('-x', default='XX')

-        parser.add_argument('y', nargs='?')

-        parser.add_argument('z', nargs='?', default='ZZ')

-

-        # defaults set previously

-        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),

-                         parser.parse_args([]))

-

-        # reset defaults

-        parser.set_defaults(w='WW', x='X', y='YY', z='Z')

-        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),

-                         parser.parse_args([]))

-

-    def test_set_defaults_same_as_add_argument_group(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.set_defaults(w='W', x='X', y='Y', z='Z')

-        group = parser.add_argument_group('foo')

-        group.add_argument('-w')

-        group.add_argument('-x', default='XX')

-        group.add_argument('y', nargs='?')

-        group.add_argument('z', nargs='?', default='ZZ')

-

-

-        # defaults set previously

-        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),

-                         parser.parse_args([]))

-

-        # reset defaults

-        parser.set_defaults(w='WW', x='X', y='YY', z='Z')

-        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),

-                         parser.parse_args([]))

-

-# =================

-# Get default tests

-# =================

-

-class TestGetDefault(TestCase):

-

-    def test_get_default(self):

-        parser = ErrorRaisingArgumentParser()

-        self.assertEqual(None, parser.get_default("foo"))

-        self.assertEqual(None, parser.get_default("bar"))

-

-        parser.add_argument("--foo")

-        self.assertEqual(None, parser.get_default("foo"))

-        self.assertEqual(None, parser.get_default("bar"))

-

-        parser.add_argument("--bar", type=int, default=42)

-        self.assertEqual(None, parser.get_default("foo"))

-        self.assertEqual(42, parser.get_default("bar"))

-

-        parser.set_defaults(foo="badger")

-        self.assertEqual("badger", parser.get_default("foo"))

-        self.assertEqual(42, parser.get_default("bar"))

-

-# ==========================

-# Namespace 'contains' tests

-# ==========================

-

-class TestNamespaceContainsSimple(TestCase):

-

-    def test_empty(self):

-        ns = argparse.Namespace()

-        self.assertEquals('' in ns, False)

-        self.assertEquals('' not in ns, True)

-        self.assertEquals('x' in ns, False)

-

-    def test_non_empty(self):

-        ns = argparse.Namespace(x=1, y=2)

-        self.assertEquals('x' in ns, True)

-        self.assertEquals('x' not in ns, False)

-        self.assertEquals('y' in ns, True)

-        self.assertEquals('' in ns, False)

-        self.assertEquals('xx' in ns, False)

-        self.assertEquals('z' in ns, False)

-

-# =====================

-# Help formatting tests

-# =====================

-

-class TestHelpFormattingMetaclass(type):

-

-    def __init__(cls, name, bases, bodydict):

-        if name == 'HelpTestCase':

-            return

-

-        class AddTests(object):

-

-            def __init__(self, test_class, func_suffix, std_name):

-                self.func_suffix = func_suffix

-                self.std_name = std_name

-

-                for test_func in [self.test_format,

-                                  self.test_print,

-                                  self.test_print_file]:

-                    test_name = '%s_%s' % (test_func.__name__, func_suffix)

-

-                    def test_wrapper(self, test_func=test_func):

-                        test_func(self)

-                    try:

-                        test_wrapper.__name__ = test_name

-                    except TypeError:

-                        pass

-                    setattr(test_class, test_name, test_wrapper)

-

-            def _get_parser(self, tester):

-                parser = argparse.ArgumentParser(

-                    *tester.parser_signature.args,

-                    **tester.parser_signature.kwargs)

-                for argument_sig in tester.argument_signatures:

-                    parser.add_argument(*argument_sig.args,

-                                        **argument_sig.kwargs)

-                group_signatures = tester.argument_group_signatures

-                for group_sig, argument_sigs in group_signatures:

-                    group = parser.add_argument_group(*group_sig.args,

-                                                      **group_sig.kwargs)

-                    for argument_sig in argument_sigs:

-                        group.add_argument(*argument_sig.args,

-                                           **argument_sig.kwargs)

-                return parser

-

-            def _test(self, tester, parser_text):

-                expected_text = getattr(tester, self.func_suffix)

-                expected_text = textwrap.dedent(expected_text)

-                if expected_text != parser_text:

-                    print(repr(expected_text))

-                    print(repr(parser_text))

-                    for char1, char2 in zip(expected_text, parser_text):

-                        if char1 != char2:

-                            print('first diff: %r %r' % (char1, char2))

-                            break

-                tester.assertEqual(expected_text, parser_text)

-

-            def test_format(self, tester):

-                parser = self._get_parser(tester)

-                format = getattr(parser, 'format_%s' % self.func_suffix)

-                self._test(tester, format())

-

-            def test_print(self, tester):

-                parser = self._get_parser(tester)

-                print_ = getattr(parser, 'print_%s' % self.func_suffix)

-                old_stream = getattr(sys, self.std_name)

-                setattr(sys, self.std_name, StringIO())

-                try:

-                    print_()

-                    parser_text = getattr(sys, self.std_name).getvalue()

-                finally:

-                    setattr(sys, self.std_name, old_stream)

-                self._test(tester, parser_text)

-

-            def test_print_file(self, tester):

-                parser = self._get_parser(tester)

-                print_ = getattr(parser, 'print_%s' % self.func_suffix)

-                sfile = StringIO()

-                print_(sfile)

-                parser_text = sfile.getvalue()

-                self._test(tester, parser_text)

-

-        # add tests for {format,print}_{usage,help,version}

-        for func_suffix, std_name in [('usage', 'stdout'),

-                                      ('help', 'stdout'),

-                                      ('version', 'stderr')]:

-            AddTests(cls, func_suffix, std_name)

-

-bases = TestCase,

-HelpTestCase = TestHelpFormattingMetaclass('HelpTestCase', bases, {})

-

-

-class TestHelpBiggerOptionals(HelpTestCase):

-    """Make sure that argument help aligns when options are longer"""

-

-    parser_signature = Sig(prog='PROG', description='DESCRIPTION',

-                           epilog='EPILOG', version='0.1')

-    argument_signatures = [

-        Sig('-x', action='store_true', help='X HELP'),

-        Sig('--y', help='Y HELP'),

-        Sig('foo', help='FOO HELP'),

-        Sig('bar', help='BAR HELP'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-v] [-x] [--y Y] foo bar

-        '''

-    help = usage + '''\

-

-        DESCRIPTION

-

-        positional arguments:

-          foo            FOO HELP

-          bar            BAR HELP

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -v, --version  show program's version number and exit

-          -x             X HELP

-          --y Y          Y HELP

-

-        EPILOG

-    '''

-    version = '''\

-        0.1

-        '''

-

-

-class TestHelpBiggerOptionalGroups(HelpTestCase):

-    """Make sure that argument help aligns when options are longer"""

-

-    parser_signature = Sig(prog='PROG', description='DESCRIPTION',

-                           epilog='EPILOG', version='0.1')

-    argument_signatures = [

-        Sig('-x', action='store_true', help='X HELP'),

-        Sig('--y', help='Y HELP'),

-        Sig('foo', help='FOO HELP'),

-        Sig('bar', help='BAR HELP'),

-    ]

-    argument_group_signatures = [

-        (Sig('GROUP TITLE', description='GROUP DESCRIPTION'), [

-            Sig('baz', help='BAZ HELP'),

-            Sig('-z', nargs='+', help='Z HELP')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [-v] [-x] [--y Y] [-z Z [Z ...]] foo bar baz

-        '''

-    help = usage + '''\

-

-        DESCRIPTION

-

-        positional arguments:

-          foo            FOO HELP

-          bar            BAR HELP

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -v, --version  show program's version number and exit

-          -x             X HELP

-          --y Y          Y HELP

-

-        GROUP TITLE:

-          GROUP DESCRIPTION

-

-          baz            BAZ HELP

-          -z Z [Z ...]   Z HELP

-

-        EPILOG

-    '''

-    version = '''\

-        0.1

-        '''

-

-

-class TestHelpBiggerPositionals(HelpTestCase):

-    """Make sure that help aligns when arguments are longer"""

-

-    parser_signature = Sig(usage='USAGE', description='DESCRIPTION')

-    argument_signatures = [

-        Sig('-x', action='store_true', help='X HELP'),

-        Sig('--y', help='Y HELP'),

-        Sig('ekiekiekifekang', help='EKI HELP'),

-        Sig('bar', help='BAR HELP'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: USAGE

-        '''

-    help = usage + '''\

-

-        DESCRIPTION

-

-        positional arguments:

-          ekiekiekifekang  EKI HELP

-          bar              BAR HELP

-

-        optional arguments:

-          -h, --help       show this help message and exit

-          -x               X HELP

-          --y Y            Y HELP

-        '''

-

-    version = ''

-

-

-class TestHelpReformatting(HelpTestCase):

-    """Make sure that text after short names starts on the first line"""

-

-    parser_signature = Sig(

-        prog='PROG',

-        description='   oddly    formatted\n'

-                    'description\n'

-                    '\n'

-                    'that is so long that it should go onto multiple '

-                    'lines when wrapped')

-    argument_signatures = [

-        Sig('-x', metavar='XX', help='oddly\n'

-                                     '    formatted -x help'),

-        Sig('y', metavar='yyy', help='normal y help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='\n'

-                                  '    oddly formatted group\n'

-                                  '\n'

-                                  'description'),

-         [Sig('-a', action='store_true',

-              help=' oddly \n'

-                   'formatted    -a  help  \n'

-                   '    again, so long that it should be wrapped over '

-                   'multiple lines')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [-x XX] [-a] yyy

-        '''

-    help = usage + '''\

-

-        oddly formatted description that is so long that it should go onto \

-multiple

-        lines when wrapped

-

-        positional arguments:

-          yyy         normal y help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -x XX       oddly formatted -x help

-

-        title:

-          oddly formatted group description

-

-          -a          oddly formatted -a help again, so long that it should \

-be wrapped

-                      over multiple lines

-        '''

-    version = ''

-

-

-class TestHelpWrappingShortNames(HelpTestCase):

-    """Make sure that text after short names starts on the first line"""

-

-    parser_signature = Sig(prog='PROG', description= 'D\nD' * 30)

-    argument_signatures = [

-        Sig('-x', metavar='XX', help='XHH HX' * 20),

-        Sig('y', metavar='yyy', help='YH YH' * 20),

-    ]

-    argument_group_signatures = [

-        (Sig('ALPHAS'), [

-            Sig('-a', action='store_true', help='AHHH HHA' * 10)]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [-x XX] [-a] yyy

-        '''

-    help = usage + '''\

-

-        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \

-DD DD DD

-        DD DD DD DD D

-

-        positional arguments:

-          yyy         YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \

-YHYH YHYH

-                      YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -x XX       XHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH \

-HXXHH HXXHH

-                      HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HX

-

-        ALPHAS:

-          -a          AHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH \

-HHAAHHH

-                      HHAAHHH HHAAHHH HHA

-        '''

-    version = ''

-

-

-class TestHelpWrappingLongNames(HelpTestCase):

-    """Make sure that text after long names starts on the next line"""

-

-    parser_signature = Sig(usage='USAGE', description= 'D D' * 30,

-                           version='V V'*30)

-    argument_signatures = [

-        Sig('-x', metavar='X' * 25, help='XH XH' * 20),

-        Sig('y', metavar='y' * 25, help='YH YH' * 20),

-    ]

-    argument_group_signatures = [

-        (Sig('ALPHAS'), [

-            Sig('-a', metavar='A' * 25, help='AH AH' * 20),

-            Sig('z', metavar='z' * 25, help='ZH ZH' * 20)]),

-    ]

-    usage = '''\

-        usage: USAGE

-        '''

-    help = usage + '''\

-

-        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \

-DD DD DD

-        DD DD DD DD D

-

-        positional arguments:

-          yyyyyyyyyyyyyyyyyyyyyyyyy

-                                YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \

-YHYH YHYH

-                                YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -v, --version         show program's version number and exit

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-                                XH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH \

-XHXH XHXH

-                                XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XH

-

-        ALPHAS:

-          -a AAAAAAAAAAAAAAAAAAAAAAAAA

-                                AH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH \

-AHAH AHAH

-                                AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AH

-          zzzzzzzzzzzzzzzzzzzzzzzzz

-                                ZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH \

-ZHZH ZHZH

-                                ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZH

-        '''

-    version = '''\

-        V VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV \

-VV VV VV

-        VV VV VV VV V

-        '''

-

-

-class TestHelpUsage(HelpTestCase):

-    """Test basic usage messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-w', nargs='+', help='w'),

-        Sig('-x', nargs='*', help='x'),

-        Sig('a', help='a'),

-        Sig('b', help='b', nargs=2),

-        Sig('c', help='c', nargs='?'),

-    ]

-    argument_group_signatures = [

-        (Sig('group'), [

-            Sig('-y', nargs='?', help='y'),

-            Sig('-z', nargs=3, help='z'),

-            Sig('d', help='d', nargs='*'),

-            Sig('e', help='e', nargs='+'),

-        ])

-    ]

-    usage = '''\

-        usage: PROG [-h] [-w W [W ...]] [-x [X [X ...]]] [-y [Y]] [-z Z Z Z]

-                    a b b [c] [d [d ...]] e [e ...]

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a               a

-          b               b

-          c               c

-

-        optional arguments:

-          -h, --help      show this help message and exit

-          -w W [W ...]    w

-          -x [X [X ...]]  x

-

-        group:

-          -y [Y]          y

-          -z Z Z Z        z

-          d               d

-          e               e

-        '''

-    version = ''

-

-

-class TestHelpOnlyUserGroups(HelpTestCase):

-    """Test basic usage messages"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = []

-    argument_group_signatures = [

-        (Sig('xxxx'), [

-            Sig('-x', help='x'),

-            Sig('a', help='a'),

-        ]),

-        (Sig('yyyy'), [

-            Sig('b', help='b'),

-            Sig('-y', help='y'),

-        ]),

-    ]

-    usage = '''\

-        usage: PROG [-x X] [-y Y] a b

-        '''

-    help = usage + '''\

-

-        xxxx:

-          -x X  x

-          a     a

-

-        yyyy:

-          b     b

-          -y Y  y

-        '''

-    version = ''

-

-

-class TestHelpUsageLongProg(HelpTestCase):

-    """Test usage messages where the prog is long"""

-

-    parser_signature = Sig(prog='P' * 60)

-    argument_signatures = [

-        Sig('-w', metavar='W'),

-        Sig('-x', metavar='X'),

-        Sig('a'),

-        Sig('b'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

-               [-h] [-w W] [-x X] a b

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a

-          b

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          -w W

-          -x X

-        '''

-    version = ''

-

-

-class TestHelpUsageLongProgOptionsWrap(HelpTestCase):

-    """Test usage messages where the prog is long and the optionals wrap"""

-

-    parser_signature = Sig(prog='P' * 60)

-    argument_signatures = [

-        Sig('-w', metavar='W' * 25),

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-        Sig('a'),

-        Sig('b'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

-               [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \

-[-x XXXXXXXXXXXXXXXXXXXXXXXXX]

-               [-y YYYYYYYYYYYYYYYYYYYYYYYYY] [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-               a b

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a

-          b

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -w WWWWWWWWWWWWWWWWWWWWWWWWW

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsageLongProgPositionalsWrap(HelpTestCase):

-    """Test usage messages where the prog is long and the positionals wrap"""

-

-    parser_signature = Sig(prog='P' * 60, add_help=False)

-    argument_signatures = [

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP

-               aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-               ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-        '''

-    version = ''

-

-

-class TestHelpUsageOptionalsWrap(HelpTestCase):

-    """Test usage messages where the optionals wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-w', metavar='W' * 25),

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-        Sig('a'),

-        Sig('b'),

-        Sig('c'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \

-[-x XXXXXXXXXXXXXXXXXXXXXXXXX]

-                    [-y YYYYYYYYYYYYYYYYYYYYYYYYY] \

-[-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-                    a b c

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          a

-          b

-          c

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -w WWWWWWWWWWWWWWWWWWWWWWWWW

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsagePositionalsWrap(HelpTestCase):

-    """Test usage messages where the positionals wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x'),

-        Sig('-y'),

-        Sig('-z'),

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-x X] [-y Y] [-z Z]

-                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-                    ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -x X

-          -y Y

-          -z Z

-        '''

-    version = ''

-

-

-class TestHelpUsageOptionalsPositionalsWrap(HelpTestCase):

-    """Test usage messages where the optionals and positionals wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \

-[-y YYYYYYYYYYYYYYYYYYYYYYYYY]

-                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-                    ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsageOptionalsOnlyWrap(HelpTestCase):

-    """Test usage messages where there are only optionals and they wrap"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x', metavar='X' * 25),

-        Sig('-y', metavar='Y' * 25),

-        Sig('-z', metavar='Z' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \

-[-y YYYYYYYYYYYYYYYYYYYYYYYYY]

-                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help            show this help message and exit

-          -x XXXXXXXXXXXXXXXXXXXXXXXXX

-          -y YYYYYYYYYYYYYYYYYYYYYYYYY

-          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ

-        '''

-    version = ''

-

-

-class TestHelpUsagePositionalsOnlyWrap(HelpTestCase):

-    """Test usage messages where there are only positionals and they wrap"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = [

-        Sig('a' * 25),

-        Sig('b' * 25),

-        Sig('c' * 25),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb

-                    ccccccccccccccccccccccccc

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          aaaaaaaaaaaaaaaaaaaaaaaaa

-          bbbbbbbbbbbbbbbbbbbbbbbbb

-          ccccccccccccccccccccccccc

-        '''

-    version = ''

-

-

-class TestHelpVariableExpansion(HelpTestCase):

-    """Test that variables are expanded properly in help messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-x', type=int,

-            help='x %(prog)s %(default)s %(type)s %%'),

-        Sig('-y', action='store_const', default=42, const='XXX',

-            help='y %(prog)s %(default)s %(const)s'),

-        Sig('--foo', choices='abc',

-            help='foo %(prog)s %(default)s %(choices)s'),

-        Sig('--bar', default='baz', choices=[1, 2], metavar='BBB',

-            help='bar %(prog)s %(default)s %(dest)s'),

-        Sig('spam', help='spam %(prog)s %(default)s'),

-        Sig('badger', default=0.5, help='badger %(prog)s %(default)s'),

-    ]

-    argument_group_signatures = [

-        (Sig('group'), [

-            Sig('-a', help='a %(prog)s %(default)s'),

-            Sig('-b', default=-1, help='b %(prog)s %(default)s'),

-        ])

-    ]

-    usage = ('''\

-        usage: PROG [-h] [-x X] [-y] [--foo {a,b,c}] [--bar BBB] [-a A] [-b B]

-                    spam badger

-        ''')

-    help = usage + '''\

-

-        positional arguments:

-          spam           spam PROG None

-          badger         badger PROG 0.5

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -x X           x PROG None int %

-          -y             y PROG 42 XXX

-          --foo {a,b,c}  foo PROG None a, b, c

-          --bar BBB      bar PROG baz bar

-

-        group:

-          -a A           a PROG None

-          -b B           b PROG -1

-        '''

-    version = ''

-

-

-class TestHelpVariableExpansionUsageSupplied(HelpTestCase):

-    """Test that variables are expanded properly when usage= is present"""

-

-    parser_signature = Sig(prog='PROG', usage='%(prog)s FOO')

-    argument_signatures = []

-    argument_group_signatures = []

-    usage = ('''\

-        usage: PROG FOO

-        ''')

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-        '''

-    version = ''

-

-

-class TestHelpVariableExpansionNoArguments(HelpTestCase):

-    """Test that variables are expanded properly with no arguments"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = []

-    argument_group_signatures = []

-    usage = ('''\

-        usage: PROG

-        ''')

-    help = usage

-    version = ''

-

-

-class TestHelpSuppressUsage(HelpTestCase):

-    """Test that items can be suppressed in usage messages"""

-

-    parser_signature = Sig(prog='PROG', usage=argparse.SUPPRESS)

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    help = '''\

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    usage = ''

-    version = ''

-

-

-class TestHelpSuppressOptional(HelpTestCase):

-    """Test that optional arguments can be suppressed in help messages"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = [

-        Sig('--foo', help=argparse.SUPPRESS),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam  spam help

-        '''

-    version = ''

-

-

-class TestHelpSuppressOptionalGroup(HelpTestCase):

-    """Test that optional groups can be suppressed in help messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = [

-        (Sig('group'), [Sig('--bar', help=argparse.SUPPRESS)]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    version = ''

-

-

-class TestHelpSuppressPositional(HelpTestCase):

-    """Test that positional arguments can be suppressed in help messages"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help=argparse.SUPPRESS),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [--foo FOO]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    version = ''

-

-

-class TestHelpRequiredOptional(HelpTestCase):

-    """Test that required options don't look optional"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo', required=True, help='foo help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] --foo FOO

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help

-        '''

-    version = ''

-

-

-class TestHelpAlternatePrefixChars(HelpTestCase):

-    """Test that options display with different prefix characters"""

-

-    parser_signature = Sig(prog='PROG', prefix_chars='^;', add_help=False)

-    argument_signatures = [

-        Sig('^^foo', action='store_true', help='foo help'),

-        Sig(';b', ';;bar', help='bar help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [^^foo] [;b BAR]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          ^^foo              foo help

-          ;b BAR, ;;bar BAR  bar help

-        '''

-    version = ''

-

-

-class TestHelpNoHelpOptional(HelpTestCase):

-    """Test that the --help argument can be suppressed help messages"""

-

-    parser_signature = Sig(prog='PROG', add_help=False)

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam       spam help

-

-        optional arguments:

-          --foo FOO  foo help

-        '''

-    version = ''

-

-

-class TestHelpVersionOptional(HelpTestCase):

-    """Test that the --version argument can be suppressed help messages"""

-

-    parser_signature = Sig(prog='PROG', version='1.0')

-    argument_signatures = [

-        Sig('--foo', help='foo help'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-v] [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam           spam help

-

-        optional arguments:

-          -h, --help     show this help message and exit

-          -v, --version  show program's version number and exit

-          --foo FOO      foo help

-        '''

-    version = '''\

-        1.0

-        '''

-

-

-class TestHelpNone(HelpTestCase):

-    """Test that no errors occur if no help is specified"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('--foo'),

-        Sig('spam'),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] spam

-        '''

-    help = usage + '''\

-

-        positional arguments:

-          spam

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO

-        '''

-    version = ''

-

-

-class TestHelpTupleMetavar(HelpTestCase):

-    """Test specifying metavar as a tuple"""

-

-    parser_signature = Sig(prog='PROG')

-    argument_signatures = [

-        Sig('-w', help='w', nargs='+', metavar=('W1', 'W2')),

-        Sig('-x', help='x', nargs='*', metavar=('X1', 'X2')),

-        Sig('-y', help='y', nargs=3, metavar=('Y1', 'Y2', 'Y3')),

-        Sig('-z', help='z', nargs='?', metavar=('Z1', )),

-    ]

-    argument_group_signatures = []

-    usage = '''\

-        usage: PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] \

-[-z [Z1]]

-        '''

-    help = usage + '''\

-

-        optional arguments:

-          -h, --help        show this help message and exit

-          -w W1 [W2 ...]    w

-          -x [X1 [X2 ...]]  x

-          -y Y1 Y2 Y3       y

-          -z [Z1]           z

-        '''

-    version = ''

-

-

-class TestHelpRawText(HelpTestCase):

-    """Test the RawTextHelpFormatter"""

-

-    parser_signature = Sig(

-        prog='PROG', formatter_class=argparse.RawTextHelpFormatter,

-        description='Keep the formatting\n'

-                    '    exactly as it is written\n'

-                    '\n'

-                    'here\n')

-

-    argument_signatures = [

-        Sig('--foo', help='    foo help should also\n'

-                          'appear as given here'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='    This text\n'

-                                  '  should be indented\n'

-                                  '    exactly like it is here\n'),

-         [Sig('--bar', help='bar help')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] [--bar BAR] spam

-        '''

-    help = usage + '''\

-

-        Keep the formatting

-            exactly as it is written

-

-        here

-

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO       foo help should also

-                      appear as given here

-

-        title:

-              This text

-            should be indented

-              exactly like it is here

-

-          --bar BAR   bar help

-        '''

-    version = ''

-

-

-class TestHelpRawDescription(HelpTestCase):

-    """Test the RawTextHelpFormatter"""

-

-    parser_signature = Sig(

-        prog='PROG', formatter_class=argparse.RawDescriptionHelpFormatter,

-        description='Keep the formatting\n'

-                    '    exactly as it is written\n'

-                    '\n'

-                    'here\n')

-

-    argument_signatures = [

-        Sig('--foo', help='  foo help should not\n'

-                          '    retain this odd formatting'),

-        Sig('spam', help='spam help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='    This text\n'

-                                  '  should be indented\n'

-                                  '    exactly like it is here\n'),

-         [Sig('--bar', help='bar help')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] [--bar BAR] spam

-        '''

-    help = usage + '''\

-

-        Keep the formatting

-            exactly as it is written

-

-        here

-

-        positional arguments:

-          spam        spam help

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help should not retain this odd formatting

-

-        title:

-              This text

-            should be indented

-              exactly like it is here

-

-          --bar BAR   bar help

-        '''

-    version = ''

-

-

-class TestHelpArgumentDefaults(HelpTestCase):

-    """Test the ArgumentDefaultsHelpFormatter"""

-

-    parser_signature = Sig(

-        prog='PROG', formatter_class=argparse.ArgumentDefaultsHelpFormatter,

-        description='description')

-

-    argument_signatures = [

-        Sig('--foo', help='foo help - oh and by the way, %(default)s'),

-        Sig('--bar', action='store_true', help='bar help'),

-        Sig('spam', help='spam help'),

-        Sig('badger', nargs='?', default='wooden', help='badger help'),

-    ]

-    argument_group_signatures = [

-        (Sig('title', description='description'),

-         [Sig('--baz', type=int, default=42, help='baz help')]),

-    ]

-    usage = '''\

-        usage: PROG [-h] [--foo FOO] [--bar] [--baz BAZ] spam [badger]

-        '''

-    help = usage + '''\

-

-        description

-

-        positional arguments:

-          spam        spam help

-          badger      badger help (default: wooden)

-

-        optional arguments:

-          -h, --help  show this help message and exit

-          --foo FOO   foo help - oh and by the way, None

-          --bar       bar help (default: False)

-

-        title:

-          description

-

-          --baz BAZ   baz help (default: 42)

-        '''

-    version = ''

-

-# =====================================

-# Optional/Positional constructor tests

-# =====================================

-

-class TestInvalidArgumentConstructors(TestCase):

-    """Test a bunch of invalid Argument constructors"""

-

-    def assertTypeError(self, *args, **kwargs):

-        parser = argparse.ArgumentParser()

-        self.assertRaises(TypeError, parser.add_argument,

-                          *args, **kwargs)

-

-    def assertValueError(self, *args, **kwargs):

-        parser = argparse.ArgumentParser()

-        self.assertRaises(ValueError, parser.add_argument,

-                          *args, **kwargs)

-

-    def test_invalid_keyword_arguments(self):

-        self.assertTypeError('-x', bar=None)

-        self.assertTypeError('-y', callback='foo')

-        self.assertTypeError('-y', callback_args=())

-        self.assertTypeError('-y', callback_kwargs={})

-

-    def test_missing_destination(self):

-        self.assertTypeError()

-        for action in ['append', 'store']:

-            self.assertTypeError(action=action)

-

-    def test_invalid_option_strings(self):

-        self.assertValueError('--')

-        self.assertValueError('---')

-

-    def test_invalid_type(self):

-        self.assertValueError('--foo', type='int')

-

-    def test_invalid_action(self):

-        self.assertValueError('-x', action='foo')

-        self.assertValueError('foo', action='baz')

-        parser = argparse.ArgumentParser()

-        try:

-            parser.add_argument("--foo", action="store-true")

-        except ValueError:

-            e = sys.exc_info()[1]

-            expected = 'unknown action'

-            msg = 'expected %r, found %r' % (expected, e)

-            self.assertTrue(expected in str(e), msg)

-

-    def test_multiple_dest(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument(dest='foo')

-        try:

-            parser.add_argument('bar', dest='baz')

-        except ValueError:

-            e = sys.exc_info()[1]

-            expected = 'dest supplied twice for positional argument'

-            msg = 'expected %r, found %r' % (expected, e)

-            self.assertTrue(expected in str(e), msg)

-

-    def test_no_argument_actions(self):

-        for action in ['store_const', 'store_true', 'store_false',

-                       'append_const', 'count']:

-            for attrs in [dict(type=int), dict(nargs='+'),

-                          dict(choices='ab')]:

-                self.assertTypeError('-x', action=action, **attrs)

-

-    def test_no_argument_no_const_actions(self):

-        # options with zero arguments

-        for action in ['store_true', 'store_false', 'count']:

-

-            # const is always disallowed

-            self.assertTypeError('-x', const='foo', action=action)

-

-            # nargs is always disallowed

-            self.assertTypeError('-x', nargs='*', action=action)

-

-    def test_more_than_one_argument_actions(self):

-        for action in ['store', 'append']:

-

-            # nargs=0 is disallowed

-            self.assertValueError('-x', nargs=0, action=action)

-            self.assertValueError('spam', nargs=0, action=action)

-

-            # const is disallowed with non-optional arguments

-            for nargs in [1, '*', '+']:

-                self.assertValueError('-x', const='foo',

-                                      nargs=nargs, action=action)

-                self.assertValueError('spam', const='foo',

-                                      nargs=nargs, action=action)

-

-    def test_required_const_actions(self):

-        for action in ['store_const', 'append_const']:

-

-            # nargs is always disallowed

-            self.assertTypeError('-x', nargs='+', action=action)

-

-    def test_parsers_action_missing_params(self):

-        self.assertTypeError('command', action='parsers')

-        self.assertTypeError('command', action='parsers', prog='PROG')

-        self.assertTypeError('command', action='parsers',

-                             parser_class=argparse.ArgumentParser)

-

-    def test_required_positional(self):

-        self.assertTypeError('foo', required=True)

-

-    def test_user_defined_action(self):

-

-        class Success(Exception):

-            pass

-

-        class Action(object):

-

-            def __init__(self,

-                         option_strings,

-                         dest,

-                         const,

-                         default,

-                         required=False):

-                if dest == 'spam':

-                    if const is Success:

-                        if default is Success:

-                            raise Success()

-

-            def __call__(self, *args, **kwargs):

-                pass

-

-        parser = argparse.ArgumentParser()

-        self.assertRaises(Success, parser.add_argument, '--spam',

-                          action=Action, default=Success, const=Success)

-        self.assertRaises(Success, parser.add_argument, 'spam',

-                          action=Action, default=Success, const=Success)

-

-# ================================

-# Actions returned by add_argument

-# ================================

-

-class TestActionsReturned(TestCase):

-

-    def test_dest(self):

-        parser = argparse.ArgumentParser()

-        action = parser.add_argument('--foo')

-        self.assertEqual(action.dest, 'foo')

-        action = parser.add_argument('-b', '--bar')

-        self.assertEqual(action.dest, 'bar')

-        action = parser.add_argument('-x', '-y')

-        self.assertEqual(action.dest, 'x')

-

-    def test_misc(self):

-        parser = argparse.ArgumentParser()

-        action = parser.add_argument('--foo', nargs='?', const=42,

-                                     default=84, type=int, choices=[1, 2],

-                                     help='FOO', metavar='BAR', dest='baz')

-        self.assertEqual(action.nargs, '?')

-        self.assertEqual(action.const, 42)

-        self.assertEqual(action.default, 84)

-        self.assertEqual(action.type, int)

-        self.assertEqual(action.choices, [1, 2])

-        self.assertEqual(action.help, 'FOO')

-        self.assertEqual(action.metavar, 'BAR')

-        self.assertEqual(action.dest, 'baz')

-

-

-# ================================

-# Argument conflict handling tests

-# ================================

-

-class TestConflictHandling(TestCase):

-

-    def test_bad_type(self):

-        self.assertRaises(ValueError, argparse.ArgumentParser,

-                          conflict_handler='foo')

-

-    def test_conflict_error(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument('-x')

-        self.assertRaises(argparse.ArgumentError,

-                          parser.add_argument, '-x')

-        parser.add_argument('--spam')

-        self.assertRaises(argparse.ArgumentError,

-                          parser.add_argument, '--spam')

-

-    def test_resolve_error(self):

-        get_parser = argparse.ArgumentParser

-        parser = get_parser(prog='PROG', conflict_handler='resolve')

-

-        parser.add_argument('-x', help='OLD X')

-        parser.add_argument('-x', help='NEW X')

-        self.assertEqual(parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [-x X]

-

-            optional arguments:

-              -h, --help  show this help message and exit

-              -x X        NEW X

-            '''))

-

-        parser.add_argument('--spam', metavar='OLD_SPAM')

-        parser.add_argument('--spam', metavar='NEW_SPAM')

-        self.assertEqual(parser.format_help(), textwrap.dedent('''\

-            usage: PROG [-h] [-x X] [--spam NEW_SPAM]

-

-            optional arguments:

-              -h, --help       show this help message and exit

-              -x X             NEW X

-              --spam NEW_SPAM

-            '''))

-

-

-# =============================

-# Help and Version option tests

-# =============================

-

-class TestOptionalsHelpVersionActions(TestCase):

-    """Test the help and version actions"""

-

-    def _get_error(self, func, *args, **kwargs):

-        try:

-            func(*args, **kwargs)

-        except ArgumentParserError:

-            return sys.exc_info()[1]

-        else:

-            self.assertRaises(ArgumentParserError, func, *args, **kwargs)

-

-    def assertPrintHelpExit(self, parser, args_str):

-        self.assertEqual(

-            parser.format_help(),

-            self._get_error(parser.parse_args, args_str.split()).stdout)

-

-    def assertPrintVersionExit(self, parser, args_str):

-        self.assertEqual(

-            parser.format_version(),

-            self._get_error(parser.parse_args, args_str.split()).stderr)

-

-    def assertArgumentParserError(self, parser, *args):

-        self.assertRaises(ArgumentParserError, parser.parse_args, args)

-

-    def test_version(self):

-        parser = ErrorRaisingArgumentParser(version='1.0')

-        self.assertPrintHelpExit(parser, '-h')

-        self.assertPrintHelpExit(parser, '--help')

-        self.assertPrintVersionExit(parser, '-v')

-        self.assertPrintVersionExit(parser, '--version')

-

-    def test_version_format(self):

-        parser = ErrorRaisingArgumentParser(prog='PPP', version='%(prog)s 3.5')

-        msg = self._get_error(parser.parse_args, ['-v']).stderr

-        self.assertEqual('PPP 3.5\n', msg)

-

-    def test_version_no_help(self):

-        parser = ErrorRaisingArgumentParser(add_help=False, version='1.0')

-        self.assertArgumentParserError(parser, '-h')

-        self.assertArgumentParserError(parser, '--help')

-        self.assertPrintVersionExit(parser, '-v')

-        self.assertPrintVersionExit(parser, '--version')

-

-    def test_version_action(self):

-        parser = ErrorRaisingArgumentParser(prog='XXX')

-        parser.add_argument('-V', action='version', version='%(prog)s 3.7')

-        msg = self._get_error(parser.parse_args, ['-V']).stderr

-        self.assertEqual('XXX 3.7\n', msg)

-

-    def test_no_help(self):

-        parser = ErrorRaisingArgumentParser(add_help=False)

-        self.assertArgumentParserError(parser, '-h')

-        self.assertArgumentParserError(parser, '--help')

-        self.assertArgumentParserError(parser, '-v')

-        self.assertArgumentParserError(parser, '--version')

-

-    def test_alternate_help_version(self):

-        parser = ErrorRaisingArgumentParser()

-        parser.add_argument('-x', action='help')

-        parser.add_argument('-y', action='version')

-        self.assertPrintHelpExit(parser, '-x')

-        self.assertPrintVersionExit(parser, '-y')

-        self.assertArgumentParserError(parser, '-v')

-        self.assertArgumentParserError(parser, '--version')

-

-    def test_help_version_extra_arguments(self):

-        parser = ErrorRaisingArgumentParser(version='1.0')

-        parser.add_argument('-x', action='store_true')

-        parser.add_argument('y')

-

-        # try all combinations of valid prefixes and suffixes

-        valid_prefixes = ['', '-x', 'foo', '-x bar', 'baz -x']

-        valid_suffixes = valid_prefixes + ['--bad-option', 'foo bar baz']

-        for prefix in valid_prefixes:

-            for suffix in valid_suffixes:

-                format = '%s %%s %s' % (prefix, suffix)

-            self.assertPrintHelpExit(parser, format % '-h')

-            self.assertPrintHelpExit(parser, format % '--help')

-            self.assertPrintVersionExit(parser, format % '-v')

-            self.assertPrintVersionExit(parser, format % '--version')

-

-

-# ======================

-# str() and repr() tests

-# ======================

-

-class TestStrings(TestCase):

-    """Test str()  and repr() on Optionals and Positionals"""

-

-    def assertStringEqual(self, obj, result_string):

-        for func in [str, repr]:

-            self.assertEqual(func(obj), result_string)

-

-    def test_optional(self):

-        option = argparse.Action(

-            option_strings=['--foo', '-a', '-b'],

-            dest='b',

-            type='int',

-            nargs='+',

-            default=42,

-            choices=[1, 2, 3],

-            help='HELP',

-            metavar='METAVAR')

-        string = (

-            "Action(option_strings=['--foo', '-a', '-b'], dest='b', "

-            "nargs='+', const=None, default=42, type='int', "

-            "choices=[1, 2, 3], help='HELP', metavar='METAVAR')")

-        self.assertStringEqual(option, string)

-

-    def test_argument(self):

-        argument = argparse.Action(

-            option_strings=[],

-            dest='x',

-            type=float,

-            nargs='?',

-            default=2.5,

-            choices=[0.5, 1.5, 2.5],

-            help='H HH H',

-            metavar='MV MV MV')

-        string = (

-            "Action(option_strings=[], dest='x', nargs='?', "

-            "const=None, default=2.5, type=%r, choices=[0.5, 1.5, 2.5], "

-            "help='H HH H', metavar='MV MV MV')" % float)

-        self.assertStringEqual(argument, string)

-

-    def test_namespace(self):

-        ns = argparse.Namespace(foo=42, bar='spam')

-        string = "Namespace(bar='spam', foo=42)"

-        self.assertStringEqual(ns, string)

-

-    def test_parser(self):

-        parser = argparse.ArgumentParser(prog='PROG')

-        string = (

-            "ArgumentParser(prog='PROG', usage=None, description=None, "

-            "version=None, formatter_class=%r, conflict_handler='error', "

-            "add_help=True)" % argparse.HelpFormatter)

-        self.assertStringEqual(parser, string)

-

-# ===============

-# Namespace tests

-# ===============

-

-class TestNamespace(TestCase):

-

-    def test_constructor(self):

-        ns = argparse.Namespace()

-        self.assertRaises(AttributeError, getattr, ns, 'x')

-

-        ns = argparse.Namespace(a=42, b='spam')

-        self.assertEqual(ns.a, 42)

-        self.assertEqual(ns.b, 'spam')

-

-    def test_equality(self):

-        ns1 = argparse.Namespace(a=1, b=2)

-        ns2 = argparse.Namespace(b=2, a=1)

-        ns3 = argparse.Namespace(a=1)

-        ns4 = argparse.Namespace(b=2)

-

-        self.assertEqual(ns1, ns2)

-        self.assertNotEqual(ns1, ns3)

-        self.assertNotEqual(ns1, ns4)

-        self.assertNotEqual(ns2, ns3)

-        self.assertNotEqual(ns2, ns4)

-        self.assertTrue(ns1 != ns3)

-        self.assertTrue(ns1 != ns4)

-        self.assertTrue(ns2 != ns3)

-        self.assertTrue(ns2 != ns4)

-

-

-# ===================

-# File encoding tests

-# ===================

-

-class TestEncoding(TestCase):

-

-    def _test_module_encoding(self, path):

-        path, _ = os.path.splitext(path)

-        path += ".py"

-        codecs.open(path, 'r', 'utf8').read()

-

-    def test_argparse_module_encoding(self):

-        self._test_module_encoding(argparse.__file__)

-

-    def test_test_argparse_module_encoding(self):

-        self._test_module_encoding(__file__)

-

-# ===================

-# ArgumentError tests

-# ===================

-

-class TestArgumentError(TestCase):

-

-    def test_argument_error(self):

-        msg = "my error here"

-        error = argparse.ArgumentError(None, msg)

-        self.assertEqual(str(error), msg)

-

-# =======================

-# ArgumentTypeError tests

-# =======================

-

-class TestArgumentError(TestCase):

-

-    def test_argument_type_error(self):

-

-        def spam(string):

-            raise argparse.ArgumentTypeError('spam!')

-

-        parser = ErrorRaisingArgumentParser(prog='PROG', add_help=False)

-        parser.add_argument('x', type=spam)

-        try:

-            parser.parse_args(['XXX'])

-        except ArgumentParserError:

-            expected = 'usage: PROG x\nPROG: error: argument x: spam!\n'

-            msg = sys.exc_info()[1].stderr

-            self.assertEqual(expected, msg)

-        else:

-            self.fail()

-

-# ======================

-# parse_known_args tests

-# ======================

-

-class TestParseKnownArgs(TestCase):

-

-    def test_optionals(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument('--foo')

-        args, extras = parser.parse_known_args('--foo F --bar --baz'.split())

-        self.assertEqual(NS(foo='F'), args)

-        self.assertEqual(['--bar', '--baz'], extras)

-

-    def test_mixed(self):

-        parser = argparse.ArgumentParser()

-        parser.add_argument('-v', nargs='?', const=1, type=int)

-        parser.add_argument('--spam', action='store_false')

-        parser.add_argument('badger')

-

-        argv = ["B", "C", "--foo", "-v", "3", "4"]

-        args, extras = parser.parse_known_args(argv)

-        self.assertEqual(NS(v=3, spam=True, badger="B"), args)

-        self.assertEqual(["C", "--foo", "4"], extras)

-

-# ============================

-# from argparse import * tests

-# ============================

-

-class TestImportStar(TestCase):

-

-    def test(self):

-        for name in argparse.__all__:

-            self.assertTrue(hasattr(argparse, name))

-

-

-if __name__ == '__main__':

-    unittest.main()

+# Copyright 2006-2009 Steven J. Bethard <steven.bethard@gmail.com>.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy
+# of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+import codecs
+import os
+import shutil
+import sys
+import textwrap
+import tempfile
+import unittest
+import warnings
+import argparse
+
+from test import support
+
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+try:
+    set
+except NameError:
+    from sets import Set as set
+
+try:
+    sorted
+except NameError:
+
+    def sorted(iterable, reverse=False):
+        result = list(iterable)
+        result.sort()
+        if reverse:
+            result.reverse()
+        return result
+
+
+class TestCase(unittest.TestCase):
+
+    def assertEqual(self, obj1, obj2):
+        if obj1 != obj2:
+            print('')
+            print(repr(obj1))
+            print(repr(obj2))
+            print(obj1)
+            print(obj2)
+        super(TestCase, self).assertEqual(obj1, obj2)
+
+
+class TempDirMixin(object):
+
+    def setUp(self):
+        self.temp_dir = tempfile.mkdtemp()
+        self.old_dir = os.getcwd()
+        os.chdir(self.temp_dir)
+
+    def tearDown(self):
+        os.chdir(self.old_dir)
+        while True:
+            try:
+                shutil.rmtree(self.temp_dir)
+            except WindowsError:
+                continue
+            else:
+                break
+
+
+class Sig(object):
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+
+class NS(object):
+
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+    def __repr__(self):
+        sorted_items = sorted(self.__dict__.items())
+        kwarg_str = ', '.join(['%s=%r' % tup for tup in sorted_items])
+        return '%s(%s)' % (type(self).__name__, kwarg_str)
+
+    def __eq__(self, other):
+        return vars(self) == vars(other)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+
+class ArgumentParserError(Exception):
+
+    def __init__(self, message, stdout=None, stderr=None, error_code=None):
+        Exception.__init__(self, message, stdout, stderr)
+        self.message = message
+        self.stdout = stdout
+        self.stderr = stderr
+        self.error_code = error_code
+
+
+def stderr_to_parser_error(parse_args, *args, **kwargs):
+    # if this is being called recursively and stderr or stdout is already being
+    # redirected, simply call the function and let the enclosing function
+    # catch the exception
+    if isinstance(sys.stderr, StringIO) or isinstance(sys.stdout, StringIO):
+        return parse_args(*args, **kwargs)
+
+    # if this is not being called recursively, redirect stderr and
+    # use it as the ArgumentParserError message
+    old_stdout = sys.stdout
+    old_stderr = sys.stderr
+    sys.stdout = StringIO()
+    sys.stderr = StringIO()
+    try:
+        try:
+            result = parse_args(*args, **kwargs)
+            for key in list(vars(result)):
+                if getattr(result, key) is sys.stdout:
+                    setattr(result, key, old_stdout)
+                if getattr(result, key) is sys.stderr:
+                    setattr(result, key, old_stderr)
+            return result
+        except SystemExit:
+            code = sys.exc_info()[1].code
+            stdout = sys.stdout.getvalue()
+            stderr = sys.stderr.getvalue()
+            raise ArgumentParserError("SystemExit", stdout, stderr, code)
+    finally:
+        sys.stdout = old_stdout
+        sys.stderr = old_stderr
+
+
+class ErrorRaisingArgumentParser(argparse.ArgumentParser):
+
+    def parse_args(self, *args, **kwargs):
+        parse_args = super(ErrorRaisingArgumentParser, self).parse_args
+        return stderr_to_parser_error(parse_args, *args, **kwargs)
+
+    def exit(self, *args, **kwargs):
+        exit = super(ErrorRaisingArgumentParser, self).exit
+        return stderr_to_parser_error(exit, *args, **kwargs)
+
+    def error(self, *args, **kwargs):
+        error = super(ErrorRaisingArgumentParser, self).error
+        return stderr_to_parser_error(error, *args, **kwargs)
+
+
+class ParserTesterMetaclass(type):
+    """Adds parser tests using the class attributes.
+
+    Classes of this type should specify the following attributes:
+
+    argument_signatures -- a list of Sig objects which specify
+        the signatures of Argument objects to be created
+    failures -- a list of args lists that should cause the parser
+        to fail
+    successes -- a list of (initial_args, options, remaining_args) tuples
+        where initial_args specifies the string args to be parsed,
+        options is a dict that should match the vars() of the options
+        parsed out of initial_args, and remaining_args should be any
+        remaining unparsed arguments
+    """
+
+    def __init__(cls, name, bases, bodydict):
+        if name == 'ParserTestCase':
+            return
+
+        # default parser signature is empty
+        if not hasattr(cls, 'parser_signature'):
+            cls.parser_signature = Sig()
+        if not hasattr(cls, 'parser_class'):
+            cls.parser_class = ErrorRaisingArgumentParser
+
+        # ---------------------------------------
+        # functions for adding optional arguments
+        # ---------------------------------------
+        def no_groups(parser, argument_signatures):
+            """Add all arguments directly to the parser"""
+            for sig in argument_signatures:
+                parser.add_argument(*sig.args, **sig.kwargs)
+
+        def one_group(parser, argument_signatures):
+            """Add all arguments under a single group in the parser"""
+            group = parser.add_argument_group('foo')
+            for sig in argument_signatures:
+                group.add_argument(*sig.args, **sig.kwargs)
+
+        def many_groups(parser, argument_signatures):
+            """Add each argument in its own group to the parser"""
+            for i, sig in enumerate(argument_signatures):
+                group = parser.add_argument_group('foo:%i' % i)
+                group.add_argument(*sig.args, **sig.kwargs)
+
+        # --------------------------
+        # functions for parsing args
+        # --------------------------
+        def listargs(parser, args):
+            """Parse the args by passing in a list"""
+            return parser.parse_args(args)
+
+        def sysargs(parser, args):
+            """Parse the args by defaulting to sys.argv"""
+            old_sys_argv = sys.argv
+            sys.argv = [old_sys_argv[0]] + args
+            try:
+                return parser.parse_args()
+            finally:
+                sys.argv = old_sys_argv
+
+        # class that holds the combination of one optional argument
+        # addition method and one arg parsing method
+        class AddTests(object):
+
+            def __init__(self, tester_cls, add_arguments, parse_args):
+                self._add_arguments = add_arguments
+                self._parse_args = parse_args
+
+                add_arguments_name = self._add_arguments.__name__
+                parse_args_name = self._parse_args.__name__
+                for test_func in [self.test_failures, self.test_successes]:
+                    func_name = test_func.__name__
+                    names = func_name, add_arguments_name, parse_args_name
+                    test_name = '_'.join(names)
+
+                    def wrapper(self, test_func=test_func):
+                        test_func(self)
+                    try:
+                        wrapper.__name__ = test_name
+                    except TypeError:
+                        pass
+                    setattr(tester_cls, test_name, wrapper)
+
+            def _get_parser(self, tester):
+                args = tester.parser_signature.args
+                kwargs = tester.parser_signature.kwargs
+                parser = tester.parser_class(*args, **kwargs)
+                self._add_arguments(parser, tester.argument_signatures)
+                return parser
+
+            def test_failures(self, tester):
+                parser = self._get_parser(tester)
+                for args_str in tester.failures:
+                    args = args_str.split()
+                    raises = tester.assertRaises
+                    raises(ArgumentParserError, parser.parse_args, args)
+
+            def test_successes(self, tester):
+                parser = self._get_parser(tester)
+                for args, expected_ns in tester.successes:
+                    if isinstance(args, str):
+                        args = args.split()
+                    result_ns = self._parse_args(parser, args)
+                    tester.assertEqual(expected_ns, result_ns)
+
+        # add tests for each combination of an optionals adding method
+        # and an arg parsing method
+        for add_arguments in [no_groups, one_group, many_groups]:
+            for parse_args in [listargs, sysargs]:
+                AddTests(cls, add_arguments, parse_args)
+
+bases = TestCase,
+ParserTestCase = ParserTesterMetaclass('ParserTestCase', bases, {})
+
+# ===============
+# Optionals tests
+# ===============
+
+class TestOptionalsSingleDash(ParserTestCase):
+    """Test an Optional with a single-dash option string"""
+
+    argument_signatures = [Sig('-x')]
+    failures = ['-x', 'a', '--foo', '-x --foo', '-x -y']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a', NS(x='a')),
+        ('-xa', NS(x='a')),
+        ('-x -1', NS(x='-1')),
+        ('-x-1', NS(x='-1')),
+    ]
+
+
+class TestOptionalsSingleDashCombined(ParserTestCase):
+    """Test an Optional with a single-dash option string"""
+
+    argument_signatures = [
+        Sig('-x', action='store_true'),
+        Sig('-yyy', action='store_const', const=42),
+        Sig('-z'),
+    ]
+    failures = ['a', '--foo', '-xa', '-x --foo', '-x -z', '-z -x',
+                '-yx', '-yz a', '-yyyx', '-yyyza', '-xyza']
+    successes = [
+        ('', NS(x=False, yyy=None, z=None)),
+        ('-x', NS(x=True, yyy=None, z=None)),
+        ('-za', NS(x=False, yyy=None, z='a')),
+        ('-z a', NS(x=False, yyy=None, z='a')),
+        ('-xza', NS(x=True, yyy=None, z='a')),
+        ('-xz a', NS(x=True, yyy=None, z='a')),
+        ('-x -za', NS(x=True, yyy=None, z='a')),
+        ('-x -z a', NS(x=True, yyy=None, z='a')),
+        ('-y', NS(x=False, yyy=42, z=None)),
+        ('-yyy', NS(x=False, yyy=42, z=None)),
+        ('-x -yyy -za', NS(x=True, yyy=42, z='a')),
+        ('-x -yyy -z a', NS(x=True, yyy=42, z='a')),
+    ]
+
+
+class TestOptionalsSingleDashLong(ParserTestCase):
+    """Test an Optional with a multi-character single-dash option string"""
+
+    argument_signatures = [Sig('-foo')]
+    failures = ['-foo', 'a', '--foo', '-foo --foo', '-foo -y', '-fooa']
+    successes = [
+        ('', NS(foo=None)),
+        ('-foo a', NS(foo='a')),
+        ('-foo -1', NS(foo='-1')),
+        ('-fo a', NS(foo='a')),
+        ('-f a', NS(foo='a')),
+    ]
+
+
+class TestOptionalsSingleDashSubsetAmbiguous(ParserTestCase):
+    """Test Optionals where option strings are subsets of each other"""
+
+    argument_signatures = [Sig('-f'), Sig('-foobar'), Sig('-foorab')]
+    failures = ['-f', '-foo', '-fo', '-foo b', '-foob', '-fooba', '-foora']
+    successes = [
+        ('', NS(f=None, foobar=None, foorab=None)),
+        ('-f a', NS(f='a', foobar=None, foorab=None)),
+        ('-fa', NS(f='a', foobar=None, foorab=None)),
+        ('-foa', NS(f='oa', foobar=None, foorab=None)),
+        ('-fooa', NS(f='ooa', foobar=None, foorab=None)),
+        ('-foobar a', NS(f=None, foobar='a', foorab=None)),
+        ('-foorab a', NS(f=None, foobar=None, foorab='a')),
+    ]
+
+
+class TestOptionalsSingleDashAmbiguous(ParserTestCase):
+    """Test Optionals that partially match but are not subsets"""
+
+    argument_signatures = [Sig('-foobar'), Sig('-foorab')]
+    failures = ['-f', '-f a', '-fa', '-foa', '-foo', '-fo', '-foo b']
+    successes = [
+        ('', NS(foobar=None, foorab=None)),
+        ('-foob a', NS(foobar='a', foorab=None)),
+        ('-foor a', NS(foobar=None, foorab='a')),
+        ('-fooba a', NS(foobar='a', foorab=None)),
+        ('-foora a', NS(foobar=None, foorab='a')),
+        ('-foobar a', NS(foobar='a', foorab=None)),
+        ('-foorab a', NS(foobar=None, foorab='a')),
+    ]
+
+
+class TestOptionalsNumeric(ParserTestCase):
+    """Test an Optional with a short opt string"""
+
+    argument_signatures = [Sig('-1', dest='one')]
+    failures = ['-1', 'a', '-1 --foo', '-1 -y', '-1 -1', '-1 -2']
+    successes = [
+        ('', NS(one=None)),
+        ('-1 a', NS(one='a')),
+        ('-1a', NS(one='a')),
+        ('-1-2', NS(one='-2')),
+    ]
+
+
+class TestOptionalsDoubleDash(ParserTestCase):
+    """Test an Optional with a double-dash option string"""
+
+    argument_signatures = [Sig('--foo')]
+    failures = ['--foo', '-f', '-f a', 'a', '--foo -x', '--foo --bar']
+    successes = [
+        ('', NS(foo=None)),
+        ('--foo a', NS(foo='a')),
+        ('--foo=a', NS(foo='a')),
+        ('--foo -2.5', NS(foo='-2.5')),
+        ('--foo=-2.5', NS(foo='-2.5')),
+    ]
+
+
+class TestOptionalsDoubleDashPartialMatch(ParserTestCase):
+    """Tests partial matching with a double-dash option string"""
+
+    argument_signatures = [
+        Sig('--badger', action='store_true'),
+        Sig('--bat'),
+    ]
+    failures = ['--bar', '--b', '--ba', '--b=2', '--ba=4', '--badge 5']
+    successes = [
+        ('', NS(badger=False, bat=None)),
+        ('--bat X', NS(badger=False, bat='X')),
+        ('--bad', NS(badger=True, bat=None)),
+        ('--badg', NS(badger=True, bat=None)),
+        ('--badge', NS(badger=True, bat=None)),
+        ('--badger', NS(badger=True, bat=None)),
+    ]
+
+
+class TestOptionalsDoubleDashPrefixMatch(ParserTestCase):
+    """Tests when one double-dash option string is a prefix of another"""
+
+    argument_signatures = [
+        Sig('--badger', action='store_true'),
+        Sig('--ba'),
+    ]
+    failures = ['--bar', '--b', '--ba', '--b=2', '--badge 5']
+    successes = [
+        ('', NS(badger=False, ba=None)),
+        ('--ba X', NS(badger=False, ba='X')),
+        ('--ba=X', NS(badger=False, ba='X')),
+        ('--bad', NS(badger=True, ba=None)),
+        ('--badg', NS(badger=True, ba=None)),
+        ('--badge', NS(badger=True, ba=None)),
+        ('--badger', NS(badger=True, ba=None)),
+    ]
+
+
+class TestOptionalsSingleDoubleDash(ParserTestCase):
+    """Test an Optional with single- and double-dash option strings"""
+
+    argument_signatures = [
+        Sig('-f', action='store_true'),
+        Sig('--bar'),
+        Sig('-baz', action='store_const', const=42),
+    ]
+    failures = ['--bar', '-fbar', '-fbaz', '-bazf', '-b B', 'B']
+    successes = [
+        ('', NS(f=False, bar=None, baz=None)),
+        ('-f', NS(f=True, bar=None, baz=None)),
+        ('--ba B', NS(f=False, bar='B', baz=None)),
+        ('-f --bar B', NS(f=True, bar='B', baz=None)),
+        ('-f -b', NS(f=True, bar=None, baz=42)),
+        ('-ba -f', NS(f=True, bar=None, baz=42)),
+    ]
+
+
+class TestOptionalsAlternatePrefixChars(ParserTestCase):
+    """Test an Optional with a double-dash option string"""
+
+    parser_signature = Sig(prefix_chars='+:/', add_help=False)
+    argument_signatures = [
+        Sig('+f', action='store_true'),
+        Sig('::bar'),
+        Sig('/baz', action='store_const', const=42),
+    ]
+    failures = ['--bar', '-fbar', '-b B', 'B', '-f', '--bar B', '-baz']
+    successes = [
+        ('', NS(f=False, bar=None, baz=None)),
+        ('+f', NS(f=True, bar=None, baz=None)),
+        ('::ba B', NS(f=False, bar='B', baz=None)),
+        ('+f ::bar B', NS(f=True, bar='B', baz=None)),
+        ('+f /b', NS(f=True, bar=None, baz=42)),
+        ('/ba +f', NS(f=True, bar=None, baz=42)),
+    ]
+
+
+class TestOptionalsShortLong(ParserTestCase):
+    """Test a combination of single- and double-dash option strings"""
+
+    argument_signatures = [
+        Sig('-v', '--verbose', '-n', '--noisy', action='store_true'),
+    ]
+    failures = ['--x --verbose', '-N', 'a', '-v x']
+    successes = [
+        ('', NS(verbose=False)),
+        ('-v', NS(verbose=True)),
+        ('--verbose', NS(verbose=True)),
+        ('-n', NS(verbose=True)),
+        ('--noisy', NS(verbose=True)),
+    ]
+
+
+class TestOptionalsDest(ParserTestCase):
+    """Tests various means of setting destination"""
+
+    argument_signatures = [Sig('--foo-bar'), Sig('--baz', dest='zabbaz')]
+    failures = ['a']
+    successes = [
+        ('--foo-bar f', NS(foo_bar='f', zabbaz=None)),
+        ('--baz g', NS(foo_bar=None, zabbaz='g')),
+        ('--foo-bar h --baz i', NS(foo_bar='h', zabbaz='i')),
+        ('--baz j --foo-bar k', NS(foo_bar='k', zabbaz='j')),
+    ]
+
+
+class TestOptionalsDefault(ParserTestCase):
+    """Tests specifying a default for an Optional"""
+
+    argument_signatures = [Sig('-x'), Sig('-y', default=42)]
+    failures = ['a']
+    successes = [
+        ('', NS(x=None, y=42)),
+        ('-xx', NS(x='x', y=42)),
+        ('-yy', NS(x=None, y='y')),
+    ]
+
+
+class TestOptionalsNargsDefault(ParserTestCase):
+    """Tests not specifying the number of args for an Optional"""
+
+    argument_signatures = [Sig('-x')]
+    failures = ['a', '-x']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a', NS(x='a')),
+    ]
+
+
+class TestOptionalsNargs1(ParserTestCase):
+    """Tests specifying the 1 arg for an Optional"""
+
+    argument_signatures = [Sig('-x', nargs=1)]
+    failures = ['a', '-x']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a', NS(x=['a'])),
+    ]
+
+
+class TestOptionalsNargs3(ParserTestCase):
+    """Tests specifying the 3 args for an Optional"""
+
+    argument_signatures = [Sig('-x', nargs=3)]
+    failures = ['a', '-x', '-x a', '-x a b', 'a -x', 'a -x b']
+    successes = [
+        ('', NS(x=None)),
+        ('-x a b c', NS(x=['a', 'b', 'c'])),
+    ]
+
+
+class TestOptionalsNargsOptional(ParserTestCase):
+    """Tests specifying an Optional arg for an Optional"""
+
+    argument_signatures = [
+        Sig('-w', nargs='?'),
+        Sig('-x', nargs='?', const=42),
+        Sig('-y', nargs='?', default='spam'),
+        Sig('-z', nargs='?', type=int, const='42', default='84'),
+    ]
+    failures = ['2']
+    successes = [
+        ('', NS(w=None, x=None, y='spam', z=84)),
+        ('-w', NS(w=None, x=None, y='spam', z=84)),
+        ('-w 2', NS(w='2', x=None, y='spam', z=84)),
+        ('-x', NS(w=None, x=42, y='spam', z=84)),
+        ('-x 2', NS(w=None, x='2', y='spam', z=84)),
+        ('-y', NS(w=None, x=None, y=None, z=84)),
+        ('-y 2', NS(w=None, x=None, y='2', z=84)),
+        ('-z', NS(w=None, x=None, y='spam', z=42)),
+        ('-z 2', NS(w=None, x=None, y='spam', z=2)),
+    ]
+
+
+class TestOptionalsNargsZeroOrMore(ParserTestCase):
+    """Tests specifying an args for an Optional that accepts zero or more"""
+
+    argument_signatures = [
+        Sig('-x', nargs='*'),
+        Sig('-y', nargs='*', default='spam'),
+    ]
+    failures = ['a']
+    successes = [
+        ('', NS(x=None, y='spam')),
+        ('-x', NS(x=[], y='spam')),
+        ('-x a', NS(x=['a'], y='spam')),
+        ('-x a b', NS(x=['a', 'b'], y='spam')),
+        ('-y', NS(x=None, y=[])),
+        ('-y a', NS(x=None, y=['a'])),
+        ('-y a b', NS(x=None, y=['a', 'b'])),
+    ]
+
+
+class TestOptionalsNargsOneOrMore(ParserTestCase):
+    """Tests specifying an args for an Optional that accepts one or more"""
+
+    argument_signatures = [
+        Sig('-x', nargs='+'),
+        Sig('-y', nargs='+', default='spam'),
+    ]
+    failures = ['a', '-x', '-y', 'a -x', 'a -y b']
+    successes = [
+        ('', NS(x=None, y='spam')),
+        ('-x a', NS(x=['a'], y='spam')),
+        ('-x a b', NS(x=['a', 'b'], y='spam')),
+        ('-y a', NS(x=None, y=['a'])),
+        ('-y a b', NS(x=None, y=['a', 'b'])),
+    ]
+
+
+class TestOptionalsChoices(ParserTestCase):
+    """Tests specifying the choices for an Optional"""
+
+    argument_signatures = [
+        Sig('-f', choices='abc'),
+        Sig('-g', type=int, choices=range(5))]
+    failures = ['a', '-f d', '-fad', '-ga', '-g 6']
+    successes = [
+        ('', NS(f=None, g=None)),
+        ('-f a', NS(f='a', g=None)),
+        ('-f c', NS(f='c', g=None)),
+        ('-g 0', NS(f=None, g=0)),
+        ('-g 03', NS(f=None, g=3)),
+        ('-fb -g4', NS(f='b', g=4)),
+    ]
+
+
+class TestOptionalsRequired(ParserTestCase):
+    """Tests the an optional action that is required"""
+
+    argument_signatures = [
+        Sig('-x', type=int, required=True),
+    ]
+    failures = ['a', '']
+    successes = [
+        ('-x 1', NS(x=1)),
+        ('-x42', NS(x=42)),
+    ]
+
+
+class TestOptionalsActionStore(ParserTestCase):
+    """Tests the store action for an Optional"""
+
+    argument_signatures = [Sig('-x', action='store')]
+    failures = ['a', 'a -x']
+    successes = [
+        ('', NS(x=None)),
+        ('-xfoo', NS(x='foo')),
+    ]
+
+
+class TestOptionalsActionStoreConst(ParserTestCase):
+    """Tests the store_const action for an Optional"""
+
+    argument_signatures = [Sig('-y', action='store_const', const=object)]
+    failures = ['a']
+    successes = [
+        ('', NS(y=None)),
+        ('-y', NS(y=object)),
+    ]
+
+
+class TestOptionalsActionStoreFalse(ParserTestCase):
+    """Tests the store_false action for an Optional"""
+
+    argument_signatures = [Sig('-z', action='store_false')]
+    failures = ['a', '-za', '-z a']
+    successes = [
+        ('', NS(z=True)),
+        ('-z', NS(z=False)),
+    ]
+
+
+class TestOptionalsActionStoreTrue(ParserTestCase):
+    """Tests the store_true action for an Optional"""
+
+    argument_signatures = [Sig('--apple', action='store_true')]
+    failures = ['a', '--apple=b', '--apple b']
+    successes = [
+        ('', NS(apple=False)),
+        ('--apple', NS(apple=True)),
+    ]
+
+
+class TestOptionalsActionAppend(ParserTestCase):
+    """Tests the append action for an Optional"""
+
+    argument_signatures = [Sig('--baz', action='append')]
+    failures = ['a', '--baz', 'a --baz', '--baz a b']
+    successes = [
+        ('', NS(baz=None)),
+        ('--baz a', NS(baz=['a'])),
+        ('--baz a --baz b', NS(baz=['a', 'b'])),
+    ]
+
+
+class TestOptionalsActionAppendWithDefault(ParserTestCase):
+    """Tests the append action for an Optional"""
+
+    argument_signatures = [Sig('--baz', action='append', default=['X'])]
+    failures = ['a', '--baz', 'a --baz', '--baz a b']
+    successes = [
+        ('', NS(baz=['X'])),
+        ('--baz a', NS(baz=['X', 'a'])),
+        ('--baz a --baz b', NS(baz=['X', 'a', 'b'])),
+    ]
+
+
+class TestOptionalsActionAppendConst(ParserTestCase):
+    """Tests the append_const action for an Optional"""
+
+    argument_signatures = [
+        Sig('-b', action='append_const', const=Exception),
+        Sig('-c', action='append', dest='b'),
+    ]
+    failures = ['a', '-c', 'a -c', '-bx', '-b x']
+    successes = [
+        ('', NS(b=None)),
+        ('-b', NS(b=[Exception])),
+        ('-b -cx -b -cyz', NS(b=[Exception, 'x', Exception, 'yz'])),
+    ]
+
+
+class TestOptionalsActionAppendConstWithDefault(ParserTestCase):
+    """Tests the append_const action for an Optional"""
+
+    argument_signatures = [
+        Sig('-b', action='append_const', const=Exception, default=['X']),
+        Sig('-c', action='append', dest='b'),
+    ]
+    failures = ['a', '-c', 'a -c', '-bx', '-b x']
+    successes = [
+        ('', NS(b=['X'])),
+        ('-b', NS(b=['X', Exception])),
+        ('-b -cx -b -cyz', NS(b=['X', Exception, 'x', Exception, 'yz'])),
+    ]
+
+
+class TestOptionalsActionCount(ParserTestCase):
+    """Tests the count action for an Optional"""
+
+    argument_signatures = [Sig('-x', action='count')]
+    failures = ['a', '-x a', '-x b', '-x a -x b']
+    successes = [
+        ('', NS(x=None)),
+        ('-x', NS(x=1)),
+    ]
+
+
+# ================
+# Positional tests
+# ================
+
+class TestPositionalsNargsNone(ParserTestCase):
+    """Test a Positional that doesn't specify nargs"""
+
+    argument_signatures = [Sig('foo')]
+    failures = ['', '-x', 'a b']
+    successes = [
+        ('a', NS(foo='a')),
+    ]
+
+
+class TestPositionalsNargs1(ParserTestCase):
+    """Test a Positional that specifies an nargs of 1"""
+
+    argument_signatures = [Sig('foo', nargs=1)]
+    failures = ['', '-x', 'a b']
+    successes = [
+        ('a', NS(foo=['a'])),
+    ]
+
+
+class TestPositionalsNargs2(ParserTestCase):
+    """Test a Positional that specifies an nargs of 2"""
+
+    argument_signatures = [Sig('foo', nargs=2)]
+    failures = ['', 'a', '-x', 'a b c']
+    successes = [
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsZeroOrMore(ParserTestCase):
+    """Test a Positional that specifies unlimited nargs"""
+
+    argument_signatures = [Sig('foo', nargs='*')]
+    failures = ['-x']
+    successes = [
+        ('', NS(foo=[])),
+        ('a', NS(foo=['a'])),
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsZeroOrMoreDefault(ParserTestCase):
+    """Test a Positional that specifies unlimited nargs and a default"""
+
+    argument_signatures = [Sig('foo', nargs='*', default='bar')]
+    failures = ['-x']
+    successes = [
+        ('', NS(foo='bar')),
+        ('a', NS(foo=['a'])),
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsOneOrMore(ParserTestCase):
+    """Test a Positional that specifies one or more nargs"""
+
+    argument_signatures = [Sig('foo', nargs='+')]
+    failures = ['', '-x']
+    successes = [
+        ('a', NS(foo=['a'])),
+        ('a b', NS(foo=['a', 'b'])),
+    ]
+
+
+class TestPositionalsNargsOptional(ParserTestCase):
+    """Tests an Optional Positional"""
+
+    argument_signatures = [Sig('foo', nargs='?')]
+    failures = ['-x', 'a b']
+    successes = [
+        ('', NS(foo=None)),
+        ('a', NS(foo='a')),
+    ]
+
+
+class TestPositionalsNargsOptionalDefault(ParserTestCase):
+    """Tests an Optional Positional with a default value"""
+
+    argument_signatures = [Sig('foo', nargs='?', default=42)]
+    failures = ['-x', 'a b']
+    successes = [
+        ('', NS(foo=42)),
+        ('a', NS(foo='a')),
+    ]
+
+
+class TestPositionalsNargsOptionalConvertedDefault(ParserTestCase):
+    """Tests an Optional Positional with a default value
+    that needs to be converted to the appropriate type.
+    """
+
+    argument_signatures = [
+        Sig('foo', nargs='?', type=int, default='42'),
+    ]
+    failures = ['-x', 'a b', '1 2']
+    successes = [
+        ('', NS(foo=42)),
+        ('1', NS(foo=1)),
+    ]
+
+
+class TestPositionalsNargsNoneNone(ParserTestCase):
+    """Test two Positionals that don't specify nargs"""
+
+    argument_signatures = [Sig('foo'), Sig('bar')]
+    failures = ['', '-x', 'a', 'a b c']
+    successes = [
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargsNone1(ParserTestCase):
+    """Test a Positional with no nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', 'a', 'a b c']
+    successes = [
+        ('a b', NS(foo='a', bar=['b'])),
+    ]
+
+
+class TestPositionalsNargs2None(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar')]
+    failures = ['', '--foo', 'a', 'a b', 'a b c d']
+    successes = [
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsNoneZeroOrMore(ParserTestCase):
+    """Test a Positional with no nargs followed by one with unlimited"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs='*')]
+    failures = ['', '--foo']
+    successes = [
+        ('a', NS(foo='a', bar=[])),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsNargsNoneOneOrMore(ParserTestCase):
+    """Test a Positional with no nargs followed by one with one or more"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs='+')]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsNargsNoneOptional(ParserTestCase):
+    """Test a Positional with no nargs followed by one with an Optional"""
+
+    argument_signatures = [Sig('foo'), Sig('bar', nargs='?')]
+    failures = ['', '--foo', 'a b c']
+    successes = [
+        ('a', NS(foo='a', bar=None)),
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargsZeroOrMoreNone(ParserTestCase):
+    """Test a Positional with unlimited nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs='*'), Sig('bar')]
+    failures = ['', '--foo']
+    successes = [
+        ('a', NS(foo=[], bar='a')),
+        ('a b', NS(foo=['a'], bar='b')),
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsOneOrMoreNone(ParserTestCase):
+    """Test a Positional with one or more nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs='+'), Sig('bar')]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo=['a'], bar='b')),
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsOptionalNone(ParserTestCase):
+    """Test a Positional with an Optional nargs followed by one with none"""
+
+    argument_signatures = [Sig('foo', nargs='?', default=42), Sig('bar')]
+    failures = ['', '--foo', 'a b c']
+    successes = [
+        ('a', NS(foo=42, bar='a')),
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargs2ZeroOrMore(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one with unlimited"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='*')]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo=['a', 'b'], bar=[])),
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargs2OneOrMore(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one with one or more"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='+')]
+    failures = ['', '--foo', 'a', 'a b']
+    successes = [
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargs2Optional(ParserTestCase):
+    """Test a Positional with 2 nargs followed by one optional"""
+
+    argument_signatures = [Sig('foo', nargs=2), Sig('bar', nargs='?')]
+    failures = ['', '--foo', 'a', 'a b c d']
+    successes = [
+        ('a b', NS(foo=['a', 'b'], bar=None)),
+        ('a b c', NS(foo=['a', 'b'], bar='c')),
+    ]
+
+
+class TestPositionalsNargsZeroOrMore1(ParserTestCase):
+    """Test a Positional with unlimited nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo', nargs='*'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', ]
+    successes = [
+        ('a', NS(foo=[], bar=['a'])),
+        ('a b', NS(foo=['a'], bar=['b'])),
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargsOneOrMore1(ParserTestCase):
+    """Test a Positional with one or more nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo', nargs='+'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo=['a'], bar=['b'])),
+        ('a b c', NS(foo=['a', 'b'], bar=['c'])),
+    ]
+
+
+class TestPositionalsNargsOptional1(ParserTestCase):
+    """Test a Positional with an Optional nargs followed by one with 1"""
+
+    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs=1)]
+    failures = ['', '--foo', 'a b c']
+    successes = [
+        ('a', NS(foo=None, bar=['a'])),
+        ('a b', NS(foo='a', bar=['b'])),
+    ]
+
+
+class TestPositionalsNargsNoneZeroOrMore1(ParserTestCase):
+    """Test three Positionals: no nargs, unlimited nargs and 1 nargs"""
+
+    argument_signatures = [
+        Sig('foo'),
+        Sig('bar', nargs='*'),
+        Sig('baz', nargs=1),
+    ]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo='a', bar=[], baz=['b'])),
+        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),
+    ]
+
+
+class TestPositionalsNargsNoneOneOrMore1(ParserTestCase):
+    """Test three Positionals: no nargs, one or more nargs and 1 nargs"""
+
+    argument_signatures = [
+        Sig('foo'),
+        Sig('bar', nargs='+'),
+        Sig('baz', nargs=1),
+    ]
+    failures = ['', '--foo', 'a', 'b']
+    successes = [
+        ('a b c', NS(foo='a', bar=['b'], baz=['c'])),
+        ('a b c d', NS(foo='a', bar=['b', 'c'], baz=['d'])),
+    ]
+
+
+class TestPositionalsNargsNoneOptional1(ParserTestCase):
+    """Test three Positionals: no nargs, optional narg and 1 nargs"""
+
+    argument_signatures = [
+        Sig('foo'),
+        Sig('bar', nargs='?', default=0.625),
+        Sig('baz', nargs=1),
+    ]
+    failures = ['', '--foo', 'a']
+    successes = [
+        ('a b', NS(foo='a', bar=0.625, baz=['b'])),
+        ('a b c', NS(foo='a', bar='b', baz=['c'])),
+    ]
+
+
+class TestPositionalsNargsOptionalOptional(ParserTestCase):
+    """Test two optional nargs"""
+
+    argument_signatures = [
+        Sig('foo', nargs='?'),
+        Sig('bar', nargs='?', default=42),
+    ]
+    failures = ['--foo', 'a b c']
+    successes = [
+        ('', NS(foo=None, bar=42)),
+        ('a', NS(foo='a', bar=42)),
+        ('a b', NS(foo='a', bar='b')),
+    ]
+
+
+class TestPositionalsNargsOptionalZeroOrMore(ParserTestCase):
+    """Test an Optional narg followed by unlimited nargs"""
+
+    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='*')]
+    failures = ['--foo']
+    successes = [
+        ('', NS(foo=None, bar=[])),
+        ('a', NS(foo='a', bar=[])),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsNargsOptionalOneOrMore(ParserTestCase):
+    """Test an Optional narg followed by one or more nargs"""
+
+    argument_signatures = [Sig('foo', nargs='?'), Sig('bar', nargs='+')]
+    failures = ['', '--foo']
+    successes = [
+        ('a', NS(foo=None, bar=['a'])),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('a b c', NS(foo='a', bar=['b', 'c'])),
+    ]
+
+
+class TestPositionalsChoicesString(ParserTestCase):
+    """Test a set of single-character choices"""
+
+    argument_signatures = [Sig('spam', choices=set('abcdefg'))]
+    failures = ['', '--foo', 'h', '42', 'ef']
+    successes = [
+        ('a', NS(spam='a')),
+        ('g', NS(spam='g')),
+    ]
+
+
+class TestPositionalsChoicesInt(ParserTestCase):
+    """Test a set of integer choices"""
+
+    argument_signatures = [Sig('spam', type=int, choices=range(20))]
+    failures = ['', '--foo', 'h', '42', 'ef']
+    successes = [
+        ('4', NS(spam=4)),
+        ('15', NS(spam=15)),
+    ]
+
+
+class TestPositionalsActionAppend(ParserTestCase):
+    """Test the 'append' action"""
+
+    argument_signatures = [
+        Sig('spam', action='append'),
+        Sig('spam', action='append', nargs=2),
+    ]
+    failures = ['', '--foo', 'a', 'a b', 'a b c d']
+    successes = [
+        ('a b c', NS(spam=['a', ['b', 'c']])),
+    ]
+
+# ========================================
+# Combined optionals and positionals tests
+# ========================================
+
+class TestOptionalsNumericAndPositionals(ParserTestCase):
+    """Tests negative number args when numeric options are present"""
+
+    argument_signatures = [
+        Sig('x', nargs='?'),
+        Sig('-4', dest='y', action='store_true'),
+    ]
+    failures = ['-2', '-315']
+    successes = [
+        ('', NS(x=None, y=False)),
+        ('a', NS(x='a', y=False)),
+        ('-4', NS(x=None, y=True)),
+        ('-4 a', NS(x='a', y=True)),
+    ]
+
+
+class TestOptionalsAlmostNumericAndPositionals(ParserTestCase):
+    """Tests negative number args when almost numeric options are present"""
+
+    argument_signatures = [
+        Sig('x', nargs='?'),
+        Sig('-k4', dest='y', action='store_true'),
+    ]
+    failures = ['-k3']
+    successes = [
+        ('', NS(x=None, y=False)),
+        ('-2', NS(x='-2', y=False)),
+        ('a', NS(x='a', y=False)),
+        ('-k4', NS(x=None, y=True)),
+        ('-k4 a', NS(x='a', y=True)),
+    ]
+
+
+class TestEmptyAndSpaceContainingArguments(ParserTestCase):
+
+    argument_signatures = [
+        Sig('x', nargs='?'),
+        Sig('-y', '--yyy', dest='y'),
+    ]
+    failures = ['-y']
+    successes = [
+        ([''], NS(x='', y=None)),
+        (['a badger'], NS(x='a badger', y=None)),
+        (['-a badger'], NS(x='-a badger', y=None)),
+        (['-y', ''], NS(x=None, y='')),
+        (['-y', 'a badger'], NS(x=None, y='a badger')),
+        (['-y', '-a badger'], NS(x=None, y='-a badger')),
+        (['--yyy=a badger'], NS(x=None, y='a badger')),
+        (['--yyy=-a badger'], NS(x=None, y='-a badger')),
+    ]
+
+
+class TestPrefixCharacterOnlyArguments(ParserTestCase):
+
+    parser_signature = Sig(prefix_chars='-+')
+    argument_signatures = [
+        Sig('-', dest='x', nargs='?', const='badger'),
+        Sig('+', dest='y', type=int, default=42),
+        Sig('-+-', dest='z', action='store_true'),
+    ]
+    failures = ['-y', '+ -']
+    successes = [
+        ('', NS(x=None, y=42, z=False)),
+        ('-', NS(x='badger', y=42, z=False)),
+        ('- X', NS(x='X', y=42, z=False)),
+        ('+ -3', NS(x=None, y=-3, z=False)),
+        ('-+-', NS(x=None, y=42, z=True)),
+        ('- ===', NS(x='===', y=42, z=False)),
+    ]
+
+
+class TestNargsZeroOrMore(ParserTestCase):
+    """Tests specifying an args for an Optional that accepts zero or more"""
+
+    argument_signatures = [Sig('-x', nargs='*'), Sig('y', nargs='*')]
+    failures = []
+    successes = [
+        ('', NS(x=None, y=[])),
+        ('-x', NS(x=[], y=[])),
+        ('-x a', NS(x=['a'], y=[])),
+        ('-x a -- b', NS(x=['a'], y=['b'])),
+        ('a', NS(x=None, y=['a'])),
+        ('a -x', NS(x=[], y=['a'])),
+        ('a -x b', NS(x=['b'], y=['a'])),
+    ]
+
+
+class TestNargsRemainder(ParserTestCase):
+    """Tests specifying a positional with nargs=REMAINDER"""
+
+    argument_signatures = [Sig('x'), Sig('y', nargs='...'), Sig('-z')]
+    failures = ['', '-z', '-z Z']
+    successes = [
+        ('X', NS(x='X', y=[], z=None)),
+        ('-z Z X', NS(x='X', y=[], z='Z')),
+        ('X A B -z Z', NS(x='X', y=['A', 'B', '-z', 'Z'], z=None)),
+        ('X Y --foo', NS(x='X', y=['Y', '--foo'], z=None)),
+    ]
+
+
+class TestOptionLike(ParserTestCase):
+    """Tests options that may or may not be arguments"""
+
+    argument_signatures = [
+        Sig('-x', type=float),
+        Sig('-3', type=float, dest='y'),
+        Sig('z', nargs='*'),
+    ]
+    failures = ['-x', '-y2.5', '-xa', '-x -a',
+                '-x -3', '-x -3.5', '-3 -3.5',
+                '-x -2.5', '-x -2.5 a', '-3 -.5',
+                'a x -1', '-x -1 a', '-3 -1 a']
+    successes = [
+        ('', NS(x=None, y=None, z=[])),
+        ('-x 2.5', NS(x=2.5, y=None, z=[])),
+        ('-x 2.5 a', NS(x=2.5, y=None, z=['a'])),
+        ('-3.5', NS(x=None, y=0.5, z=[])),
+        ('-3-.5', NS(x=None, y=-0.5, z=[])),
+        ('-3 .5', NS(x=None, y=0.5, z=[])),
+        ('a -3.5', NS(x=None, y=0.5, z=['a'])),
+        ('a', NS(x=None, y=None, z=['a'])),
+        ('a -x 1', NS(x=1.0, y=None, z=['a'])),
+        ('-x 1 a', NS(x=1.0, y=None, z=['a'])),
+        ('-3 1 a', NS(x=None, y=1.0, z=['a'])),
+    ]
+
+
+class TestDefaultSuppress(ParserTestCase):
+    """Test actions with suppressed defaults"""
+
+    argument_signatures = [
+        Sig('foo', nargs='?', default=argparse.SUPPRESS),
+        Sig('bar', nargs='*', default=argparse.SUPPRESS),
+        Sig('--baz', action='store_true', default=argparse.SUPPRESS),
+    ]
+    failures = ['-x']
+    successes = [
+        ('', NS()),
+        ('a', NS(foo='a')),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('--baz', NS(baz=True)),
+        ('a --baz', NS(foo='a', baz=True)),
+        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),
+    ]
+
+
+class TestParserDefaultSuppress(ParserTestCase):
+    """Test actions with a parser-level default of SUPPRESS"""
+
+    parser_signature = Sig(argument_default=argparse.SUPPRESS)
+    argument_signatures = [
+        Sig('foo', nargs='?'),
+        Sig('bar', nargs='*'),
+        Sig('--baz', action='store_true'),
+    ]
+    failures = ['-x']
+    successes = [
+        ('', NS()),
+        ('a', NS(foo='a')),
+        ('a b', NS(foo='a', bar=['b'])),
+        ('--baz', NS(baz=True)),
+        ('a --baz', NS(foo='a', baz=True)),
+        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),
+    ]
+
+
+class TestParserDefault42(ParserTestCase):
+    """Test actions with a parser-level default of 42"""
+
+    parser_signature = Sig(argument_default=42, version='1.0')
+    argument_signatures = [
+        Sig('foo', nargs='?'),
+        Sig('bar', nargs='*'),
+        Sig('--baz', action='store_true'),
+    ]
+    failures = ['-x']
+    successes = [
+        ('', NS(foo=42, bar=42, baz=42)),
+        ('a', NS(foo='a', bar=42, baz=42)),
+        ('a b', NS(foo='a', bar=['b'], baz=42)),
+        ('--baz', NS(foo=42, bar=42, baz=True)),
+        ('a --baz', NS(foo='a', bar=42, baz=True)),
+        ('--baz a b', NS(foo='a', bar=['b'], baz=True)),
+    ]
+
+
+class TestArgumentsFromFile(TempDirMixin, ParserTestCase):
+    """Test reading arguments from a file"""
+
+    def setUp(self):
+        super(TestArgumentsFromFile, self).setUp()
+        file_texts = [
+            ('hello', 'hello world!\n'),
+            ('recursive', '-a\n'
+                          'A\n'
+                          '@hello'),
+            ('invalid', '@no-such-path\n'),
+        ]
+        for path, text in file_texts:
+            file = open(path, 'w')
+            file.write(text)
+            file.close()
+
+    parser_signature = Sig(fromfile_prefix_chars='@')
+    argument_signatures = [
+        Sig('-a'),
+        Sig('x'),
+        Sig('y', nargs='+'),
+    ]
+    failures = ['', '-b', 'X', '@invalid', '@missing']
+    successes = [
+        ('X Y', NS(a=None, x='X', y=['Y'])),
+        ('X -a A Y Z', NS(a='A', x='X', y=['Y', 'Z'])),
+        ('@hello X', NS(a=None, x='hello world!', y=['X'])),
+        ('X @hello', NS(a=None, x='X', y=['hello world!'])),
+        ('-a B @recursive Y Z', NS(a='A', x='hello world!', y=['Y', 'Z'])),
+        ('X @recursive Z -a B', NS(a='B', x='X', y=['hello world!', 'Z'])),
+    ]
+
+
+class TestArgumentsFromFileConverter(TempDirMixin, ParserTestCase):
+    """Test reading arguments from a file"""
+
+    def setUp(self):
+        super(TestArgumentsFromFileConverter, self).setUp()
+        file_texts = [
+            ('hello', 'hello world!\n'),
+        ]
+        for path, text in file_texts:
+            file = open(path, 'w')
+            file.write(text)
+            file.close()
+
+    class FromFileConverterArgumentParser(ErrorRaisingArgumentParser):
+
+        def convert_arg_line_to_args(self, arg_line):
+            for arg in arg_line.split():
+                if not arg.strip():
+                    continue
+                yield arg
+    parser_class = FromFileConverterArgumentParser
+    parser_signature = Sig(fromfile_prefix_chars='@')
+    argument_signatures = [
+        Sig('y', nargs='+'),
+    ]
+    failures = []
+    successes = [
+        ('@hello X', NS(y=['hello', 'world!', 'X'])),
+    ]
+
+
+# =====================
+# Type conversion tests
+# =====================
+
+class TestFileTypeRepr(TestCase):
+
+    def test_r(self):
+        type = argparse.FileType('r')
+        self.assertEqual("FileType('r')", repr(type))
+
+    def test_wb_1(self):
+        type = argparse.FileType('wb', 1)
+        self.assertEqual("FileType('wb', 1)", repr(type))
+
+
+class RFile(object):
+    seen = {}
+
+    def __init__(self, name):
+        self.name = name
+
+    def __eq__(self, other):
+        if other in self.seen:
+            text = self.seen[other]
+        else:
+            text = self.seen[other] = other.read()
+            other.close()
+        if not isinstance(text, str):
+            text = text.decode('ascii')
+        return self.name == other.name == text
+
+
+class TestFileTypeR(TempDirMixin, ParserTestCase):
+    """Test the FileType option/argument type for reading files"""
+
+    def setUp(self):
+        super(TestFileTypeR, self).setUp()
+        for file_name in ['foo', 'bar']:
+            file = open(os.path.join(self.temp_dir, file_name), 'w')
+            file.write(file_name)
+            file.close()
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType()),
+        Sig('spam', type=argparse.FileType('r')),
+    ]
+    failures = ['-x', '']
+    successes = [
+        ('foo', NS(x=None, spam=RFile('foo'))),
+        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),
+    ]
+
+
+class TestFileTypeRB(TempDirMixin, ParserTestCase):
+    """Test the FileType option/argument type for reading files"""
+
+    def setUp(self):
+        super(TestFileTypeRB, self).setUp()
+        for file_name in ['foo', 'bar']:
+            file = open(os.path.join(self.temp_dir, file_name), 'w')
+            file.write(file_name)
+            file.close()
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType('rb')),
+        Sig('spam', type=argparse.FileType('rb')),
+    ]
+    failures = ['-x', '']
+    successes = [
+        ('foo', NS(x=None, spam=RFile('foo'))),
+        ('-x foo bar', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('bar -x foo', NS(x=RFile('foo'), spam=RFile('bar'))),
+        ('-x - -', NS(x=sys.stdin, spam=sys.stdin)),
+    ]
+
+
+class WFile(object):
+    seen = set()
+
+    def __init__(self, name):
+        self.name = name
+
+    def __eq__(self, other):
+        if other not in self.seen:
+            text = 'Check that file is writable.'
+            if 'b' in other.mode:
+                text = text.encode('ascii')
+            other.write(text)
+            other.close()
+            self.seen.add(other)
+        return self.name == other.name
+
+
+class TestFileTypeW(TempDirMixin, ParserTestCase):
+    """Test the FileType option/argument type for writing files"""
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType('w')),
+        Sig('spam', type=argparse.FileType('w')),
+    ]
+    failures = ['-x', '']
+    successes = [
+        ('foo', NS(x=None, spam=WFile('foo'))),
+        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),
+    ]
+
+
+class TestFileTypeWB(TempDirMixin, ParserTestCase):
+
+    argument_signatures = [
+        Sig('-x', type=argparse.FileType('wb')),
+        Sig('spam', type=argparse.FileType('wb')),
+    ]
+    failures = ['-x', '']
+    successes = [
+        ('foo', NS(x=None, spam=WFile('foo'))),
+        ('-x foo bar', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('bar -x foo', NS(x=WFile('foo'), spam=WFile('bar'))),
+        ('-x - -', NS(x=sys.stdout, spam=sys.stdout)),
+    ]
+
+
+class TestTypeCallable(ParserTestCase):
+    """Test some callables as option/argument types"""
+
+    argument_signatures = [
+        Sig('--eggs', type=complex),
+        Sig('spam', type=float),
+    ]
+    failures = ['a', '42j', '--eggs a', '--eggs 2i']
+    successes = [
+        ('--eggs=42 42', NS(eggs=42, spam=42.0)),
+        ('--eggs 2j -- -1.5', NS(eggs=2j, spam=-1.5)),
+        ('1024.675', NS(eggs=None, spam=1024.675)),
+    ]
+
+
+class TestTypeUserDefined(ParserTestCase):
+    """Test a user-defined option/argument type"""
+
+    class MyType(TestCase):
+
+        def __init__(self, value):
+            self.value = value
+
+        def __eq__(self, other):
+            return (type(self), self.value) == (type(other), other.value)
+
+    argument_signatures = [
+        Sig('-x', type=MyType),
+        Sig('spam', type=MyType),
+    ]
+    failures = []
+    successes = [
+        ('a -x b', NS(x=MyType('b'), spam=MyType('a'))),
+        ('-xf g', NS(x=MyType('f'), spam=MyType('g'))),
+    ]
+
+
+class TestTypeClassicClass(ParserTestCase):
+    """Test a classic class type"""
+
+    class C:
+
+        def __init__(self, value):
+            self.value = value
+
+        def __eq__(self, other):
+            return (type(self), self.value) == (type(other), other.value)
+
+    argument_signatures = [
+        Sig('-x', type=C),
+        Sig('spam', type=C),
+    ]
+    failures = []
+    successes = [
+        ('a -x b', NS(x=C('b'), spam=C('a'))),
+        ('-xf g', NS(x=C('f'), spam=C('g'))),
+    ]
+
+
+class TestTypeRegistration(TestCase):
+    """Test a user-defined type by registering it"""
+
+    def test(self):
+
+        def get_my_type(string):
+            return 'my_type{%s}' % string
+
+        parser = argparse.ArgumentParser()
+        parser.register('type', 'my_type', get_my_type)
+        parser.add_argument('-x', type='my_type')
+        parser.add_argument('y', type='my_type')
+
+        self.assertEqual(parser.parse_args('1'.split()),
+                         NS(x=None, y='my_type{1}'))
+        self.assertEqual(parser.parse_args('-x 1 42'.split()),
+                         NS(x='my_type{1}', y='my_type{42}'))
+
+
+# ============
+# Action tests
+# ============
+
+class TestActionUserDefined(ParserTestCase):
+    """Test a user-defined option/argument action"""
+
+    class OptionalAction(argparse.Action):
+
+        def __call__(self, parser, namespace, value, option_string=None):
+            try:
+                # check destination and option string
+                assert self.dest == 'spam', 'dest: %s' % self.dest
+                assert option_string == '-s', 'flag: %s' % option_string
+                # when option is before argument, badger=2, and when
+                # option is after argument, badger=<whatever was set>
+                expected_ns = NS(spam=0.25)
+                if value in [0.125, 0.625]:
+                    expected_ns.badger = 2
+                elif value in [2.0]:
+                    expected_ns.badger = 84
+                else:
+                    raise AssertionError('value: %s' % value)
+                assert expected_ns == namespace, ('expected %s, got %s' %
+                                                  (expected_ns, namespace))
+            except AssertionError:
+                e = sys.exc_info()[1]
+                raise ArgumentParserError('opt_action failed: %s' % e)
+            setattr(namespace, 'spam', value)
+
+    class PositionalAction(argparse.Action):
+
+        def __call__(self, parser, namespace, value, option_string=None):
+            try:
+                assert option_string is None, ('option_string: %s' %
+                                               option_string)
+                # check destination
+                assert self.dest == 'badger', 'dest: %s' % self.dest
+                # when argument is before option, spam=0.25, and when
+                # option is after argument, spam=<whatever was set>
+                expected_ns = NS(badger=2)
+                if value in [42, 84]:
+                    expected_ns.spam = 0.25
+                elif value in [1]:
+                    expected_ns.spam = 0.625
+                elif value in [2]:
+                    expected_ns.spam = 0.125
+                else:
+                    raise AssertionError('value: %s' % value)
+                assert expected_ns == namespace, ('expected %s, got %s' %
+                                                  (expected_ns, namespace))
+            except AssertionError:
+                e = sys.exc_info()[1]
+                raise ArgumentParserError('arg_action failed: %s' % e)
+            setattr(namespace, 'badger', value)
+
+    argument_signatures = [
+        Sig('-s', dest='spam', action=OptionalAction,
+            type=float, default=0.25),
+        Sig('badger', action=PositionalAction,
+            type=int, nargs='?', default=2),
+    ]
+    failures = []
+    successes = [
+        ('-s0.125', NS(spam=0.125, badger=2)),
+        ('42', NS(spam=0.25, badger=42)),
+        ('-s 0.625 1', NS(spam=0.625, badger=1)),
+        ('84 -s2', NS(spam=2.0, badger=84)),
+    ]
+
+
+class TestActionRegistration(TestCase):
+    """Test a user-defined action supplied by registering it"""
+
+    class MyAction(argparse.Action):
+
+        def __call__(self, parser, namespace, values, option_string=None):
+            setattr(namespace, self.dest, 'foo[%s]' % values)
+
+    def test(self):
+
+        parser = argparse.ArgumentParser()
+        parser.register('action', 'my_action', self.MyAction)
+        parser.add_argument('badger', action='my_action')
+
+        self.assertEqual(parser.parse_args(['1']), NS(badger='foo[1]'))
+        self.assertEqual(parser.parse_args(['42']), NS(badger='foo[42]'))
+
+
+# ================
+# Subparsers tests
+# ================
+
+class TestAddSubparsers(TestCase):
+    """Test the add_subparsers method"""
+
+    def assertArgumentParserError(self, *args, **kwargs):
+        self.assertRaises(ArgumentParserError, *args, **kwargs)
+
+    def _get_parser(self, subparser_help=False):
+        # create a parser with a subparsers argument
+        parser = ErrorRaisingArgumentParser(
+            prog='PROG', description='main description')
+        parser.add_argument(
+            '--foo', action='store_true', help='foo help')
+        parser.add_argument(
+            'bar', type=float, help='bar help')
+
+        # check that only one subparsers argument can be added
+        subparsers = parser.add_subparsers(help='command help')
+        self.assertArgumentParserError(parser.add_subparsers)
+
+        # add first sub-parser
+        parser1_kwargs = dict(description='1 description')
+        if subparser_help:
+            parser1_kwargs['help'] = '1 help'
+        parser1 = subparsers.add_parser('1', **parser1_kwargs)
+        parser1.add_argument('-w', type=int, help='w help')
+        parser1.add_argument('x', choices='abc', help='x help')
+
+        # add second sub-parser
+        parser2_kwargs = dict(description='2 description')
+        if subparser_help:
+            parser2_kwargs['help'] = '2 help'
+        parser2 = subparsers.add_parser('2', **parser2_kwargs)
+        parser2.add_argument('-y', choices='123', help='y help')
+        parser2.add_argument('z', type=complex, nargs='*', help='z help')
+
+        # return the main parser
+        return parser
+
+    def setUp(self):
+        self.parser = self._get_parser()
+        self.command_help_parser = self._get_parser(subparser_help=True)
+
+    def test_parse_args_failures(self):
+        # check some failure cases:
+        for args_str in ['', 'a', 'a a', '0.5 a', '0.5 1',
+                         '0.5 1 -y', '0.5 2 -w']:
+            args = args_str.split()
+            self.assertArgumentParserError(self.parser.parse_args, args)
+
+    def test_parse_args(self):
+        # check some non-failure cases:
+        self.assertEqual(
+            self.parser.parse_args('0.5 1 b -w 7'.split()),
+            NS(foo=False, bar=0.5, w=7, x='b'),
+        )
+        self.assertEqual(
+            self.parser.parse_args('0.25 --foo 2 -y 2 3j -- -1j'.split()),
+            NS(foo=True, bar=0.25, y='2', z=[3j, -1j]),
+        )
+        self.assertEqual(
+            self.parser.parse_args('--foo 0.125 1 c'.split()),
+            NS(foo=True, bar=0.125, w=None, x='c'),
+        )
+
+    def test_dest(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.add_argument('--foo', action='store_true')
+        subparsers = parser.add_subparsers(dest='bar')
+        parser1 = subparsers.add_parser('1')
+        parser1.add_argument('baz')
+        self.assertEqual(NS(foo=False, bar='1', baz='2'),
+                         parser.parse_args('1 2'.split()))
+
+    def test_help(self):
+        self.assertEqual(self.parser.format_usage(),
+                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')
+        self.assertEqual(self.parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [--foo] bar {1,2} ...
+
+            main description
+
+            positional arguments:
+              bar         bar help
+              {1,2}       command help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              --foo       foo help
+            '''))
+
+    def test_parser_command_help(self):
+        self.assertEqual(self.command_help_parser.format_usage(),
+                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')
+        self.assertEqual(self.command_help_parser.format_help(),
+                         textwrap.dedent('''\
+            usage: PROG [-h] [--foo] bar {1,2} ...
+
+            main description
+
+            positional arguments:
+              bar         bar help
+              {1,2}       command help
+                1         1 help
+                2         2 help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              --foo       foo help
+            '''))
+
+    def test_subparser_title_help(self):
+        parser = ErrorRaisingArgumentParser(prog='PROG',
+                                            description='main description')
+        parser.add_argument('--foo', action='store_true', help='foo help')
+        parser.add_argument('bar', help='bar help')
+        subparsers = parser.add_subparsers(title='subcommands',
+                                           description='command help',
+                                           help='additional text')
+        parser1 = subparsers.add_parser('1')
+        parser2 = subparsers.add_parser('2')
+        self.assertEqual(parser.format_usage(),
+                         'usage: PROG [-h] [--foo] bar {1,2} ...\n')
+        self.assertEqual(parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [--foo] bar {1,2} ...
+
+            main description
+
+            positional arguments:
+              bar         bar help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              --foo       foo help
+
+            subcommands:
+              command help
+
+              {1,2}       additional text
+            '''))
+
+    def _test_subparser_help(self, args_str, expected_help):
+        try:
+            self.parser.parse_args(args_str.split())
+        except ArgumentParserError:
+            err = sys.exc_info()[1]
+            if err.stdout != expected_help:
+                print(repr(expected_help))
+                print(repr(err.stdout))
+            self.assertEqual(err.stdout, expected_help)
+
+    def test_subparser1_help(self):
+        self._test_subparser_help('5.0 1 -h', textwrap.dedent('''\
+            usage: PROG bar 1 [-h] [-w W] {a,b,c}
+
+            1 description
+
+            positional arguments:
+              {a,b,c}     x help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -w W        w help
+            '''))
+
+    def test_subparser2_help(self):
+        self._test_subparser_help('5.0 2 -h', textwrap.dedent('''\
+            usage: PROG bar 2 [-h] [-y {1,2,3}] [z [z ...]]
+
+            2 description
+
+            positional arguments:
+              z           z help
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -y {1,2,3}  y help
+            '''))
+
+# ============
+# Groups tests
+# ============
+
+class TestPositionalsGroups(TestCase):
+    """Tests that order of group positionals matches construction order"""
+
+    def test_nongroup_first(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.add_argument('foo')
+        group = parser.add_argument_group('g')
+        group.add_argument('bar')
+        parser.add_argument('baz')
+        expected = NS(foo='1', bar='2', baz='3')
+        result = parser.parse_args('1 2 3'.split())
+        self.assertEqual(expected, result)
+
+    def test_group_first(self):
+        parser = ErrorRaisingArgumentParser()
+        group = parser.add_argument_group('xxx')
+        group.add_argument('foo')
+        parser.add_argument('bar')
+        parser.add_argument('baz')
+        expected = NS(foo='1', bar='2', baz='3')
+        result = parser.parse_args('1 2 3'.split())
+        self.assertEqual(expected, result)
+
+    def test_interleaved_groups(self):
+        parser = ErrorRaisingArgumentParser()
+        group = parser.add_argument_group('xxx')
+        parser.add_argument('foo')
+        group.add_argument('bar')
+        parser.add_argument('baz')
+        group = parser.add_argument_group('yyy')
+        group.add_argument('frell')
+        expected = NS(foo='1', bar='2', baz='3', frell='4')
+        result = parser.parse_args('1 2 3 4'.split())
+        self.assertEqual(expected, result)
+
+# ===================
+# Parent parser tests
+# ===================
+
+class TestParentParsers(TestCase):
+    """Tests that parsers can be created with parent parsers"""
+
+    def assertArgumentParserError(self, *args, **kwargs):
+        self.assertRaises(ArgumentParserError, *args, **kwargs)
+
+    def setUp(self):
+        self.wxyz_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.wxyz_parent.add_argument('--w')
+        x_group = self.wxyz_parent.add_argument_group('x')
+        x_group.add_argument('-y')
+        self.wxyz_parent.add_argument('z')
+
+        self.abcd_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.abcd_parent.add_argument('a')
+        self.abcd_parent.add_argument('-b')
+        c_group = self.abcd_parent.add_argument_group('c')
+        c_group.add_argument('--d')
+
+        self.w_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.w_parent.add_argument('--w')
+
+        self.z_parent = ErrorRaisingArgumentParser(add_help=False)
+        self.z_parent.add_argument('z')
+
+        # parents with mutually exclusive groups
+        self.ab_mutex_parent = ErrorRaisingArgumentParser(add_help=False)
+        group = self.ab_mutex_parent.add_mutually_exclusive_group()
+        group.add_argument('-a', action='store_true')
+        group.add_argument('-b', action='store_true')
+
+        self.main_program = os.path.basename(sys.argv[0])
+
+    def test_single_parent(self):
+        parser = ErrorRaisingArgumentParser(parents=[self.wxyz_parent])
+        self.assertEqual(parser.parse_args('-y 1 2 --w 3'.split()),
+                         NS(w='3', y='1', z='2'))
+
+    def test_single_parent_mutex(self):
+        self._test_mutex_ab(self.ab_mutex_parent.parse_args)
+        parser = ErrorRaisingArgumentParser(parents=[self.ab_mutex_parent])
+        self._test_mutex_ab(parser.parse_args)
+
+    def test_single_granparent_mutex(self):
+        parents = [self.ab_mutex_parent]
+        parser = ErrorRaisingArgumentParser(add_help=False, parents=parents)
+        parser = ErrorRaisingArgumentParser(parents=[parser])
+        self._test_mutex_ab(parser.parse_args)
+
+    def _test_mutex_ab(self, parse_args):
+        self.assertEqual(parse_args([]), NS(a=False, b=False))
+        self.assertEqual(parse_args(['-a']), NS(a=True, b=False))
+        self.assertEqual(parse_args(['-b']), NS(a=False, b=True))
+        self.assertArgumentParserError(parse_args, ['-a', '-b'])
+        self.assertArgumentParserError(parse_args, ['-b', '-a'])
+        self.assertArgumentParserError(parse_args, ['-c'])
+        self.assertArgumentParserError(parse_args, ['-a', '-c'])
+        self.assertArgumentParserError(parse_args, ['-b', '-c'])
+
+    def test_multiple_parents(self):
+        parents = [self.abcd_parent, self.wxyz_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        self.assertEqual(parser.parse_args('--d 1 --w 2 3 4'.split()),
+                         NS(a='3', b=None, d='1', w='2', y=None, z='4'))
+
+    def test_multiple_parents_mutex(self):
+        parents = [self.ab_mutex_parent, self.wxyz_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        self.assertEqual(parser.parse_args('-a --w 2 3'.split()),
+                         NS(a=True, b=False, w='2', y=None, z='3'))
+        self.assertArgumentParserError(
+            parser.parse_args, '-a --w 2 3 -b'.split())
+        self.assertArgumentParserError(
+            parser.parse_args, '-a -b --w 2 3'.split())
+
+    def test_conflicting_parents(self):
+        self.assertRaises(
+            argparse.ArgumentError,
+            argparse.ArgumentParser,
+            parents=[self.w_parent, self.wxyz_parent])
+
+    def test_conflicting_parents_mutex(self):
+        self.assertRaises(
+            argparse.ArgumentError,
+            argparse.ArgumentParser,
+            parents=[self.abcd_parent, self.ab_mutex_parent])
+
+    def test_same_argument_name_parents(self):
+        parents = [self.wxyz_parent, self.z_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        self.assertEqual(parser.parse_args('1 2'.split()),
+                         NS(w=None, y=None, z='2'))
+
+    def test_subparser_parents(self):
+        parser = ErrorRaisingArgumentParser()
+        subparsers = parser.add_subparsers()
+        abcde_parser = subparsers.add_parser('bar', parents=[self.abcd_parent])
+        abcde_parser.add_argument('e')
+        self.assertEqual(parser.parse_args('bar -b 1 --d 2 3 4'.split()),
+                         NS(a='3', b='1', d='2', e='4'))
+
+    def test_subparser_parents_mutex(self):
+        parser = ErrorRaisingArgumentParser()
+        subparsers = parser.add_subparsers()
+        parents = [self.ab_mutex_parent]
+        abc_parser = subparsers.add_parser('foo', parents=parents)
+        c_group = abc_parser.add_argument_group('c_group')
+        c_group.add_argument('c')
+        parents = [self.wxyz_parent, self.ab_mutex_parent]
+        wxyzabe_parser = subparsers.add_parser('bar', parents=parents)
+        wxyzabe_parser.add_argument('e')
+        self.assertEqual(parser.parse_args('foo -a 4'.split()),
+                         NS(a=True, b=False, c='4'))
+        self.assertEqual(parser.parse_args('bar -b  --w 2 3 4'.split()),
+                         NS(a=False, b=True, w='2', y=None, z='3', e='4'))
+        self.assertArgumentParserError(
+            parser.parse_args, 'foo -a -b 4'.split())
+        self.assertArgumentParserError(
+            parser.parse_args, 'bar -b -a 4'.split())
+
+    def test_parent_help(self):
+        parents = [self.abcd_parent, self.wxyz_parent]
+        parser = ErrorRaisingArgumentParser(parents=parents)
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent('''\
+            usage: {} [-h] [-b B] [--d D] [--w W] [-y Y] a z
+
+            positional arguments:
+              a
+              z
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -b B
+              --w W
+
+            c:
+              --d D
+
+            x:
+              -y Y
+        '''.format(self.main_program)))
+
+    def test_groups_parents(self):
+        parent = ErrorRaisingArgumentParser(add_help=False)
+        g = parent.add_argument_group(title='g', description='gd')
+        g.add_argument('-w')
+        g.add_argument('-x')
+        m = parent.add_mutually_exclusive_group()
+        m.add_argument('-y')
+        m.add_argument('-z')
+        parser = ErrorRaisingArgumentParser(parents=[parent])
+
+        self.assertRaises(ArgumentParserError, parser.parse_args,
+            ['-y', 'Y', '-z', 'Z'])
+
+        parser_help = parser.format_help()
+        self.assertEqual(parser_help, textwrap.dedent('''\
+            usage: {} [-h] [-w W] [-x X] [-y Y | -z Z]
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -y Y
+              -z Z
+
+            g:
+              gd
+
+              -w W
+              -x X
+        '''.format(self.main_program)))
+
+# ==============================
+# Mutually exclusive group tests
+# ==============================
+
+class TestMutuallyExclusiveGroupErrors(TestCase):
+
+    def test_invalid_add_argument_group(self):
+        parser = ErrorRaisingArgumentParser()
+        raises = self.assertRaises
+        raises(TypeError, parser.add_mutually_exclusive_group, title='foo')
+
+    def test_invalid_add_argument(self):
+        parser = ErrorRaisingArgumentParser()
+        group = parser.add_mutually_exclusive_group()
+        add_argument = group.add_argument
+        raises = self.assertRaises
+        raises(ValueError, add_argument, '--foo', required=True)
+        raises(ValueError, add_argument, 'bar')
+        raises(ValueError, add_argument, 'bar', nargs='+')
+        raises(ValueError, add_argument, 'bar', nargs=1)
+        raises(ValueError, add_argument, 'bar', nargs=argparse.PARSER)
+
+
+class MEMixin(object):
+
+    def test_failures_when_not_required(self):
+        parse_args = self.get_parser(required=False).parse_args
+        error = ArgumentParserError
+        for args_string in self.failures:
+            self.assertRaises(error, parse_args, args_string.split())
+
+    def test_failures_when_required(self):
+        parse_args = self.get_parser(required=True).parse_args
+        error = ArgumentParserError
+        for args_string in self.failures + ['']:
+            self.assertRaises(error, parse_args, args_string.split())
+
+    def test_successes_when_not_required(self):
+        parse_args = self.get_parser(required=False).parse_args
+        successes = self.successes + self.successes_when_not_required
+        for args_string, expected_ns in successes:
+            actual_ns = parse_args(args_string.split())
+            self.assertEqual(actual_ns, expected_ns)
+
+    def test_successes_when_required(self):
+        parse_args = self.get_parser(required=True).parse_args
+        for args_string, expected_ns in self.successes:
+            actual_ns = parse_args(args_string.split())
+            self.assertEqual(actual_ns, expected_ns)
+
+    def test_usage_when_not_required(self):
+        format_usage = self.get_parser(required=False).format_usage
+        expected_usage = self.usage_when_not_required
+        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))
+
+    def test_usage_when_required(self):
+        format_usage = self.get_parser(required=True).format_usage
+        expected_usage = self.usage_when_required
+        self.assertEqual(format_usage(), textwrap.dedent(expected_usage))
+
+    def test_help_when_not_required(self):
+        format_help = self.get_parser(required=False).format_help
+        help = self.usage_when_not_required + self.help
+        self.assertEqual(format_help(), textwrap.dedent(help))
+
+    def test_help_when_required(self):
+        format_help = self.get_parser(required=True).format_help
+        help = self.usage_when_required + self.help
+        self.assertEqual(format_help(), textwrap.dedent(help))
+
+
+class TestMutuallyExclusiveSimple(MEMixin, TestCase):
+
+    def get_parser(self, required=None):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('--bar', help='bar help')
+        group.add_argument('--baz', nargs='?', const='Z', help='baz help')
+        return parser
+
+    failures = ['--bar X --baz Y', '--bar X --baz']
+    successes = [
+        ('--bar X', NS(bar='X', baz=None)),
+        ('--bar X --bar Z', NS(bar='Z', baz=None)),
+        ('--baz Y', NS(bar=None, baz='Y')),
+        ('--baz', NS(bar=None, baz='Z')),
+    ]
+    successes_when_not_required = [
+        ('', NS(bar=None, baz=None)),
+    ]
+
+    usage_when_not_required = '''\
+        usage: PROG [-h] [--bar BAR | --baz [BAZ]]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] (--bar BAR | --baz [BAZ])
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help   show this help message and exit
+          --bar BAR    bar help
+          --baz [BAZ]  baz help
+        '''
+
+
+class TestMutuallyExclusiveLong(MEMixin, TestCase):
+
+    def get_parser(self, required=None):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        parser.add_argument('--abcde', help='abcde help')
+        parser.add_argument('--fghij', help='fghij help')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('--klmno', help='klmno help')
+        group.add_argument('--pqrst', help='pqrst help')
+        return parser
+
+    failures = ['--klmno X --pqrst Y']
+    successes = [
+        ('--klmno X', NS(abcde=None, fghij=None, klmno='X', pqrst=None)),
+        ('--abcde Y --klmno X',
+            NS(abcde='Y', fghij=None, klmno='X', pqrst=None)),
+        ('--pqrst X', NS(abcde=None, fghij=None, klmno=None, pqrst='X')),
+        ('--pqrst X --fghij Y',
+            NS(abcde=None, fghij='Y', klmno=None, pqrst='X')),
+    ]
+    successes_when_not_required = [
+        ('', NS(abcde=None, fghij=None, klmno=None, pqrst=None)),
+    ]
+
+    usage_when_not_required = '''\
+    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]
+                [--klmno KLMNO | --pqrst PQRST]
+    '''
+    usage_when_required = '''\
+    usage: PROG [-h] [--abcde ABCDE] [--fghij FGHIJ]
+                (--klmno KLMNO | --pqrst PQRST)
+    '''
+    help = '''\
+
+    optional arguments:
+      -h, --help     show this help message and exit
+      --abcde ABCDE  abcde help
+      --fghij FGHIJ  fghij help
+      --klmno KLMNO  klmno help
+      --pqrst PQRST  pqrst help
+    '''
+
+
+class TestMutuallyExclusiveFirstSuppressed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('-x', help=argparse.SUPPRESS)
+        group.add_argument('-y', action='store_false', help='y help')
+        return parser
+
+    failures = ['-x X -y']
+    successes = [
+        ('-x X', NS(x='X', y=True)),
+        ('-x X -x Y', NS(x='Y', y=True)),
+        ('-y', NS(x=None, y=False)),
+    ]
+    successes_when_not_required = [
+        ('', NS(x=None, y=True)),
+    ]
+
+    usage_when_not_required = '''\
+        usage: PROG [-h] [-y]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] -y
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -y          y help
+        '''
+
+
+class TestMutuallyExclusiveManySuppressed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        add = group.add_argument
+        add('--spam', action='store_true', help=argparse.SUPPRESS)
+        add('--badger', action='store_false', help=argparse.SUPPRESS)
+        add('--bladder', help=argparse.SUPPRESS)
+        return parser
+
+    failures = [
+        '--spam --badger',
+        '--badger --bladder B',
+        '--bladder B --spam',
+    ]
+    successes = [
+        ('--spam', NS(spam=True, badger=True, bladder=None)),
+        ('--badger', NS(spam=False, badger=False, bladder=None)),
+        ('--bladder B', NS(spam=False, badger=True, bladder='B')),
+        ('--spam --spam', NS(spam=True, badger=True, bladder=None)),
+    ]
+    successes_when_not_required = [
+        ('', NS(spam=False, badger=True, bladder=None)),
+    ]
+
+    usage_when_required = usage_when_not_required = '''\
+        usage: PROG [-h]
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+        '''
+
+
+class TestMutuallyExclusiveOptionalAndPositional(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('--foo', action='store_true', help='FOO')
+        group.add_argument('--spam', help='SPAM')
+        group.add_argument('badger', nargs='*', default='X', help='BADGER')
+        return parser
+
+    failures = [
+        '--foo --spam S',
+        '--spam S X',
+        'X --foo',
+        'X Y Z --spam S',
+        '--foo X Y',
+    ]
+    successes = [
+        ('--foo', NS(foo=True, spam=None, badger='X')),
+        ('--spam S', NS(foo=False, spam='S', badger='X')),
+        ('X', NS(foo=False, spam=None, badger=['X'])),
+        ('X Y Z', NS(foo=False, spam=None, badger=['X', 'Y', 'Z'])),
+    ]
+    successes_when_not_required = [
+        ('', NS(foo=False, spam=None, badger='X')),
+    ]
+
+    usage_when_not_required = '''\
+        usage: PROG [-h] [--foo | --spam SPAM | badger [badger ...]]
+        '''
+    usage_when_required = '''\
+        usage: PROG [-h] (--foo | --spam SPAM | badger [badger ...])
+        '''
+    help = '''\
+
+        positional arguments:
+          badger       BADGER
+
+        optional arguments:
+          -h, --help   show this help message and exit
+          --foo        FOO
+          --spam SPAM  SPAM
+        '''
+
+
+class TestMutuallyExclusiveOptionalsMixed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        parser.add_argument('-x', action='store_true', help='x help')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('-a', action='store_true', help='a help')
+        group.add_argument('-b', action='store_true', help='b help')
+        parser.add_argument('-y', action='store_true', help='y help')
+        group.add_argument('-c', action='store_true', help='c help')
+        return parser
+
+    failures = ['-a -b', '-b -c', '-a -c', '-a -b -c']
+    successes = [
+        ('-a', NS(a=True, b=False, c=False, x=False, y=False)),
+        ('-b', NS(a=False, b=True, c=False, x=False, y=False)),
+        ('-c', NS(a=False, b=False, c=True, x=False, y=False)),
+        ('-a -x', NS(a=True, b=False, c=False, x=True, y=False)),
+        ('-y -b', NS(a=False, b=True, c=False, x=False, y=True)),
+        ('-x -y -c', NS(a=False, b=False, c=True, x=True, y=True)),
+    ]
+    successes_when_not_required = [
+        ('', NS(a=False, b=False, c=False, x=False, y=False)),
+        ('-x', NS(a=False, b=False, c=False, x=True, y=False)),
+        ('-y', NS(a=False, b=False, c=False, x=False, y=True)),
+    ]
+
+    usage_when_required = usage_when_not_required = '''\
+        usage: PROG [-h] [-x] [-a] [-b] [-y] [-c]
+        '''
+    help = '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -x          x help
+          -a          a help
+          -b          b help
+          -y          y help
+          -c          c help
+        '''
+
+
+class TestMutuallyExclusiveOptionalsAndPositionalsMixed(MEMixin, TestCase):
+
+    def get_parser(self, required):
+        parser = ErrorRaisingArgumentParser(prog='PROG')
+        parser.add_argument('x', help='x help')
+        parser.add_argument('-y', action='store_true', help='y help')
+        group = parser.add_mutually_exclusive_group(required=required)
+        group.add_argument('a', nargs='?', help='a help')
+        group.add_argument('-b', action='store_true', help='b help')
+        group.add_argument('-c', action='store_true', help='c help')
+        return parser
+
+    failures = ['X A -b', '-b -c', '-c X A']
+    successes = [
+        ('X A', NS(a='A', b=False, c=False, x='X', y=False)),
+        ('X -b', NS(a=None, b=True, c=False, x='X', y=False)),
+        ('X -c', NS(a=None, b=False, c=True, x='X', y=False)),
+        ('X A -y', NS(a='A', b=False, c=False, x='X', y=True)),
+        ('X -y -b', NS(a=None, b=True, c=False, x='X', y=True)),
+    ]
+    successes_when_not_required = [
+        ('X', NS(a=None, b=False, c=False, x='X', y=False)),
+        ('X -y', NS(a=None, b=False, c=False, x='X', y=True)),
+    ]
+
+    usage_when_required = usage_when_not_required = '''\
+        usage: PROG [-h] [-y] [-b] [-c] x [a]
+        '''
+    help = '''\
+
+        positional arguments:
+          x           x help
+          a           a help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -y          y help
+          -b          b help
+          -c          c help
+        '''
+
+# =================================================
+# Mutually exclusive group in parent parser tests
+# =================================================
+
+class MEPBase(object):
+
+    def get_parser(self, required=None):
+        parent = super(MEPBase, self).get_parser(required=required)
+        parser = ErrorRaisingArgumentParser(
+            prog=parent.prog, add_help=False, parents=[parent])
+        return parser
+
+
+class TestMutuallyExclusiveGroupErrorsParent(
+    MEPBase, TestMutuallyExclusiveGroupErrors):
+    pass
+
+
+class TestMutuallyExclusiveSimpleParent(
+    MEPBase, TestMutuallyExclusiveSimple):
+    pass
+
+
+class TestMutuallyExclusiveLongParent(
+    MEPBase, TestMutuallyExclusiveLong):
+    pass
+
+
+class TestMutuallyExclusiveFirstSuppressedParent(
+    MEPBase, TestMutuallyExclusiveFirstSuppressed):
+    pass
+
+
+class TestMutuallyExclusiveManySuppressedParent(
+    MEPBase, TestMutuallyExclusiveManySuppressed):
+    pass
+
+
+class TestMutuallyExclusiveOptionalAndPositionalParent(
+    MEPBase, TestMutuallyExclusiveOptionalAndPositional):
+    pass
+
+
+class TestMutuallyExclusiveOptionalsMixedParent(
+    MEPBase, TestMutuallyExclusiveOptionalsMixed):
+    pass
+
+
+class TestMutuallyExclusiveOptionalsAndPositionalsMixedParent(
+    MEPBase, TestMutuallyExclusiveOptionalsAndPositionalsMixed):
+    pass
+
+# =================
+# Set default tests
+# =================
+
+class TestSetDefaults(TestCase):
+
+    def test_set_defaults_no_args(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(x='foo')
+        parser.set_defaults(y='bar', z=1)
+        self.assertEqual(NS(x='foo', y='bar', z=1),
+                         parser.parse_args([]))
+        self.assertEqual(NS(x='foo', y='bar', z=1),
+                         parser.parse_args([], NS()))
+        self.assertEqual(NS(x='baz', y='bar', z=1),
+                         parser.parse_args([], NS(x='baz')))
+        self.assertEqual(NS(x='baz', y='bar', z=2),
+                         parser.parse_args([], NS(x='baz', z=2)))
+
+    def test_set_defaults_with_args(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(x='foo', y='bar')
+        parser.add_argument('-x', default='xfoox')
+        self.assertEqual(NS(x='xfoox', y='bar'),
+                         parser.parse_args([]))
+        self.assertEqual(NS(x='xfoox', y='bar'),
+                         parser.parse_args([], NS()))
+        self.assertEqual(NS(x='baz', y='bar'),
+                         parser.parse_args([], NS(x='baz')))
+        self.assertEqual(NS(x='1', y='bar'),
+                         parser.parse_args('-x 1'.split()))
+        self.assertEqual(NS(x='1', y='bar'),
+                         parser.parse_args('-x 1'.split(), NS()))
+        self.assertEqual(NS(x='1', y='bar'),
+                         parser.parse_args('-x 1'.split(), NS(x='baz')))
+
+    def test_set_defaults_subparsers(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(x='foo')
+        subparsers = parser.add_subparsers()
+        parser_a = subparsers.add_parser('a')
+        parser_a.set_defaults(y='bar')
+        self.assertEqual(NS(x='foo', y='bar'),
+                         parser.parse_args('a'.split()))
+
+    def test_set_defaults_parents(self):
+        parent = ErrorRaisingArgumentParser(add_help=False)
+        parent.set_defaults(x='foo')
+        parser = ErrorRaisingArgumentParser(parents=[parent])
+        self.assertEqual(NS(x='foo'), parser.parse_args([]))
+
+    def test_set_defaults_same_as_add_argument(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(w='W', x='X', y='Y', z='Z')
+        parser.add_argument('-w')
+        parser.add_argument('-x', default='XX')
+        parser.add_argument('y', nargs='?')
+        parser.add_argument('z', nargs='?', default='ZZ')
+
+        # defaults set previously
+        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),
+                         parser.parse_args([]))
+
+        # reset defaults
+        parser.set_defaults(w='WW', x='X', y='YY', z='Z')
+        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),
+                         parser.parse_args([]))
+
+    def test_set_defaults_same_as_add_argument_group(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.set_defaults(w='W', x='X', y='Y', z='Z')
+        group = parser.add_argument_group('foo')
+        group.add_argument('-w')
+        group.add_argument('-x', default='XX')
+        group.add_argument('y', nargs='?')
+        group.add_argument('z', nargs='?', default='ZZ')
+
+
+        # defaults set previously
+        self.assertEqual(NS(w='W', x='XX', y='Y', z='ZZ'),
+                         parser.parse_args([]))
+
+        # reset defaults
+        parser.set_defaults(w='WW', x='X', y='YY', z='Z')
+        self.assertEqual(NS(w='WW', x='X', y='YY', z='Z'),
+                         parser.parse_args([]))
+
+# =================
+# Get default tests
+# =================
+
+class TestGetDefault(TestCase):
+
+    def test_get_default(self):
+        parser = ErrorRaisingArgumentParser()
+        self.assertEqual(None, parser.get_default("foo"))
+        self.assertEqual(None, parser.get_default("bar"))
+
+        parser.add_argument("--foo")
+        self.assertEqual(None, parser.get_default("foo"))
+        self.assertEqual(None, parser.get_default("bar"))
+
+        parser.add_argument("--bar", type=int, default=42)
+        self.assertEqual(None, parser.get_default("foo"))
+        self.assertEqual(42, parser.get_default("bar"))
+
+        parser.set_defaults(foo="badger")
+        self.assertEqual("badger", parser.get_default("foo"))
+        self.assertEqual(42, parser.get_default("bar"))
+
+# ==========================
+# Namespace 'contains' tests
+# ==========================
+
+class TestNamespaceContainsSimple(TestCase):
+
+    def test_empty(self):
+        ns = argparse.Namespace()
+        self.assertEquals('' in ns, False)
+        self.assertEquals('' not in ns, True)
+        self.assertEquals('x' in ns, False)
+
+    def test_non_empty(self):
+        ns = argparse.Namespace(x=1, y=2)
+        self.assertEquals('x' in ns, True)
+        self.assertEquals('x' not in ns, False)
+        self.assertEquals('y' in ns, True)
+        self.assertEquals('' in ns, False)
+        self.assertEquals('xx' in ns, False)
+        self.assertEquals('z' in ns, False)
+
+# =====================
+# Help formatting tests
+# =====================
+
+class TestHelpFormattingMetaclass(type):
+
+    def __init__(cls, name, bases, bodydict):
+        if name == 'HelpTestCase':
+            return
+
+        class AddTests(object):
+
+            def __init__(self, test_class, func_suffix, std_name):
+                self.func_suffix = func_suffix
+                self.std_name = std_name
+
+                for test_func in [self.test_format,
+                                  self.test_print,
+                                  self.test_print_file]:
+                    test_name = '%s_%s' % (test_func.__name__, func_suffix)
+
+                    def test_wrapper(self, test_func=test_func):
+                        test_func(self)
+                    try:
+                        test_wrapper.__name__ = test_name
+                    except TypeError:
+                        pass
+                    setattr(test_class, test_name, test_wrapper)
+
+            def _get_parser(self, tester):
+                parser = argparse.ArgumentParser(
+                    *tester.parser_signature.args,
+                    **tester.parser_signature.kwargs)
+                for argument_sig in tester.argument_signatures:
+                    parser.add_argument(*argument_sig.args,
+                                        **argument_sig.kwargs)
+                group_signatures = tester.argument_group_signatures
+                for group_sig, argument_sigs in group_signatures:
+                    group = parser.add_argument_group(*group_sig.args,
+                                                      **group_sig.kwargs)
+                    for argument_sig in argument_sigs:
+                        group.add_argument(*argument_sig.args,
+                                           **argument_sig.kwargs)
+                return parser
+
+            def _test(self, tester, parser_text):
+                expected_text = getattr(tester, self.func_suffix)
+                expected_text = textwrap.dedent(expected_text)
+                if expected_text != parser_text:
+                    print(repr(expected_text))
+                    print(repr(parser_text))
+                    for char1, char2 in zip(expected_text, parser_text):
+                        if char1 != char2:
+                            print('first diff: %r %r' % (char1, char2))
+                            break
+                tester.assertEqual(expected_text, parser_text)
+
+            def test_format(self, tester):
+                parser = self._get_parser(tester)
+                format = getattr(parser, 'format_%s' % self.func_suffix)
+                self._test(tester, format())
+
+            def test_print(self, tester):
+                parser = self._get_parser(tester)
+                print_ = getattr(parser, 'print_%s' % self.func_suffix)
+                old_stream = getattr(sys, self.std_name)
+                setattr(sys, self.std_name, StringIO())
+                try:
+                    print_()
+                    parser_text = getattr(sys, self.std_name).getvalue()
+                finally:
+                    setattr(sys, self.std_name, old_stream)
+                self._test(tester, parser_text)
+
+            def test_print_file(self, tester):
+                parser = self._get_parser(tester)
+                print_ = getattr(parser, 'print_%s' % self.func_suffix)
+                sfile = StringIO()
+                print_(sfile)
+                parser_text = sfile.getvalue()
+                self._test(tester, parser_text)
+
+        # add tests for {format,print}_{usage,help,version}
+        for func_suffix, std_name in [('usage', 'stdout'),
+                                      ('help', 'stdout'),
+                                      ('version', 'stderr')]:
+            AddTests(cls, func_suffix, std_name)
+
+bases = TestCase,
+HelpTestCase = TestHelpFormattingMetaclass('HelpTestCase', bases, {})
+
+
+class TestHelpBiggerOptionals(HelpTestCase):
+    """Make sure that argument help aligns when options are longer"""
+
+    parser_signature = Sig(prog='PROG', description='DESCRIPTION',
+                           epilog='EPILOG', version='0.1')
+    argument_signatures = [
+        Sig('-x', action='store_true', help='X HELP'),
+        Sig('--y', help='Y HELP'),
+        Sig('foo', help='FOO HELP'),
+        Sig('bar', help='BAR HELP'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-v] [-x] [--y Y] foo bar
+        '''
+    help = usage + '''\
+
+        DESCRIPTION
+
+        positional arguments:
+          foo            FOO HELP
+          bar            BAR HELP
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -v, --version  show program's version number and exit
+          -x             X HELP
+          --y Y          Y HELP
+
+        EPILOG
+    '''
+    version = '''\
+        0.1
+        '''
+
+
+class TestHelpBiggerOptionalGroups(HelpTestCase):
+    """Make sure that argument help aligns when options are longer"""
+
+    parser_signature = Sig(prog='PROG', description='DESCRIPTION',
+                           epilog='EPILOG', version='0.1')
+    argument_signatures = [
+        Sig('-x', action='store_true', help='X HELP'),
+        Sig('--y', help='Y HELP'),
+        Sig('foo', help='FOO HELP'),
+        Sig('bar', help='BAR HELP'),
+    ]
+    argument_group_signatures = [
+        (Sig('GROUP TITLE', description='GROUP DESCRIPTION'), [
+            Sig('baz', help='BAZ HELP'),
+            Sig('-z', nargs='+', help='Z HELP')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [-v] [-x] [--y Y] [-z Z [Z ...]] foo bar baz
+        '''
+    help = usage + '''\
+
+        DESCRIPTION
+
+        positional arguments:
+          foo            FOO HELP
+          bar            BAR HELP
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -v, --version  show program's version number and exit
+          -x             X HELP
+          --y Y          Y HELP
+
+        GROUP TITLE:
+          GROUP DESCRIPTION
+
+          baz            BAZ HELP
+          -z Z [Z ...]   Z HELP
+
+        EPILOG
+    '''
+    version = '''\
+        0.1
+        '''
+
+
+class TestHelpBiggerPositionals(HelpTestCase):
+    """Make sure that help aligns when arguments are longer"""
+
+    parser_signature = Sig(usage='USAGE', description='DESCRIPTION')
+    argument_signatures = [
+        Sig('-x', action='store_true', help='X HELP'),
+        Sig('--y', help='Y HELP'),
+        Sig('ekiekiekifekang', help='EKI HELP'),
+        Sig('bar', help='BAR HELP'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: USAGE
+        '''
+    help = usage + '''\
+
+        DESCRIPTION
+
+        positional arguments:
+          ekiekiekifekang  EKI HELP
+          bar              BAR HELP
+
+        optional arguments:
+          -h, --help       show this help message and exit
+          -x               X HELP
+          --y Y            Y HELP
+        '''
+
+    version = ''
+
+
+class TestHelpReformatting(HelpTestCase):
+    """Make sure that text after short names starts on the first line"""
+
+    parser_signature = Sig(
+        prog='PROG',
+        description='   oddly    formatted\n'
+                    'description\n'
+                    '\n'
+                    'that is so long that it should go onto multiple '
+                    'lines when wrapped')
+    argument_signatures = [
+        Sig('-x', metavar='XX', help='oddly\n'
+                                     '    formatted -x help'),
+        Sig('y', metavar='yyy', help='normal y help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='\n'
+                                  '    oddly formatted group\n'
+                                  '\n'
+                                  'description'),
+         [Sig('-a', action='store_true',
+              help=' oddly \n'
+                   'formatted    -a  help  \n'
+                   '    again, so long that it should be wrapped over '
+                   'multiple lines')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [-x XX] [-a] yyy
+        '''
+    help = usage + '''\
+
+        oddly formatted description that is so long that it should go onto \
+multiple
+        lines when wrapped
+
+        positional arguments:
+          yyy         normal y help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -x XX       oddly formatted -x help
+
+        title:
+          oddly formatted group description
+
+          -a          oddly formatted -a help again, so long that it should \
+be wrapped
+                      over multiple lines
+        '''
+    version = ''
+
+
+class TestHelpWrappingShortNames(HelpTestCase):
+    """Make sure that text after short names starts on the first line"""
+
+    parser_signature = Sig(prog='PROG', description= 'D\nD' * 30)
+    argument_signatures = [
+        Sig('-x', metavar='XX', help='XHH HX' * 20),
+        Sig('y', metavar='yyy', help='YH YH' * 20),
+    ]
+    argument_group_signatures = [
+        (Sig('ALPHAS'), [
+            Sig('-a', action='store_true', help='AHHH HHA' * 10)]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [-x XX] [-a] yyy
+        '''
+    help = usage + '''\
+
+        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \
+DD DD DD
+        DD DD DD DD D
+
+        positional arguments:
+          yyy         YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \
+YHYH YHYH
+                      YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -x XX       XHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH \
+HXXHH HXXHH
+                      HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HXXHH HX
+
+        ALPHAS:
+          -a          AHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH HHAAHHH \
+HHAAHHH
+                      HHAAHHH HHAAHHH HHA
+        '''
+    version = ''
+
+
+class TestHelpWrappingLongNames(HelpTestCase):
+    """Make sure that text after long names starts on the next line"""
+
+    parser_signature = Sig(usage='USAGE', description= 'D D' * 30,
+                           version='V V'*30)
+    argument_signatures = [
+        Sig('-x', metavar='X' * 25, help='XH XH' * 20),
+        Sig('y', metavar='y' * 25, help='YH YH' * 20),
+    ]
+    argument_group_signatures = [
+        (Sig('ALPHAS'), [
+            Sig('-a', metavar='A' * 25, help='AH AH' * 20),
+            Sig('z', metavar='z' * 25, help='ZH ZH' * 20)]),
+    ]
+    usage = '''\
+        usage: USAGE
+        '''
+    help = usage + '''\
+
+        D DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD DD \
+DD DD DD
+        DD DD DD DD D
+
+        positional arguments:
+          yyyyyyyyyyyyyyyyyyyyyyyyy
+                                YH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH \
+YHYH YHYH
+                                YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YHYH YH
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -v, --version         show program's version number and exit
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+                                XH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH \
+XHXH XHXH
+                                XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XHXH XH
+
+        ALPHAS:
+          -a AAAAAAAAAAAAAAAAAAAAAAAAA
+                                AH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH \
+AHAH AHAH
+                                AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AHAH AH
+          zzzzzzzzzzzzzzzzzzzzzzzzz
+                                ZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH \
+ZHZH ZHZH
+                                ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZHZH ZH
+        '''
+    version = '''\
+        V VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV VV \
+VV VV VV
+        VV VV VV VV V
+        '''
+
+
+class TestHelpUsage(HelpTestCase):
+    """Test basic usage messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-w', nargs='+', help='w'),
+        Sig('-x', nargs='*', help='x'),
+        Sig('a', help='a'),
+        Sig('b', help='b', nargs=2),
+        Sig('c', help='c', nargs='?'),
+    ]
+    argument_group_signatures = [
+        (Sig('group'), [
+            Sig('-y', nargs='?', help='y'),
+            Sig('-z', nargs=3, help='z'),
+            Sig('d', help='d', nargs='*'),
+            Sig('e', help='e', nargs='+'),
+        ])
+    ]
+    usage = '''\
+        usage: PROG [-h] [-w W [W ...]] [-x [X [X ...]]] [-y [Y]] [-z Z Z Z]
+                    a b b [c] [d [d ...]] e [e ...]
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a               a
+          b               b
+          c               c
+
+        optional arguments:
+          -h, --help      show this help message and exit
+          -w W [W ...]    w
+          -x [X [X ...]]  x
+
+        group:
+          -y [Y]          y
+          -z Z Z Z        z
+          d               d
+          e               e
+        '''
+    version = ''
+
+
+class TestHelpOnlyUserGroups(HelpTestCase):
+    """Test basic usage messages"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = []
+    argument_group_signatures = [
+        (Sig('xxxx'), [
+            Sig('-x', help='x'),
+            Sig('a', help='a'),
+        ]),
+        (Sig('yyyy'), [
+            Sig('b', help='b'),
+            Sig('-y', help='y'),
+        ]),
+    ]
+    usage = '''\
+        usage: PROG [-x X] [-y Y] a b
+        '''
+    help = usage + '''\
+
+        xxxx:
+          -x X  x
+          a     a
+
+        yyyy:
+          b     b
+          -y Y  y
+        '''
+    version = ''
+
+
+class TestHelpUsageLongProg(HelpTestCase):
+    """Test usage messages where the prog is long"""
+
+    parser_signature = Sig(prog='P' * 60)
+    argument_signatures = [
+        Sig('-w', metavar='W'),
+        Sig('-x', metavar='X'),
+        Sig('a'),
+        Sig('b'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+               [-h] [-w W] [-x X] a b
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a
+          b
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          -w W
+          -x X
+        '''
+    version = ''
+
+
+class TestHelpUsageLongProgOptionsWrap(HelpTestCase):
+    """Test usage messages where the prog is long and the optionals wrap"""
+
+    parser_signature = Sig(prog='P' * 60)
+    argument_signatures = [
+        Sig('-w', metavar='W' * 25),
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+        Sig('a'),
+        Sig('b'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+               [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \
+[-x XXXXXXXXXXXXXXXXXXXXXXXXX]
+               [-y YYYYYYYYYYYYYYYYYYYYYYYYY] [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+               a b
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a
+          b
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -w WWWWWWWWWWWWWWWWWWWWWWWWW
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsageLongProgPositionalsWrap(HelpTestCase):
+    """Test usage messages where the prog is long and the positionals wrap"""
+
+    parser_signature = Sig(prog='P' * 60, add_help=False)
+    argument_signatures = [
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
+               aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+               ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+        '''
+    version = ''
+
+
+class TestHelpUsageOptionalsWrap(HelpTestCase):
+    """Test usage messages where the optionals wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-w', metavar='W' * 25),
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+        Sig('a'),
+        Sig('b'),
+        Sig('c'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-w WWWWWWWWWWWWWWWWWWWWWWWWW] \
+[-x XXXXXXXXXXXXXXXXXXXXXXXXX]
+                    [-y YYYYYYYYYYYYYYYYYYYYYYYYY] \
+[-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+                    a b c
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          a
+          b
+          c
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -w WWWWWWWWWWWWWWWWWWWWWWWWW
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsagePositionalsWrap(HelpTestCase):
+    """Test usage messages where the positionals wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x'),
+        Sig('-y'),
+        Sig('-z'),
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-x X] [-y Y] [-z Z]
+                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+                    ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -x X
+          -y Y
+          -z Z
+        '''
+    version = ''
+
+
+class TestHelpUsageOptionalsPositionalsWrap(HelpTestCase):
+    """Test usage messages where the optionals and positionals wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \
+[-y YYYYYYYYYYYYYYYYYYYYYYYYY]
+                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+                    aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+                    ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsageOptionalsOnlyWrap(HelpTestCase):
+    """Test usage messages where there are only optionals and they wrap"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x', metavar='X' * 25),
+        Sig('-y', metavar='Y' * 25),
+        Sig('-z', metavar='Z' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-x XXXXXXXXXXXXXXXXXXXXXXXXX] \
+[-y YYYYYYYYYYYYYYYYYYYYYYYYY]
+                    [-z ZZZZZZZZZZZZZZZZZZZZZZZZZ]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help            show this help message and exit
+          -x XXXXXXXXXXXXXXXXXXXXXXXXX
+          -y YYYYYYYYYYYYYYYYYYYYYYYYY
+          -z ZZZZZZZZZZZZZZZZZZZZZZZZZ
+        '''
+    version = ''
+
+
+class TestHelpUsagePositionalsOnlyWrap(HelpTestCase):
+    """Test usage messages where there are only positionals and they wrap"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = [
+        Sig('a' * 25),
+        Sig('b' * 25),
+        Sig('c' * 25),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG aaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbb
+                    ccccccccccccccccccccccccc
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          aaaaaaaaaaaaaaaaaaaaaaaaa
+          bbbbbbbbbbbbbbbbbbbbbbbbb
+          ccccccccccccccccccccccccc
+        '''
+    version = ''
+
+
+class TestHelpVariableExpansion(HelpTestCase):
+    """Test that variables are expanded properly in help messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-x', type=int,
+            help='x %(prog)s %(default)s %(type)s %%'),
+        Sig('-y', action='store_const', default=42, const='XXX',
+            help='y %(prog)s %(default)s %(const)s'),
+        Sig('--foo', choices='abc',
+            help='foo %(prog)s %(default)s %(choices)s'),
+        Sig('--bar', default='baz', choices=[1, 2], metavar='BBB',
+            help='bar %(prog)s %(default)s %(dest)s'),
+        Sig('spam', help='spam %(prog)s %(default)s'),
+        Sig('badger', default=0.5, help='badger %(prog)s %(default)s'),
+    ]
+    argument_group_signatures = [
+        (Sig('group'), [
+            Sig('-a', help='a %(prog)s %(default)s'),
+            Sig('-b', default=-1, help='b %(prog)s %(default)s'),
+        ])
+    ]
+    usage = ('''\
+        usage: PROG [-h] [-x X] [-y] [--foo {a,b,c}] [--bar BBB] [-a A] [-b B]
+                    spam badger
+        ''')
+    help = usage + '''\
+
+        positional arguments:
+          spam           spam PROG None
+          badger         badger PROG 0.5
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -x X           x PROG None int %
+          -y             y PROG 42 XXX
+          --foo {a,b,c}  foo PROG None a, b, c
+          --bar BBB      bar PROG baz bar
+
+        group:
+          -a A           a PROG None
+          -b B           b PROG -1
+        '''
+    version = ''
+
+
+class TestHelpVariableExpansionUsageSupplied(HelpTestCase):
+    """Test that variables are expanded properly when usage= is present"""
+
+    parser_signature = Sig(prog='PROG', usage='%(prog)s FOO')
+    argument_signatures = []
+    argument_group_signatures = []
+    usage = ('''\
+        usage: PROG FOO
+        ''')
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+        '''
+    version = ''
+
+
+class TestHelpVariableExpansionNoArguments(HelpTestCase):
+    """Test that variables are expanded properly with no arguments"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = []
+    argument_group_signatures = []
+    usage = ('''\
+        usage: PROG
+        ''')
+    help = usage
+    version = ''
+
+
+class TestHelpSuppressUsage(HelpTestCase):
+    """Test that items can be suppressed in usage messages"""
+
+    parser_signature = Sig(prog='PROG', usage=argparse.SUPPRESS)
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    help = '''\
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    usage = ''
+    version = ''
+
+
+class TestHelpSuppressOptional(HelpTestCase):
+    """Test that optional arguments can be suppressed in help messages"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = [
+        Sig('--foo', help=argparse.SUPPRESS),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam  spam help
+        '''
+    version = ''
+
+
+class TestHelpSuppressOptionalGroup(HelpTestCase):
+    """Test that optional groups can be suppressed in help messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = [
+        (Sig('group'), [Sig('--bar', help=argparse.SUPPRESS)]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    version = ''
+
+
+class TestHelpSuppressPositional(HelpTestCase):
+    """Test that positional arguments can be suppressed in help messages"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help=argparse.SUPPRESS),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [--foo FOO]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    version = ''
+
+
+class TestHelpRequiredOptional(HelpTestCase):
+    """Test that required options don't look optional"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo', required=True, help='foo help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] --foo FOO
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help
+        '''
+    version = ''
+
+
+class TestHelpAlternatePrefixChars(HelpTestCase):
+    """Test that options display with different prefix characters"""
+
+    parser_signature = Sig(prog='PROG', prefix_chars='^;', add_help=False)
+    argument_signatures = [
+        Sig('^^foo', action='store_true', help='foo help'),
+        Sig(';b', ';;bar', help='bar help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [^^foo] [;b BAR]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          ^^foo              foo help
+          ;b BAR, ;;bar BAR  bar help
+        '''
+    version = ''
+
+
+class TestHelpNoHelpOptional(HelpTestCase):
+    """Test that the --help argument can be suppressed help messages"""
+
+    parser_signature = Sig(prog='PROG', add_help=False)
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam       spam help
+
+        optional arguments:
+          --foo FOO  foo help
+        '''
+    version = ''
+
+
+class TestHelpVersionOptional(HelpTestCase):
+    """Test that the --version argument can be suppressed help messages"""
+
+    parser_signature = Sig(prog='PROG', version='1.0')
+    argument_signatures = [
+        Sig('--foo', help='foo help'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-v] [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam           spam help
+
+        optional arguments:
+          -h, --help     show this help message and exit
+          -v, --version  show program's version number and exit
+          --foo FOO      foo help
+        '''
+    version = '''\
+        1.0
+        '''
+
+
+class TestHelpNone(HelpTestCase):
+    """Test that no errors occur if no help is specified"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('--foo'),
+        Sig('spam'),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] spam
+        '''
+    help = usage + '''\
+
+        positional arguments:
+          spam
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO
+        '''
+    version = ''
+
+
+class TestHelpTupleMetavar(HelpTestCase):
+    """Test specifying metavar as a tuple"""
+
+    parser_signature = Sig(prog='PROG')
+    argument_signatures = [
+        Sig('-w', help='w', nargs='+', metavar=('W1', 'W2')),
+        Sig('-x', help='x', nargs='*', metavar=('X1', 'X2')),
+        Sig('-y', help='y', nargs=3, metavar=('Y1', 'Y2', 'Y3')),
+        Sig('-z', help='z', nargs='?', metavar=('Z1', )),
+    ]
+    argument_group_signatures = []
+    usage = '''\
+        usage: PROG [-h] [-w W1 [W2 ...]] [-x [X1 [X2 ...]]] [-y Y1 Y2 Y3] \
+[-z [Z1]]
+        '''
+    help = usage + '''\
+
+        optional arguments:
+          -h, --help        show this help message and exit
+          -w W1 [W2 ...]    w
+          -x [X1 [X2 ...]]  x
+          -y Y1 Y2 Y3       y
+          -z [Z1]           z
+        '''
+    version = ''
+
+
+class TestHelpRawText(HelpTestCase):
+    """Test the RawTextHelpFormatter"""
+
+    parser_signature = Sig(
+        prog='PROG', formatter_class=argparse.RawTextHelpFormatter,
+        description='Keep the formatting\n'
+                    '    exactly as it is written\n'
+                    '\n'
+                    'here\n')
+
+    argument_signatures = [
+        Sig('--foo', help='    foo help should also\n'
+                          'appear as given here'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='    This text\n'
+                                  '  should be indented\n'
+                                  '    exactly like it is here\n'),
+         [Sig('--bar', help='bar help')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] [--bar BAR] spam
+        '''
+    help = usage + '''\
+
+        Keep the formatting
+            exactly as it is written
+
+        here
+
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO       foo help should also
+                      appear as given here
+
+        title:
+              This text
+            should be indented
+              exactly like it is here
+
+          --bar BAR   bar help
+        '''
+    version = ''
+
+
+class TestHelpRawDescription(HelpTestCase):
+    """Test the RawTextHelpFormatter"""
+
+    parser_signature = Sig(
+        prog='PROG', formatter_class=argparse.RawDescriptionHelpFormatter,
+        description='Keep the formatting\n'
+                    '    exactly as it is written\n'
+                    '\n'
+                    'here\n')
+
+    argument_signatures = [
+        Sig('--foo', help='  foo help should not\n'
+                          '    retain this odd formatting'),
+        Sig('spam', help='spam help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='    This text\n'
+                                  '  should be indented\n'
+                                  '    exactly like it is here\n'),
+         [Sig('--bar', help='bar help')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] [--bar BAR] spam
+        '''
+    help = usage + '''\
+
+        Keep the formatting
+            exactly as it is written
+
+        here
+
+        positional arguments:
+          spam        spam help
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help should not retain this odd formatting
+
+        title:
+              This text
+            should be indented
+              exactly like it is here
+
+          --bar BAR   bar help
+        '''
+    version = ''
+
+
+class TestHelpArgumentDefaults(HelpTestCase):
+    """Test the ArgumentDefaultsHelpFormatter"""
+
+    parser_signature = Sig(
+        prog='PROG', formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description='description')
+
+    argument_signatures = [
+        Sig('--foo', help='foo help - oh and by the way, %(default)s'),
+        Sig('--bar', action='store_true', help='bar help'),
+        Sig('spam', help='spam help'),
+        Sig('badger', nargs='?', default='wooden', help='badger help'),
+    ]
+    argument_group_signatures = [
+        (Sig('title', description='description'),
+         [Sig('--baz', type=int, default=42, help='baz help')]),
+    ]
+    usage = '''\
+        usage: PROG [-h] [--foo FOO] [--bar] [--baz BAZ] spam [badger]
+        '''
+    help = usage + '''\
+
+        description
+
+        positional arguments:
+          spam        spam help
+          badger      badger help (default: wooden)
+
+        optional arguments:
+          -h, --help  show this help message and exit
+          --foo FOO   foo help - oh and by the way, None
+          --bar       bar help (default: False)
+
+        title:
+          description
+
+          --baz BAZ   baz help (default: 42)
+        '''
+    version = ''
+
+# =====================================
+# Optional/Positional constructor tests
+# =====================================
+
+class TestInvalidArgumentConstructors(TestCase):
+    """Test a bunch of invalid Argument constructors"""
+
+    def assertTypeError(self, *args, **kwargs):
+        parser = argparse.ArgumentParser()
+        self.assertRaises(TypeError, parser.add_argument,
+                          *args, **kwargs)
+
+    def assertValueError(self, *args, **kwargs):
+        parser = argparse.ArgumentParser()
+        self.assertRaises(ValueError, parser.add_argument,
+                          *args, **kwargs)
+
+    def test_invalid_keyword_arguments(self):
+        self.assertTypeError('-x', bar=None)
+        self.assertTypeError('-y', callback='foo')
+        self.assertTypeError('-y', callback_args=())
+        self.assertTypeError('-y', callback_kwargs={})
+
+    def test_missing_destination(self):
+        self.assertTypeError()
+        for action in ['append', 'store']:
+            self.assertTypeError(action=action)
+
+    def test_invalid_option_strings(self):
+        self.assertValueError('--')
+        self.assertValueError('---')
+
+    def test_invalid_type(self):
+        self.assertValueError('--foo', type='int')
+
+    def test_invalid_action(self):
+        self.assertValueError('-x', action='foo')
+        self.assertValueError('foo', action='baz')
+        parser = argparse.ArgumentParser()
+        try:
+            parser.add_argument("--foo", action="store-true")
+        except ValueError:
+            e = sys.exc_info()[1]
+            expected = 'unknown action'
+            msg = 'expected %r, found %r' % (expected, e)
+            self.assertTrue(expected in str(e), msg)
+
+    def test_multiple_dest(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument(dest='foo')
+        try:
+            parser.add_argument('bar', dest='baz')
+        except ValueError:
+            e = sys.exc_info()[1]
+            expected = 'dest supplied twice for positional argument'
+            msg = 'expected %r, found %r' % (expected, e)
+            self.assertTrue(expected in str(e), msg)
+
+    def test_no_argument_actions(self):
+        for action in ['store_const', 'store_true', 'store_false',
+                       'append_const', 'count']:
+            for attrs in [dict(type=int), dict(nargs='+'),
+                          dict(choices='ab')]:
+                self.assertTypeError('-x', action=action, **attrs)
+
+    def test_no_argument_no_const_actions(self):
+        # options with zero arguments
+        for action in ['store_true', 'store_false', 'count']:
+
+            # const is always disallowed
+            self.assertTypeError('-x', const='foo', action=action)
+
+            # nargs is always disallowed
+            self.assertTypeError('-x', nargs='*', action=action)
+
+    def test_more_than_one_argument_actions(self):
+        for action in ['store', 'append']:
+
+            # nargs=0 is disallowed
+            self.assertValueError('-x', nargs=0, action=action)
+            self.assertValueError('spam', nargs=0, action=action)
+
+            # const is disallowed with non-optional arguments
+            for nargs in [1, '*', '+']:
+                self.assertValueError('-x', const='foo',
+                                      nargs=nargs, action=action)
+                self.assertValueError('spam', const='foo',
+                                      nargs=nargs, action=action)
+
+    def test_required_const_actions(self):
+        for action in ['store_const', 'append_const']:
+
+            # nargs is always disallowed
+            self.assertTypeError('-x', nargs='+', action=action)
+
+    def test_parsers_action_missing_params(self):
+        self.assertTypeError('command', action='parsers')
+        self.assertTypeError('command', action='parsers', prog='PROG')
+        self.assertTypeError('command', action='parsers',
+                             parser_class=argparse.ArgumentParser)
+
+    def test_required_positional(self):
+        self.assertTypeError('foo', required=True)
+
+    def test_user_defined_action(self):
+
+        class Success(Exception):
+            pass
+
+        class Action(object):
+
+            def __init__(self,
+                         option_strings,
+                         dest,
+                         const,
+                         default,
+                         required=False):
+                if dest == 'spam':
+                    if const is Success:
+                        if default is Success:
+                            raise Success()
+
+            def __call__(self, *args, **kwargs):
+                pass
+
+        parser = argparse.ArgumentParser()
+        self.assertRaises(Success, parser.add_argument, '--spam',
+                          action=Action, default=Success, const=Success)
+        self.assertRaises(Success, parser.add_argument, 'spam',
+                          action=Action, default=Success, const=Success)
+
+# ================================
+# Actions returned by add_argument
+# ================================
+
+class TestActionsReturned(TestCase):
+
+    def test_dest(self):
+        parser = argparse.ArgumentParser()
+        action = parser.add_argument('--foo')
+        self.assertEqual(action.dest, 'foo')
+        action = parser.add_argument('-b', '--bar')
+        self.assertEqual(action.dest, 'bar')
+        action = parser.add_argument('-x', '-y')
+        self.assertEqual(action.dest, 'x')
+
+    def test_misc(self):
+        parser = argparse.ArgumentParser()
+        action = parser.add_argument('--foo', nargs='?', const=42,
+                                     default=84, type=int, choices=[1, 2],
+                                     help='FOO', metavar='BAR', dest='baz')
+        self.assertEqual(action.nargs, '?')
+        self.assertEqual(action.const, 42)
+        self.assertEqual(action.default, 84)
+        self.assertEqual(action.type, int)
+        self.assertEqual(action.choices, [1, 2])
+        self.assertEqual(action.help, 'FOO')
+        self.assertEqual(action.metavar, 'BAR')
+        self.assertEqual(action.dest, 'baz')
+
+
+# ================================
+# Argument conflict handling tests
+# ================================
+
+class TestConflictHandling(TestCase):
+
+    def test_bad_type(self):
+        self.assertRaises(ValueError, argparse.ArgumentParser,
+                          conflict_handler='foo')
+
+    def test_conflict_error(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-x')
+        self.assertRaises(argparse.ArgumentError,
+                          parser.add_argument, '-x')
+        parser.add_argument('--spam')
+        self.assertRaises(argparse.ArgumentError,
+                          parser.add_argument, '--spam')
+
+    def test_resolve_error(self):
+        get_parser = argparse.ArgumentParser
+        parser = get_parser(prog='PROG', conflict_handler='resolve')
+
+        parser.add_argument('-x', help='OLD X')
+        parser.add_argument('-x', help='NEW X')
+        self.assertEqual(parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [-x X]
+
+            optional arguments:
+              -h, --help  show this help message and exit
+              -x X        NEW X
+            '''))
+
+        parser.add_argument('--spam', metavar='OLD_SPAM')
+        parser.add_argument('--spam', metavar='NEW_SPAM')
+        self.assertEqual(parser.format_help(), textwrap.dedent('''\
+            usage: PROG [-h] [-x X] [--spam NEW_SPAM]
+
+            optional arguments:
+              -h, --help       show this help message and exit
+              -x X             NEW X
+              --spam NEW_SPAM
+            '''))
+
+
+# =============================
+# Help and Version option tests
+# =============================
+
+class TestOptionalsHelpVersionActions(TestCase):
+    """Test the help and version actions"""
+
+    def _get_error(self, func, *args, **kwargs):
+        try:
+            func(*args, **kwargs)
+        except ArgumentParserError:
+            return sys.exc_info()[1]
+        else:
+            self.assertRaises(ArgumentParserError, func, *args, **kwargs)
+
+    def assertPrintHelpExit(self, parser, args_str):
+        self.assertEqual(
+            parser.format_help(),
+            self._get_error(parser.parse_args, args_str.split()).stdout)
+
+    def assertPrintVersionExit(self, parser, args_str):
+        self.assertEqual(
+            parser.format_version(),
+            self._get_error(parser.parse_args, args_str.split()).stderr)
+
+    def assertArgumentParserError(self, parser, *args):
+        self.assertRaises(ArgumentParserError, parser.parse_args, args)
+
+    def test_version(self):
+        parser = ErrorRaisingArgumentParser(version='1.0')
+        self.assertPrintHelpExit(parser, '-h')
+        self.assertPrintHelpExit(parser, '--help')
+        self.assertPrintVersionExit(parser, '-v')
+        self.assertPrintVersionExit(parser, '--version')
+
+    def test_version_format(self):
+        parser = ErrorRaisingArgumentParser(prog='PPP', version='%(prog)s 3.5')
+        msg = self._get_error(parser.parse_args, ['-v']).stderr
+        self.assertEqual('PPP 3.5\n', msg)
+
+    def test_version_no_help(self):
+        parser = ErrorRaisingArgumentParser(add_help=False, version='1.0')
+        self.assertArgumentParserError(parser, '-h')
+        self.assertArgumentParserError(parser, '--help')
+        self.assertPrintVersionExit(parser, '-v')
+        self.assertPrintVersionExit(parser, '--version')
+
+    def test_version_action(self):
+        parser = ErrorRaisingArgumentParser(prog='XXX')
+        parser.add_argument('-V', action='version', version='%(prog)s 3.7')
+        msg = self._get_error(parser.parse_args, ['-V']).stderr
+        self.assertEqual('XXX 3.7\n', msg)
+
+    def test_no_help(self):
+        parser = ErrorRaisingArgumentParser(add_help=False)
+        self.assertArgumentParserError(parser, '-h')
+        self.assertArgumentParserError(parser, '--help')
+        self.assertArgumentParserError(parser, '-v')
+        self.assertArgumentParserError(parser, '--version')
+
+    def test_alternate_help_version(self):
+        parser = ErrorRaisingArgumentParser()
+        parser.add_argument('-x', action='help')
+        parser.add_argument('-y', action='version')
+        self.assertPrintHelpExit(parser, '-x')
+        self.assertPrintVersionExit(parser, '-y')
+        self.assertArgumentParserError(parser, '-v')
+        self.assertArgumentParserError(parser, '--version')
+
+    def test_help_version_extra_arguments(self):
+        parser = ErrorRaisingArgumentParser(version='1.0')
+        parser.add_argument('-x', action='store_true')
+        parser.add_argument('y')
+
+        # try all combinations of valid prefixes and suffixes
+        valid_prefixes = ['', '-x', 'foo', '-x bar', 'baz -x']
+        valid_suffixes = valid_prefixes + ['--bad-option', 'foo bar baz']
+        for prefix in valid_prefixes:
+            for suffix in valid_suffixes:
+                format = '%s %%s %s' % (prefix, suffix)
+            self.assertPrintHelpExit(parser, format % '-h')
+            self.assertPrintHelpExit(parser, format % '--help')
+            self.assertPrintVersionExit(parser, format % '-v')
+            self.assertPrintVersionExit(parser, format % '--version')
+
+
+# ======================
+# str() and repr() tests
+# ======================
+
+class TestStrings(TestCase):
+    """Test str()  and repr() on Optionals and Positionals"""
+
+    def assertStringEqual(self, obj, result_string):
+        for func in [str, repr]:
+            self.assertEqual(func(obj), result_string)
+
+    def test_optional(self):
+        option = argparse.Action(
+            option_strings=['--foo', '-a', '-b'],
+            dest='b',
+            type='int',
+            nargs='+',
+            default=42,
+            choices=[1, 2, 3],
+            help='HELP',
+            metavar='METAVAR')
+        string = (
+            "Action(option_strings=['--foo', '-a', '-b'], dest='b', "
+            "nargs='+', const=None, default=42, type='int', "
+            "choices=[1, 2, 3], help='HELP', metavar='METAVAR')")
+        self.assertStringEqual(option, string)
+
+    def test_argument(self):
+        argument = argparse.Action(
+            option_strings=[],
+            dest='x',
+            type=float,
+            nargs='?',
+            default=2.5,
+            choices=[0.5, 1.5, 2.5],
+            help='H HH H',
+            metavar='MV MV MV')
+        string = (
+            "Action(option_strings=[], dest='x', nargs='?', "
+            "const=None, default=2.5, type=%r, choices=[0.5, 1.5, 2.5], "
+            "help='H HH H', metavar='MV MV MV')" % float)
+        self.assertStringEqual(argument, string)
+
+    def test_namespace(self):
+        ns = argparse.Namespace(foo=42, bar='spam')
+        string = "Namespace(bar='spam', foo=42)"
+        self.assertStringEqual(ns, string)
+
+    def test_parser(self):
+        parser = argparse.ArgumentParser(prog='PROG')
+        string = (
+            "ArgumentParser(prog='PROG', usage=None, description=None, "
+            "version=None, formatter_class=%r, conflict_handler='error', "
+            "add_help=True)" % argparse.HelpFormatter)
+        self.assertStringEqual(parser, string)
+
+# ===============
+# Namespace tests
+# ===============
+
+class TestNamespace(TestCase):
+
+    def test_constructor(self):
+        ns = argparse.Namespace()
+        self.assertRaises(AttributeError, getattr, ns, 'x')
+
+        ns = argparse.Namespace(a=42, b='spam')
+        self.assertEqual(ns.a, 42)
+        self.assertEqual(ns.b, 'spam')
+
+    def test_equality(self):
+        ns1 = argparse.Namespace(a=1, b=2)
+        ns2 = argparse.Namespace(b=2, a=1)
+        ns3 = argparse.Namespace(a=1)
+        ns4 = argparse.Namespace(b=2)
+
+        self.assertEqual(ns1, ns2)
+        self.assertNotEqual(ns1, ns3)
+        self.assertNotEqual(ns1, ns4)
+        self.assertNotEqual(ns2, ns3)
+        self.assertNotEqual(ns2, ns4)
+        self.assertTrue(ns1 != ns3)
+        self.assertTrue(ns1 != ns4)
+        self.assertTrue(ns2 != ns3)
+        self.assertTrue(ns2 != ns4)
+
+
+# ===================
+# File encoding tests
+# ===================
+
+class TestEncoding(TestCase):
+
+    def _test_module_encoding(self, path):
+        path, _ = os.path.splitext(path)
+        path += ".py"
+        codecs.open(path, 'r', 'utf8').read()
+
+    def test_argparse_module_encoding(self):
+        self._test_module_encoding(argparse.__file__)
+
+    def test_test_argparse_module_encoding(self):
+        self._test_module_encoding(__file__)
+
+# ===================
+# ArgumentError tests
+# ===================
+
+class TestArgumentError(TestCase):
+
+    def test_argument_error(self):
+        msg = "my error here"
+        error = argparse.ArgumentError(None, msg)
+        self.assertEqual(str(error), msg)
+
+# =======================
+# ArgumentTypeError tests
+# =======================
+
+class TestArgumentError(TestCase):
+
+    def test_argument_type_error(self):
+
+        def spam(string):
+            raise argparse.ArgumentTypeError('spam!')
+
+        parser = ErrorRaisingArgumentParser(prog='PROG', add_help=False)
+        parser.add_argument('x', type=spam)
+        try:
+            parser.parse_args(['XXX'])
+        except ArgumentParserError:
+            expected = 'usage: PROG x\nPROG: error: argument x: spam!\n'
+            msg = sys.exc_info()[1].stderr
+            self.assertEqual(expected, msg)
+        else:
+            self.fail()
+
+# ======================
+# parse_known_args tests
+# ======================
+
+class TestParseKnownArgs(TestCase):
+
+    def test_optionals(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument('--foo')
+        args, extras = parser.parse_known_args('--foo F --bar --baz'.split())
+        self.assertEqual(NS(foo='F'), args)
+        self.assertEqual(['--bar', '--baz'], extras)
+
+    def test_mixed(self):
+        parser = argparse.ArgumentParser()
+        parser.add_argument('-v', nargs='?', const=1, type=int)
+        parser.add_argument('--spam', action='store_false')
+        parser.add_argument('badger')
+
+        argv = ["B", "C", "--foo", "-v", "3", "4"]
+        args, extras = parser.parse_known_args(argv)
+        self.assertEqual(NS(v=3, spam=True, badger="B"), args)
+        self.assertEqual(["C", "--foo", "4"], extras)
+
+# ============================
+# from argparse import * tests
+# ============================
+
+class TestImportStar(TestCase):
+
+    def test(self):
+        for name in argparse.__all__:
+            self.assertTrue(hasattr(argparse, name))
+
+def test_main():
+    with warnings.catch_warnings():
+        # silence Python 2.6 buggy warnings about Exception.message
+        warnings.filterwarnings(
+            action='ignore',
+            message='BaseException.message has been deprecated as of'
+            'Python 2.6',
+            category=DeprecationWarning)
+        # silence warnings about version argument - these are expected
+        warnings.filterwarnings(
+            action='ignore',
+            message='The "version" argument to ArgumentParser is deprecated.',
+            category=DeprecationWarning)
+        warnings.filterwarnings(
+            action='ignore',
+            message='The format_version method is deprecated',
+            category=DeprecationWarning)
+        warnings.filterwarnings(
+            action='ignore',
+            message='The print_version method is deprecated',
+            category=DeprecationWarning)
+
+        support.run_unittest(__name__)
+
+
+if __name__ == '__main__':
+    test_main()