| #!/usr/bin/env python |
| # |
| # Copyright 2009 Google Inc. All Rights Reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following disclaimer |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| """Tests for run_tests_util.py test runner script.""" |
| |
| __author__ = 'vladl@google.com (Vlad Losev)' |
| |
| import os |
| import re |
| import sets |
| import unittest |
| |
| import run_tests_util |
| |
| |
| GTEST_DBG_DIR = 'scons/build/dbg/gtest/scons' |
| GTEST_OPT_DIR = 'scons/build/opt/gtest/scons' |
| GTEST_OTHER_DIR = 'scons/build/other/gtest/scons' |
| |
| |
| def AddExeExtension(path): |
| """Appends .exe to the path on Windows or Cygwin.""" |
| |
| if run_tests_util.IS_WINDOWS or run_tests_util.IS_CYGWIN: |
| return path + '.exe' |
| else: |
| return path |
| |
| |
| class FakePath(object): |
| """A fake os.path module for testing.""" |
| |
| def __init__(self, current_dir=os.getcwd(), known_paths=None): |
| self.current_dir = current_dir |
| self.tree = {} |
| self.path_separator = os.sep |
| |
| # known_paths contains either absolute or relative paths. Relative paths |
| # are absolutized with self.current_dir. |
| if known_paths: |
| self._AddPaths(known_paths) |
| |
| def _AddPath(self, path): |
| ends_with_slash = path.endswith('/') |
| path = self.abspath(path) |
| if ends_with_slash: |
| path += self.path_separator |
| name_list = path.split(self.path_separator) |
| tree = self.tree |
| for name in name_list[:-1]: |
| if not name: |
| continue |
| if name in tree: |
| tree = tree[name] |
| else: |
| tree[name] = {} |
| tree = tree[name] |
| |
| name = name_list[-1] |
| if name: |
| if name in tree: |
| assert tree[name] == 1 |
| else: |
| tree[name] = 1 |
| |
| def _AddPaths(self, paths): |
| for path in paths: |
| self._AddPath(path) |
| |
| def PathElement(self, path): |
| """Returns an internal representation of directory tree entry for path.""" |
| tree = self.tree |
| name_list = self.abspath(path).split(self.path_separator) |
| for name in name_list: |
| if not name: |
| continue |
| tree = tree.get(name, None) |
| if tree is None: |
| break |
| |
| return tree |
| |
| # Silences pylint warning about using standard names. |
| # pylint: disable-msg=C6409 |
| def normpath(self, path): |
| return os.path.normpath(path) |
| |
| def abspath(self, path): |
| return self.normpath(os.path.join(self.current_dir, path)) |
| |
| def isfile(self, path): |
| return self.PathElement(self.abspath(path)) == 1 |
| |
| def isdir(self, path): |
| return type(self.PathElement(self.abspath(path))) == type(dict()) |
| |
| def basename(self, path): |
| return os.path.basename(path) |
| |
| def dirname(self, path): |
| return os.path.dirname(path) |
| |
| def join(self, *kargs): |
| return os.path.join(*kargs) |
| |
| |
| class FakeOs(object): |
| """A fake os module for testing.""" |
| P_WAIT = os.P_WAIT |
| |
| def __init__(self, fake_path_module): |
| self.path = fake_path_module |
| |
| # Some methods/attributes are delegated to the real os module. |
| self.environ = os.environ |
| |
| # pylint: disable-msg=C6409 |
| def listdir(self, path): |
| assert self.path.isdir(path) |
| return self.path.PathElement(path).iterkeys() |
| |
| def spawnv(self, wait, executable, *kargs): |
| assert wait == FakeOs.P_WAIT |
| return self.spawn_impl(executable, kargs) |
| |
| |
| class GetTestsToRunTest(unittest.TestCase): |
| """Exercises TestRunner.GetTestsToRun.""" |
| |
| def NormalizeGetTestsToRunResults(self, results): |
| """Normalizes path data returned from GetTestsToRun for comparison.""" |
| |
| def NormalizePythonTestPair(pair): |
| """Normalizes path data in the (directory, python_script) pair.""" |
| |
| return (os.path.normpath(pair[0]), os.path.normpath(pair[1])) |
| |
| def NormalizeBinaryTestPair(pair): |
| """Normalizes path data in the (directory, binary_executable) pair.""" |
| |
| directory, executable = map(os.path.normpath, pair) |
| |
| # On Windows and Cygwin, the test file names have the .exe extension, but |
| # they can be invoked either by name or by name+extension. Our test must |
| # accommodate both situations. |
| if run_tests_util.IS_WINDOWS or run_tests_util.IS_CYGWIN: |
| executable = re.sub(r'\.exe$', '', executable) |
| return (directory, executable) |
| |
| python_tests = sets.Set(map(NormalizePythonTestPair, results[0])) |
| binary_tests = sets.Set(map(NormalizeBinaryTestPair, results[1])) |
| return (python_tests, binary_tests) |
| |
| def AssertResultsEqual(self, results, expected): |
| """Asserts results returned by GetTestsToRun equal to expected results.""" |
| |
| self.assertEqual(self.NormalizeGetTestsToRunResults(results), |
| self.NormalizeGetTestsToRunResults(expected), |
| 'Incorrect set of tests returned:\n%s\nexpected:\n%s' % |
| (results, expected)) |
| |
| def setUp(self): |
| self.fake_os = FakeOs(FakePath( |
| current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)), |
| known_paths=[AddExeExtension(GTEST_DBG_DIR + '/gtest_unittest'), |
| AddExeExtension(GTEST_OPT_DIR + '/gtest_unittest'), |
| 'test/gtest_color_test.py'])) |
| self.fake_configurations = ['dbg', 'opt'] |
| self.test_runner = run_tests_util.TestRunner(script_dir='.', |
| injected_os=self.fake_os, |
| injected_subprocess=None) |
| |
| def testBinaryTestsOnly(self): |
| """Exercises GetTestsToRun with parameters designating binary tests only.""" |
| |
| # A default build. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_unittest'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')])) |
| |
| # An explicitly specified directory. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'gtest_unittest'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')])) |
| |
| # A particular configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_unittest'], |
| 'other', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_OTHER_DIR, GTEST_OTHER_DIR + '/gtest_unittest')])) |
| |
| # All available configurations |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_unittest'], |
| 'all', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'), |
| (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')])) |
| |
| # All built configurations (unbuilt don't cause failure). |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_unittest'], |
| '', |
| True, |
| available_configurations=self.fake_configurations + ['unbuilt']), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'), |
| (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')])) |
| |
| # A combination of an explicit directory and a configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'gtest_unittest'], |
| 'opt', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'), |
| (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')])) |
| |
| # Same test specified in an explicit directory and via a configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'gtest_unittest'], |
| 'dbg', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')])) |
| |
| # All built configurations + explicit directory + explicit configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'gtest_unittest'], |
| 'opt', |
| True, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'), |
| (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')])) |
| |
| def testPythonTestsOnly(self): |
| """Exercises GetTestsToRun with parameters designating Python tests only.""" |
| |
| # A default build. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_color_test.py'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| # An explicitly specified directory. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'test/gtest_color_test.py'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| # A particular configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_color_test.py'], |
| 'other', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_OTHER_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| # All available configurations |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['test/gtest_color_test.py'], |
| 'all', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'), |
| (GTEST_OPT_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| # All built configurations (unbuilt don't cause failure). |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_color_test.py'], |
| '', |
| True, |
| available_configurations=self.fake_configurations + ['unbuilt']), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'), |
| (GTEST_OPT_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| # A combination of an explicit directory and a configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'gtest_color_test.py'], |
| 'opt', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'), |
| (GTEST_OPT_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| # Same test specified in an explicit directory and via a configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'gtest_color_test.py'], |
| 'dbg', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| # All built configurations + explicit directory + explicit configuration. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [GTEST_DBG_DIR, 'gtest_color_test.py'], |
| 'opt', |
| True, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'), |
| (GTEST_OPT_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| def testCombinationOfBinaryAndPythonTests(self): |
| """Exercises GetTestsToRun with mixed binary/Python tests.""" |
| |
| # Use only default configuration for this test. |
| |
| # Neither binary nor Python tests are specified so find all. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')])) |
| |
| # Specifying both binary and Python tests. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_unittest', 'gtest_color_test.py'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')])) |
| |
| # Specifying binary tests suppresses Python tests. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_unittest'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')])) |
| |
| # Specifying Python tests suppresses binary tests. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_color_test.py'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| [])) |
| |
| def testIgnoresNonTestFiles(self): |
| """Verifies that GetTestsToRun ignores non-test files in the filesystem.""" |
| |
| self.fake_os = FakeOs(FakePath( |
| current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)), |
| known_paths=[AddExeExtension(GTEST_DBG_DIR + '/gtest_nontest'), |
| 'test/'])) |
| self.test_runner = run_tests_util.TestRunner(script_dir='.', |
| injected_os=self.fake_os, |
| injected_subprocess=None) |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [], |
| '', |
| True, |
| available_configurations=self.fake_configurations), |
| ([], [])) |
| |
| def testWorksFromDifferentDir(self): |
| """Exercises GetTestsToRun from a directory different from run_test.py's.""" |
| |
| # Here we simulate an test script in directory /d/ called from the |
| # directory /a/b/c/. |
| self.fake_os = FakeOs(FakePath( |
| current_dir=os.path.abspath('/a/b/c'), |
| known_paths=[ |
| '/a/b/c/', |
| AddExeExtension('/d/' + GTEST_DBG_DIR + '/gtest_unittest'), |
| AddExeExtension('/d/' + GTEST_OPT_DIR + '/gtest_unittest'), |
| '/d/test/gtest_color_test.py'])) |
| self.fake_configurations = ['dbg', 'opt'] |
| self.test_runner = run_tests_util.TestRunner(script_dir='/d/', |
| injected_os=self.fake_os, |
| injected_subprocess=None) |
| # A binary test. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_unittest'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([], |
| [('/d/' + GTEST_DBG_DIR, '/d/' + GTEST_DBG_DIR + '/gtest_unittest')])) |
| |
| # A Python test. |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| ['gtest_color_test.py'], |
| '', |
| False, |
| available_configurations=self.fake_configurations), |
| ([('/d/' + GTEST_DBG_DIR, '/d/test/gtest_color_test.py')], [])) |
| |
| def testNonTestBinary(self): |
| """Exercises GetTestsToRun with a non-test parameter.""" |
| |
| self.assert_( |
| not self.test_runner.GetTestsToRun( |
| ['gtest_unittest_not_really'], |
| '', |
| False, |
| available_configurations=self.fake_configurations)) |
| |
| def testNonExistingPythonTest(self): |
| """Exercises GetTestsToRun with a non-existent Python test parameter.""" |
| |
| self.assert_( |
| not self.test_runner.GetTestsToRun( |
| ['nonexistent_test.py'], |
| '', |
| False, |
| available_configurations=self.fake_configurations)) |
| |
| if run_tests_util.IS_WINDOWS or run_tests_util.IS_CYGWIN: |
| |
| def testDoesNotPickNonExeFilesOnWindows(self): |
| """Verifies that GetTestsToRun does not find _test files on Windows.""" |
| |
| self.fake_os = FakeOs(FakePath( |
| current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)), |
| known_paths=['/d/' + GTEST_DBG_DIR + '/gtest_test', 'test/'])) |
| self.test_runner = run_tests_util.TestRunner(script_dir='.', |
| injected_os=self.fake_os, |
| injected_subprocess=None) |
| self.AssertResultsEqual( |
| self.test_runner.GetTestsToRun( |
| [], |
| '', |
| True, |
| available_configurations=self.fake_configurations), |
| ([], [])) |
| |
| |
| class RunTestsTest(unittest.TestCase): |
| """Exercises TestRunner.RunTests.""" |
| |
| def SpawnSuccess(self, unused_executable, unused_argv): |
| """Fakes test success by returning 0 as an exit code.""" |
| |
| self.num_spawn_calls += 1 |
| return 0 |
| |
| def SpawnFailure(self, unused_executable, unused_argv): |
| """Fakes test success by returning 1 as an exit code.""" |
| |
| self.num_spawn_calls += 1 |
| return 1 |
| |
| def setUp(self): |
| self.fake_os = FakeOs(FakePath( |
| current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)), |
| known_paths=[ |
| AddExeExtension(GTEST_DBG_DIR + '/gtest_unittest'), |
| AddExeExtension(GTEST_OPT_DIR + '/gtest_unittest'), |
| 'test/gtest_color_test.py'])) |
| self.fake_configurations = ['dbg', 'opt'] |
| self.test_runner = run_tests_util.TestRunner( |
| script_dir=os.path.dirname(__file__) or '.', |
| injected_os=self.fake_os, |
| injected_subprocess=None) |
| self.num_spawn_calls = 0 # A number of calls to spawn. |
| |
| def testRunPythonTestSuccess(self): |
| """Exercises RunTests to handle a Python test success.""" |
| |
| self.fake_os.spawn_impl = self.SpawnSuccess |
| self.assertEqual( |
| self.test_runner.RunTests( |
| [(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| []), |
| 0) |
| self.assertEqual(self.num_spawn_calls, 1) |
| |
| def testRunBinaryTestSuccess(self): |
| """Exercises RunTests to handle a binary test success.""" |
| |
| self.fake_os.spawn_impl = self.SpawnSuccess |
| self.assertEqual( |
| self.test_runner.RunTests( |
| [], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]), |
| 0) |
| self.assertEqual(self.num_spawn_calls, 1) |
| |
| def testRunPythonTestFauilure(self): |
| """Exercises RunTests to handle a Python test failure.""" |
| |
| self.fake_os.spawn_impl = self.SpawnFailure |
| self.assertEqual( |
| self.test_runner.RunTests( |
| [(GTEST_DBG_DIR, 'test/gtest_color_test.py')], |
| []), |
| 1) |
| self.assertEqual(self.num_spawn_calls, 1) |
| |
| def testRunBinaryTestFailure(self): |
| """Exercises RunTests to handle a binary test failure.""" |
| |
| self.fake_os.spawn_impl = self.SpawnFailure |
| self.assertEqual( |
| self.test_runner.RunTests( |
| [], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]), |
| 1) |
| self.assertEqual(self.num_spawn_calls, 1) |
| |
| def testCombinedTestSuccess(self): |
| """Exercises RunTests to handle a success of both Python and binary test.""" |
| |
| self.fake_os.spawn_impl = self.SpawnSuccess |
| self.assertEqual( |
| self.test_runner.RunTests( |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]), |
| 0) |
| self.assertEqual(self.num_spawn_calls, 2) |
| |
| def testCombinedTestSuccessAndFailure(self): |
| """Exercises RunTests to handle a success of both Python and binary test.""" |
| |
| def SpawnImpl(executable, argv): |
| self.num_spawn_calls += 1 |
| # Simulates failure of a Python test and success of a binary test. |
| if '.py' in executable or '.py' in argv[0]: |
| return 1 |
| else: |
| return 0 |
| |
| self.fake_os.spawn_impl = SpawnImpl |
| self.assertEqual( |
| self.test_runner.RunTests( |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')], |
| [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]), |
| 0) |
| self.assertEqual(self.num_spawn_calls, 2) |
| |
| |
| class ParseArgsTest(unittest.TestCase): |
| """Exercises ParseArgs.""" |
| |
| def testNoOptions(self): |
| options, args = run_tests_util.ParseArgs('gtest', argv=['script.py']) |
| self.assertEqual(args, ['script.py']) |
| self.assert_(options.configurations is None) |
| self.assertFalse(options.built_configurations) |
| |
| def testOptionC(self): |
| options, args = run_tests_util.ParseArgs( |
| 'gtest', argv=['script.py', '-c', 'dbg']) |
| self.assertEqual(args, ['script.py']) |
| self.assertEqual(options.configurations, 'dbg') |
| self.assertFalse(options.built_configurations) |
| |
| def testOptionA(self): |
| options, args = run_tests_util.ParseArgs('gtest', argv=['script.py', '-a']) |
| self.assertEqual(args, ['script.py']) |
| self.assertEqual(options.configurations, 'all') |
| self.assertFalse(options.built_configurations) |
| |
| def testOptionB(self): |
| options, args = run_tests_util.ParseArgs('gtest', argv=['script.py', '-b']) |
| self.assertEqual(args, ['script.py']) |
| self.assert_(options.configurations is None) |
| self.assertTrue(options.built_configurations) |
| |
| def testOptionCAndOptionB(self): |
| options, args = run_tests_util.ParseArgs( |
| 'gtest', argv=['script.py', '-c', 'dbg', '-b']) |
| self.assertEqual(args, ['script.py']) |
| self.assertEqual(options.configurations, 'dbg') |
| self.assertTrue(options.built_configurations) |
| |
| def testOptionH(self): |
| help_called = [False] |
| |
| # Suppresses lint warning on unused arguments. These arguments are |
| # required by optparse, even though they are unused. |
| # pylint: disable-msg=W0613 |
| def VerifyHelp(option, opt, value, parser): |
| help_called[0] = True |
| |
| # Verifies that -h causes the help callback to be called. |
| help_called[0] = False |
| _, args = run_tests_util.ParseArgs( |
| 'gtest', argv=['script.py', '-h'], help_callback=VerifyHelp) |
| self.assertEqual(args, ['script.py']) |
| self.assertTrue(help_called[0]) |
| |
| # Verifies that --help causes the help callback to be called. |
| help_called[0] = False |
| _, args = run_tests_util.ParseArgs( |
| 'gtest', argv=['script.py', '--help'], help_callback=VerifyHelp) |
| self.assertEqual(args, ['script.py']) |
| self.assertTrue(help_called[0]) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
