mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
233 lines
8.0 KiB
Python
233 lines
8.0 KiB
Python
# 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)
|