| # tests/arguments.py --------------------------------------------*- python -*- |
| # |
| # This source file is part of the Swift.org open source project |
| # |
| # Copyright (c) 2014 - 2017 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 |
| # |
| # ---------------------------------------------------------------------------- |
| |
| import argparse |
| import os |
| import sys |
| import unittest |
| try: |
| # py2 |
| from StringIO import StringIO |
| except ImportError: |
| # py3 |
| from io import StringIO |
| |
| from swift_build_support.arguments import ( |
| action as argaction, |
| type as argtype, |
| ) |
| |
| |
| class ArgumentsTypeTestCase(unittest.TestCase): |
| |
| def test_bool(self): |
| self.assertTrue(argtype.bool("1")) |
| self.assertTrue(argtype.bool("true")) |
| self.assertTrue(argtype.bool("True")) |
| |
| self.assertFalse(argtype.bool("0")) |
| self.assertFalse(argtype.bool("false")) |
| self.assertFalse(argtype.bool("False")) |
| |
| self.assertRaises(argparse.ArgumentTypeError, argtype.bool, 'foobar') |
| self.assertRaises(argparse.ArgumentTypeError, argtype.bool, 'TRUE') |
| self.assertRaises(argparse.ArgumentTypeError, argtype.bool, 'FALSE') |
| |
| def test_shell_split(self): |
| self.assertEqual( |
| argtype.shell_split("-BAR=\"foo bar\" -BAZ='foo,bar',-QUX $baz"), |
| ['-BAR=foo bar', '-BAZ=foo,bar', '-QUX', '$baz']) |
| |
| def test_clang_compiler_version(self): |
| self.assertEqual( |
| argtype.clang_compiler_version('1.23.456').components, |
| ("1", "23", "456", None)) |
| self.assertEqual( |
| argtype.clang_compiler_version('1.2.3').components, |
| ("1", "2", "3", None)) |
| self.assertEqual( |
| argtype.clang_compiler_version('1.2.3.4').components, |
| ("1", "2", "3", "4")) |
| self.assertEqual( |
| argtype.clang_compiler_version('12.34.56').components, |
| ("12", "34", "56", None)) |
| self.assertEqual( |
| argtype.clang_compiler_version('12.34.56.78').components, |
| ("12", "34", "56", "78")) |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.clang_compiler_version, |
| "ver1.2.3") |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.clang_compiler_version, |
| "1.beta2.3") |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.clang_compiler_version, |
| "1.2.preview3") |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.clang_compiler_version, |
| "1.2.3-rc4") |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.clang_compiler_version, |
| "1..2") |
| |
| def test_executable(self): |
| python = sys.executable |
| self.assertTrue(os.path.isabs(argtype.executable(python))) |
| |
| # On this test directory, specifying "../../build-script-impl" returns |
| # absolute path of build-script-impl |
| impl = os.path.join("..", "..", "build-script-impl") |
| cwd = os.getcwd() |
| os.chdir(os.path.dirname(__file__)) |
| self.assertTrue(os.path.isabs(argtype.executable(impl))) |
| os.chdir(cwd) |
| |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.executable, __file__) # this file is not executable |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.executable, os.path.dirname(__file__)) |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.executable, "/bin/example-command-not-exist") |
| self.assertRaises( |
| argparse.ArgumentTypeError, |
| argtype.executable, "../example-command-not-exist") |
| |
| |
| class ArgumentsActionTestCase(unittest.TestCase): |
| |
| def test_unavailable(self): |
| orig_stderr = sys.stderr |
| |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--foo") |
| parser.add_argument( |
| "--do-not-use", |
| "--never-ever", |
| action=argaction.unavailable) |
| |
| args, unknown_args = parser.parse_known_args( |
| ['--foo', 'bar', '--baz', 'qux']) |
| |
| self.assertEqual(args.foo, 'bar') |
| self.assertEqual(unknown_args, ['--baz', 'qux']) |
| self.assertFalse(hasattr(args, 'sentinel')) |
| |
| stderr = StringIO() |
| sys.stderr = stderr |
| self.assertRaises( |
| SystemExit, |
| parser.parse_known_args, |
| ['--foo', 'bar', '--do-not-use', 'baz']) |
| self.assertIn('--do-not-use', stderr.getvalue()) |
| |
| stderr = StringIO() |
| sys.stderr = stderr |
| self.assertRaises( |
| SystemExit, |
| parser.parse_known_args, |
| ['--foo', 'bar', '--never-ever=baz']) |
| self.assertIn('--never-ever', stderr.getvalue()) |
| |
| sys.stderr = orig_stderr |
| |
| def test_concat(self): |
| # Has default |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "--str-opt", |
| action=argaction.concat, |
| default="def") |
| parser.add_argument( |
| "--list-opt", |
| action=argaction.concat, |
| type=argtype.shell_split, |
| default=["def"]) |
| |
| self.assertEqual( |
| parser.parse_args(['--str-opt', '12', '--str-opt=42']), |
| argparse.Namespace(str_opt="def1242", list_opt=["def"])) |
| |
| self.assertEqual( |
| parser.parse_args(['--list-opt', 'foo 12', '--list-opt=bar 42']), |
| argparse.Namespace( |
| str_opt="def", list_opt=["def", "foo", "12", "bar", "42"])) |
| |
| # Default less |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "--str-opt", |
| action=argaction.concat) |
| parser.add_argument( |
| "--list-opt", |
| action=argaction.concat, |
| type=argtype.shell_split) |
| |
| self.assertEqual( |
| parser.parse_args(['--str-opt', '12', '--str-opt=42']), |
| argparse.Namespace(str_opt="1242", list_opt=None)) |
| |
| self.assertEqual( |
| parser.parse_args(['--list-opt', 'foo 12', '--list-opt=bar 42']), |
| argparse.Namespace( |
| str_opt=None, list_opt=["foo", "12", "bar", "42"])) |
| |
| def test_optional_bool(self): |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "--test-default-default", |
| action=argaction.optional_bool) |
| parser.add_argument( |
| "--test-default-true", |
| action=argaction.optional_bool, |
| default=True) |
| parser.add_argument( |
| "--test-default-false", |
| action=argaction.optional_bool, |
| default=False) |
| |
| args, unknown_args = parser.parse_known_args([]) |
| self.assertEqual(args.test_default_default, False) |
| self.assertEqual(args.test_default_true, True) |
| self.assertEqual(args.test_default_false, False) |
| |
| args, unknown_args = parser.parse_known_args( |
| ['--test-default-default', '0', |
| '--test-default-true', '0', |
| '--test-default-false', '0']) |
| self.assertEqual(args.test_default_default, False) |
| self.assertEqual(args.test_default_true, False) |
| self.assertEqual(args.test_default_false, False) |
| |
| args, unknown_args = parser.parse_known_args( |
| ['--test-default-default', '1', |
| '--test-default-true', '1', |
| '--test-default-false', '1']) |
| self.assertEqual(args.test_default_default, True) |
| self.assertEqual(args.test_default_true, True) |
| self.assertEqual(args.test_default_false, True) |
| |
| args, unknown_args = parser.parse_known_args( |
| ['--test-default-default', |
| '--test-default-true', |
| '--test-default-false']) |
| self.assertEqual(args.test_default_default, True) |
| self.assertEqual(args.test_default_true, True) |
| self.assertEqual(args.test_default_false, True) |
