mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
431 lines
13 KiB
Python
431 lines
13 KiB
Python
# This source file is part of the Swift.org open source project
|
|
#
|
|
# Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
|
|
# Licensed under Apache License v2.0 with Runtime Library Exception
|
|
#
|
|
# See https://swift.org/LICENSE.txt for license information
|
|
# See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
|
|
|
|
from ..utils import TestCase, redirect_stderr
|
|
from ...build_swift.argparse import (
|
|
ArgumentParser, BoolType, Nargs, PathType, SUPPRESS, actions)
|
|
|
|
|
|
# -----------------------------------------------------------------------------
|
|
|
|
class TestAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.Action(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.option_strings, ['--foo'])
|
|
self.assertEqual(action.dests, ['foo'])
|
|
self.assertEqual(action.const, None)
|
|
self.assertEqual(action.default, None)
|
|
self.assertEqual(action.type, None)
|
|
self.assertEqual(action.choices, None)
|
|
self.assertEqual(action.required, False)
|
|
self.assertEqual(action.help, None)
|
|
self.assertEqual(action.metavar, None)
|
|
self.assertEqual(action.dest, SUPPRESS)
|
|
|
|
def test_single_destination(self):
|
|
action = actions.Action(['--foo'], 'foo')
|
|
|
|
self.assertEqual(action.dests, ['foo'])
|
|
|
|
def test_multiple_destinations(self):
|
|
action = actions.Action(['--foo'], ['foo', 'bar'])
|
|
|
|
self.assertEqual(action.dests, ['foo', 'bar'])
|
|
|
|
def test_supports_dest_argument(self):
|
|
with self.assertNotRaises(Exception):
|
|
action = actions.Action([], [], dest='foo')
|
|
|
|
self.assertEqual(action.dest, SUPPRESS)
|
|
|
|
def test_call_not_implemented(self):
|
|
action = actions.Action([], [])
|
|
|
|
with self.assertRaises(NotImplementedError):
|
|
action(None, None, None, None)
|
|
|
|
|
|
class TestAppendAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.AppendAction(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.SINGLE)
|
|
self.assertEqual(action.default, [])
|
|
|
|
def test_default_value(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.AppendAction)
|
|
|
|
args = parser.parse_args([])
|
|
self.assertEqual(args.foo, [])
|
|
|
|
def test_append(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.AppendAction)
|
|
|
|
args = parser.parse_args(['--foo', 'bar', '--foo', 'baz'])
|
|
self.assertEqual(args.foo, ['bar', 'baz'])
|
|
|
|
|
|
class TestCustomCallAction(TestCase):
|
|
|
|
def test_non_callable(self):
|
|
with self.assertRaises(TypeError):
|
|
actions.CustomCallAction('--foo', dests=['foo'], call_func=None)
|
|
|
|
def test_custom_call_func(self):
|
|
def test_func(action, parser, namespace, values, option_string=None):
|
|
for dest in action.dests:
|
|
setattr(namespace, dest, values)
|
|
|
|
parser = ArgumentParser()
|
|
parser.add_argument(
|
|
'--foo',
|
|
action=actions.CustomCallAction,
|
|
call_func=test_func,
|
|
nargs=Nargs.SINGLE)
|
|
|
|
args = parser.parse_args(['--foo', 'boo'])
|
|
|
|
self.assertEqual(args.foo, 'boo')
|
|
|
|
|
|
class TestStoreAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.StoreAction(['--foo'], dests=['foo'], choices=['bar'])
|
|
self.assertEqual(action.nargs, Nargs.OPTIONAL)
|
|
|
|
action = actions.StoreAction(['--foo'], dests=['foo'], const='bar')
|
|
self.assertEqual(action.nargs, Nargs.ZERO)
|
|
|
|
def test_choices(self):
|
|
parser = ArgumentParser()
|
|
action = parser.add_argument(
|
|
'--foo',
|
|
action=actions.StoreAction,
|
|
choices=['bar', 'baz'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.OPTIONAL)
|
|
|
|
with self.quietOutput(), self.assertRaises(SystemExit):
|
|
parser.parse_args(['--foo', 'qux'])
|
|
|
|
args = parser.parse_args(['--foo', 'bar'])
|
|
|
|
self.assertEqual(args.foo, 'bar')
|
|
|
|
def test_store_value(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreAction)
|
|
|
|
args = parser.parse_args(['--foo', 'bar'])
|
|
|
|
self.assertEqual(args.foo, 'bar')
|
|
|
|
def test_store_const(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreAction, const='bar')
|
|
|
|
args = parser.parse_args(['--foo'])
|
|
|
|
self.assertEqual(args.foo, 'bar')
|
|
|
|
def test_store_value_multiple_destinations(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument(
|
|
'--foo',
|
|
dests=['foo', 'bar'],
|
|
action=actions.StoreAction)
|
|
|
|
args = parser.parse_args(['--foo', 'baz'])
|
|
|
|
self.assertEqual(args.foo, 'baz')
|
|
self.assertEqual(args.bar, 'baz')
|
|
|
|
def test_store_const_multiple_destinations(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument(
|
|
'--foo',
|
|
dests=['foo', 'bar'],
|
|
action=actions.StoreAction,
|
|
const='baz')
|
|
|
|
args = parser.parse_args(['--foo'])
|
|
|
|
self.assertEqual(args.foo, 'baz')
|
|
self.assertEqual(args.bar, 'baz')
|
|
|
|
|
|
class TestStoreIntAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.StoreIntAction(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.SINGLE)
|
|
self.assertEqual(action.type, int)
|
|
self.assertEqual(action.metavar, 'N')
|
|
|
|
def test_valid_int(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreIntAction)
|
|
|
|
for i in [0, 1, 42, -64]:
|
|
args = parser.parse_args(['--foo', str(i)])
|
|
self.assertEqual(args.foo, i)
|
|
|
|
def test_invalid_int(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreIntAction)
|
|
|
|
for i in [0.0, True, 'bar']:
|
|
with self.quietOutput(), self.assertRaises(SystemExit):
|
|
parser.parse_args(['--foo', str(i)])
|
|
|
|
|
|
class TestStoreTrueAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.StoreTrueAction(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.ZERO)
|
|
self.assertEqual(action.const, True)
|
|
self.assertEqual(action.default, False)
|
|
|
|
def test_default_value(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreTrueAction)
|
|
|
|
args = parser.parse_args([])
|
|
|
|
self.assertFalse(args.foo)
|
|
|
|
def test_store_true(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreTrueAction)
|
|
|
|
args = parser.parse_args(['--foo'])
|
|
|
|
self.assertTrue(args.foo)
|
|
|
|
|
|
class TestStoreFalseAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.StoreFalseAction(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.ZERO)
|
|
self.assertEqual(action.const, False)
|
|
self.assertEqual(action.default, True)
|
|
|
|
def test_default_value(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreFalseAction)
|
|
|
|
args = parser.parse_args([])
|
|
|
|
self.assertTrue(args.foo)
|
|
|
|
def test_store_false(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.StoreFalseAction)
|
|
|
|
args = parser.parse_args(['--foo'])
|
|
|
|
self.assertFalse(args.foo)
|
|
|
|
|
|
class TestStorePathAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.StorePathAction(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.SINGLE)
|
|
self.assertIsInstance(action.type, PathType)
|
|
|
|
def test_exists(self):
|
|
action = actions.StorePathAction(['--foo'], dests=['foo'], exists=True)
|
|
|
|
self.assertTrue(action.type._assert_exists)
|
|
|
|
def test_executable(self):
|
|
action = actions.StorePathAction(['--foo'], dests=['foo'],
|
|
executable=True)
|
|
|
|
self.assertTrue(action.type._assert_executable)
|
|
|
|
|
|
class TestToggleTrueAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.ToggleTrueAction(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.OPTIONAL)
|
|
self.assertEqual(action.on_value, True)
|
|
self.assertEqual(action.off_value, False)
|
|
self.assertEqual(action.metavar, 'BOOL')
|
|
|
|
def test_default_value(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleTrueAction)
|
|
|
|
args = parser.parse_args([])
|
|
|
|
self.assertFalse(args.foo)
|
|
|
|
def test_with_no_arg(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleTrueAction)
|
|
|
|
args = parser.parse_args(['--foo'])
|
|
|
|
self.assertTrue(args.foo)
|
|
|
|
def test_with_optional_true_arg(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleTrueAction)
|
|
|
|
for value in BoolType.TRUE_VALUES:
|
|
args = parser.parse_args(['--foo', str(value)])
|
|
self.assertTrue(args.foo)
|
|
|
|
args = parser.parse_args(['--foo={}'.format(value)])
|
|
self.assertTrue(args.foo)
|
|
|
|
def test_with_optional_false_arg(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleTrueAction)
|
|
|
|
for value in BoolType.FALSE_VALUES:
|
|
args = parser.parse_args(['--foo', str(value)])
|
|
self.assertFalse(args.foo)
|
|
|
|
args = parser.parse_args(['--foo={}'.format(value)])
|
|
self.assertFalse(args.foo)
|
|
|
|
def test_last_wins(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleTrueAction)
|
|
|
|
args = parser.parse_args(['--foo=TRUE', '--foo', 'FALSE'])
|
|
self.assertFalse(args.foo)
|
|
|
|
args = parser.parse_args(['--foo=FALSE', '--foo'])
|
|
self.assertTrue(args.foo)
|
|
|
|
args = parser.parse_args(['--foo=FALSE', '--foo', 'TRUE'])
|
|
self.assertTrue(args.foo)
|
|
|
|
|
|
class TestToggleFalseAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.ToggleFalseAction(['--foo'], dests=['foo'])
|
|
|
|
self.assertEqual(action.nargs, Nargs.OPTIONAL)
|
|
self.assertEqual(action.on_value, False)
|
|
self.assertEqual(action.off_value, True)
|
|
self.assertEqual(action.metavar, 'BOOL')
|
|
|
|
def test_default_value(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleFalseAction)
|
|
|
|
args = parser.parse_args([])
|
|
|
|
self.assertTrue(args.foo)
|
|
|
|
def test_with_no_arg(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleFalseAction)
|
|
|
|
args = parser.parse_args(['--foo'])
|
|
|
|
self.assertFalse(args.foo)
|
|
|
|
def test_with_optional_true_arg(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleFalseAction)
|
|
|
|
for value in BoolType.TRUE_VALUES:
|
|
args = parser.parse_args(['--foo', str(value)])
|
|
self.assertFalse(args.foo)
|
|
|
|
args = parser.parse_args(['--foo={}'.format(value)])
|
|
self.assertFalse(args.foo)
|
|
|
|
def test_with_optional_false_arg(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleFalseAction)
|
|
|
|
for value in BoolType.FALSE_VALUES:
|
|
args = parser.parse_args(['--foo', str(value)])
|
|
self.assertTrue(args.foo)
|
|
|
|
args = parser.parse_args(['--foo={}'.format(value)])
|
|
self.assertTrue(args.foo)
|
|
|
|
def test_last_wins(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.ToggleFalseAction)
|
|
|
|
args = parser.parse_args(['--foo=TRUE', '--foo', 'FALSE'])
|
|
self.assertTrue(args.foo)
|
|
|
|
args = parser.parse_args(['--foo=FALSE', '--foo'])
|
|
self.assertFalse(args.foo)
|
|
|
|
args = parser.parse_args(['--foo=FALSE', '--foo', 'TRUE'])
|
|
self.assertFalse(args.foo)
|
|
|
|
|
|
class TestUnuspportedAction(TestCase):
|
|
|
|
def test_default_attributes(self):
|
|
action = actions.UnsupportedAction(['--foo'])
|
|
|
|
self.assertEqual(action.dests, [])
|
|
self.assertEqual(action.nargs, Nargs.ZERO)
|
|
self.assertEqual(action.default, SUPPRESS)
|
|
self.assertEqual(action.message, None)
|
|
|
|
def test_suppressed_default_value(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.UnsupportedAction)
|
|
|
|
args = parser.parse_args([])
|
|
|
|
self.assertFalse(hasattr(args, 'foo'))
|
|
|
|
def test_raises_parser_error(self):
|
|
parser = ArgumentParser()
|
|
parser.add_argument('--foo', action=actions.UnsupportedAction)
|
|
|
|
with self.quietOutput(), self.assertRaises(SystemExit):
|
|
parser.parse_args(['--foo'])
|
|
|
|
def test_custom_error_message(self):
|
|
message = 'custom error message'
|
|
|
|
parser = ArgumentParser()
|
|
action = parser.add_argument(
|
|
'--foo',
|
|
action=actions.UnsupportedAction,
|
|
message=message)
|
|
|
|
self.assertEqual(action.message, message)
|
|
|
|
with redirect_stderr() as stderr, self.assertRaises(SystemExit):
|
|
parser.parse_args(['--foo'])
|
|
|
|
self.assertIn(message, stderr)
|