test/run_tests_util_test.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2009 Google Inc. All Rights Reserved.
   4 #
   5 # Redistribution and use in source and binary forms, with or without
   6 # modification, are permitted provided that the following conditions are
   7 # met:
   8 #
   9 #     * Redistributions of source code must retain the above copyright
  10 # notice, this list of conditions and the following disclaimer.
  11 #     * Redistributions in binary form must reproduce the above
  12 # copyright notice, this list of conditions and the following disclaimer
  13 # in the documentation and/or other materials provided with the
  14 # distribution.
  15 #     * Neither the name of Google Inc. nor the names of its
  16 # contributors may be used to endorse or promote products derived from
  17 # this software without specific prior written permission.
  18 #
  19 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30
  31 """Tests for run_tests_util.py test runner script."""
  32
  33 __author__ = 'vladl@google.com (Vlad Losev)'
  34
  35 import os
  36 import re
  37 import sets
  38 import unittest
  39
  40 import run_tests_util
  41
  42
  43 GTEST_DBG_DIR = 'scons/build/dbg/gtest/scons'
  44 GTEST_OPT_DIR = 'scons/build/opt/gtest/scons'
  45 GTEST_OTHER_DIR = 'scons/build/other/gtest/scons'
  46
  47
  48 def AddExeExtension(path):
  49   """Appends .exe to the path on Windows or Cygwin."""
  50
  51   if run_tests_util.IS_WINDOWS or run_tests_util.IS_CYGWIN:
  52     return path + '.exe'
  53   else:
  54     return path
  55
  56
  57 class FakePath(object):
  58   """A fake os.path module for testing."""
  59
  60   def __init__(self, current_dir=os.getcwd(), known_paths=None):
  61     self.current_dir = current_dir
  62     self.tree = {}
  63     self.path_separator = os.sep
  64
  65     # known_paths contains either absolute or relative paths. Relative paths
  66     # are absolutized with self.current_dir.
  67     if known_paths:
  68       self._AddPaths(known_paths)
  69
  70   def _AddPath(self, path):
  71     ends_with_slash = path.endswith('/')
  72     path = self.abspath(path)
  73     if ends_with_slash:
  74       path += self.path_separator
  75     name_list = path.split(self.path_separator)
  76     tree = self.tree
  77     for name in name_list[:-1]:
  78       if not name:
  79         continue
  80       if name in tree:
  81         tree = tree[name]
  82       else:
  83         tree[name] = {}
  84         tree = tree[name]
  85
  86     name = name_list[-1]
  87     if name:
  88       if name in tree:
  89         assert tree[name] == 1
  90       else:
  91         tree[name] = 1
  92
  93   def _AddPaths(self, paths):
  94     for path in paths:
  95       self._AddPath(path)
  96
  97   def PathElement(self, path):
  98     """Returns an internal representation of directory tree entry for path."""
  99     tree = self.tree
 100     name_list = self.abspath(path).split(self.path_separator)
 101     for name in name_list:
 102       if not name:
 103         continue
 104       tree = tree.get(name, None)
 105       if tree is None:
 106         break
 107
 108     return tree
 109
 110   # Silences pylint warning about using standard names.
 111   # pylint: disable-msg=C6409
 112   def normpath(self, path):
 113     return os.path.normpath(path)
 114
 115   def abspath(self, path):
 116     return self.normpath(os.path.join(self.current_dir, path))
 117
 118   def isfile(self, path):
 119     return self.PathElement(self.abspath(path)) == 1
 120
 121   def isdir(self, path):
 122     return type(self.PathElement(self.abspath(path))) == type(dict())
 123
 124   def basename(self, path):
 125     return os.path.basename(path)
 126
 127   def dirname(self, path):
 128     return os.path.dirname(path)
 129
 130   def join(self, *kargs):
 131     return os.path.join(*kargs)
 132
 133
 134 class FakeOs(object):
 135   """A fake os module for testing."""
 136   P_WAIT = os.P_WAIT
 137
 138   def __init__(self, fake_path_module):
 139     self.path = fake_path_module
 140
 141     # Some methods/attributes are delegated to the real os module.
 142     self.environ = os.environ
 143
 144   # pylint: disable-msg=C6409
 145   def listdir(self, path):
 146     assert self.path.isdir(path)
 147     return self.path.PathElement(path).iterkeys()
 148
 149   def spawnv(self, wait, executable, *kargs):
 150     assert wait == FakeOs.P_WAIT
 151     return self.spawn_impl(executable, kargs)
 152
 153
 154 class GetTestsToRunTest(unittest.TestCase):
 155   """Exercises TestRunner.GetTestsToRun."""
 156
 157   def NormalizeGetTestsToRunResults(self, results):
 158     """Normalizes path data returned from GetTestsToRun for comparison."""
 159
 160     def NormalizePythonTestPair(pair):
 161       """Normalizes path data in the (directory, python_script) pair."""
 162
 163       return (os.path.normpath(pair[0]), os.path.normpath(pair[1]))
 164
 165     def NormalizeBinaryTestPair(pair):
 166       """Normalizes path data in the (directory, binary_executable) pair."""
 167
 168       directory, executable = map(os.path.normpath, pair)
 169
 170       # On Windows and Cygwin, the test file names have the .exe extension, but
 171       # they can be invoked either by name or by name+extension. Our test must
 172       # accommodate both situations.
 173       if run_tests_util.IS_WINDOWS or run_tests_util.IS_CYGWIN:
 174         executable = re.sub(r'\.exe$', '', executable)
 175       return (directory, executable)
 176
 177     python_tests = sets.Set(map(NormalizePythonTestPair, results[0]))
 178     binary_tests = sets.Set(map(NormalizeBinaryTestPair, results[1]))
 179     return (python_tests, binary_tests)
 180
 181   def AssertResultsEqual(self, results, expected):
 182     """Asserts results returned by GetTestsToRun equal to expected results."""
 183
 184     self.assertEqual(self.NormalizeGetTestsToRunResults(results),
 185                      self.NormalizeGetTestsToRunResults(expected),
 186                      'Incorrect set of tests returned:\n%s\nexpected:\n%s' %
 187                      (results, expected))
 188
 189   def setUp(self):
 190     self.fake_os = FakeOs(FakePath(
 191         current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)),
 192         known_paths=[AddExeExtension(GTEST_DBG_DIR + '/gtest_unittest'),
 193                      AddExeExtension(GTEST_OPT_DIR + '/gtest_unittest'),
 194                      'test/gtest_color_test.py']))
 195     self.fake_configurations = ['dbg', 'opt']
 196     self.test_runner = run_tests_util.TestRunner(script_dir='.',
 197                                                  injected_os=self.fake_os,
 198                                                  injected_subprocess=None)
 199
 200   def testBinaryTestsOnly(self):
 201     """Exercises GetTestsToRun with parameters designating binary tests only."""
 202
 203     # A default build.
 204     self.AssertResultsEqual(
 205         self.test_runner.GetTestsToRun(
 206             ['gtest_unittest'],
 207             '',
 208             False,
 209             available_configurations=self.fake_configurations),
 210         ([],
 211          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]))
 212
 213     # An explicitly specified directory.
 214     self.AssertResultsEqual(
 215         self.test_runner.GetTestsToRun(
 216             [GTEST_DBG_DIR, 'gtest_unittest'],
 217             '',
 218             False,
 219             available_configurations=self.fake_configurations),
 220         ([],
 221          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]))
 222
 223     # A particular configuration.
 224     self.AssertResultsEqual(
 225         self.test_runner.GetTestsToRun(
 226             ['gtest_unittest'],
 227             'other',
 228             False,
 229             available_configurations=self.fake_configurations),
 230         ([],
 231          [(GTEST_OTHER_DIR, GTEST_OTHER_DIR + '/gtest_unittest')]))
 232
 233     # All available configurations
 234     self.AssertResultsEqual(
 235         self.test_runner.GetTestsToRun(
 236             ['gtest_unittest'],
 237             'all',
 238             False,
 239             available_configurations=self.fake_configurations),
 240         ([],
 241          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'),
 242           (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')]))
 243
 244     # All built configurations (unbuilt don't cause failure).
 245     self.AssertResultsEqual(
 246         self.test_runner.GetTestsToRun(
 247             ['gtest_unittest'],
 248             '',
 249             True,
 250             available_configurations=self.fake_configurations + ['unbuilt']),
 251         ([],
 252          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'),
 253           (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')]))
 254
 255     # A combination of an explicit directory and a configuration.
 256     self.AssertResultsEqual(
 257         self.test_runner.GetTestsToRun(
 258             [GTEST_DBG_DIR, 'gtest_unittest'],
 259             'opt',
 260             False,
 261             available_configurations=self.fake_configurations),
 262         ([],
 263          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'),
 264           (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')]))
 265
 266     # Same test specified in an explicit directory and via a configuration.
 267     self.AssertResultsEqual(
 268         self.test_runner.GetTestsToRun(
 269             [GTEST_DBG_DIR, 'gtest_unittest'],
 270             'dbg',
 271             False,
 272             available_configurations=self.fake_configurations),
 273         ([],
 274          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]))
 275
 276     # All built configurations + explicit directory + explicit configuration.
 277     self.AssertResultsEqual(
 278         self.test_runner.GetTestsToRun(
 279             [GTEST_DBG_DIR, 'gtest_unittest'],
 280             'opt',
 281             True,
 282             available_configurations=self.fake_configurations),
 283         ([],
 284          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest'),
 285           (GTEST_OPT_DIR, GTEST_OPT_DIR + '/gtest_unittest')]))
 286
 287   def testPythonTestsOnly(self):
 288     """Exercises GetTestsToRun with parameters designating Python tests only."""
 289
 290     # A default build.
 291     self.AssertResultsEqual(
 292         self.test_runner.GetTestsToRun(
 293             ['gtest_color_test.py'],
 294             '',
 295             False,
 296             available_configurations=self.fake_configurations),
 297         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 298          []))
 299
 300     # An explicitly specified directory.
 301     self.AssertResultsEqual(
 302         self.test_runner.GetTestsToRun(
 303             [GTEST_DBG_DIR, 'test/gtest_color_test.py'],
 304             '',
 305             False,
 306             available_configurations=self.fake_configurations),
 307         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 308          []))
 309
 310     # A particular configuration.
 311     self.AssertResultsEqual(
 312         self.test_runner.GetTestsToRun(
 313             ['gtest_color_test.py'],
 314             'other',
 315             False,
 316             available_configurations=self.fake_configurations),
 317         ([(GTEST_OTHER_DIR, 'test/gtest_color_test.py')],
 318          []))
 319
 320     # All available configurations
 321     self.AssertResultsEqual(
 322         self.test_runner.GetTestsToRun(
 323             ['test/gtest_color_test.py'],
 324             'all',
 325             False,
 326             available_configurations=self.fake_configurations),
 327         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'),
 328           (GTEST_OPT_DIR, 'test/gtest_color_test.py')],
 329          []))
 330
 331     # All built configurations (unbuilt don't cause failure).
 332     self.AssertResultsEqual(
 333         self.test_runner.GetTestsToRun(
 334             ['gtest_color_test.py'],
 335             '',
 336             True,
 337             available_configurations=self.fake_configurations + ['unbuilt']),
 338         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'),
 339           (GTEST_OPT_DIR, 'test/gtest_color_test.py')],
 340          []))
 341
 342     # A combination of an explicit directory and a configuration.
 343     self.AssertResultsEqual(
 344         self.test_runner.GetTestsToRun(
 345             [GTEST_DBG_DIR, 'gtest_color_test.py'],
 346             'opt',
 347             False,
 348             available_configurations=self.fake_configurations),
 349         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'),
 350           (GTEST_OPT_DIR, 'test/gtest_color_test.py')],
 351          []))
 352
 353     # Same test specified in an explicit directory and via a configuration.
 354     self.AssertResultsEqual(
 355         self.test_runner.GetTestsToRun(
 356             [GTEST_DBG_DIR, 'gtest_color_test.py'],
 357             'dbg',
 358             False,
 359             available_configurations=self.fake_configurations),
 360         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 361          []))
 362
 363     # All built configurations + explicit directory + explicit configuration.
 364     self.AssertResultsEqual(
 365         self.test_runner.GetTestsToRun(
 366             [GTEST_DBG_DIR, 'gtest_color_test.py'],
 367             'opt',
 368             True,
 369             available_configurations=self.fake_configurations),
 370         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py'),
 371           (GTEST_OPT_DIR, 'test/gtest_color_test.py')],
 372          []))
 373
 374   def testCombinationOfBinaryAndPythonTests(self):
 375     """Exercises GetTestsToRun with mixed binary/Python tests."""
 376
 377     # Use only default configuration for this test.
 378
 379     # Neither binary nor Python tests are specified so find all.
 380     self.AssertResultsEqual(
 381         self.test_runner.GetTestsToRun(
 382             [],
 383             '',
 384             False,
 385             available_configurations=self.fake_configurations),
 386         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 387          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]))
 388
 389     # Specifying both binary and Python tests.
 390     self.AssertResultsEqual(
 391         self.test_runner.GetTestsToRun(
 392             ['gtest_unittest', 'gtest_color_test.py'],
 393             '',
 394             False,
 395             available_configurations=self.fake_configurations),
 396         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 397          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]))
 398
 399     # Specifying binary tests suppresses Python tests.
 400     self.AssertResultsEqual(
 401         self.test_runner.GetTestsToRun(
 402             ['gtest_unittest'],
 403             '',
 404             False,
 405             available_configurations=self.fake_configurations),
 406         ([],
 407          [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]))
 408
 409    # Specifying Python tests suppresses binary tests.
 410     self.AssertResultsEqual(
 411         self.test_runner.GetTestsToRun(
 412             ['gtest_color_test.py'],
 413             '',
 414             False,
 415             available_configurations=self.fake_configurations),
 416         ([(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 417          []))
 418
 419   def testIgnoresNonTestFiles(self):
 420     """Verifies that GetTestsToRun ignores non-test files in the filesystem."""
 421
 422     self.fake_os = FakeOs(FakePath(
 423         current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)),
 424         known_paths=[AddExeExtension(GTEST_DBG_DIR + '/gtest_nontest'),
 425                      'test/']))
 426     self.test_runner = run_tests_util.TestRunner(script_dir='.',
 427                                                  injected_os=self.fake_os,
 428                                                  injected_subprocess=None)
 429     self.AssertResultsEqual(
 430         self.test_runner.GetTestsToRun(
 431             [],
 432             '',
 433             True,
 434             available_configurations=self.fake_configurations),
 435         ([], []))
 436
 437   def testWorksFromDifferentDir(self):
 438     """Exercises GetTestsToRun from a directory different from run_test.py's."""
 439
 440     # Here we simulate an test script in directory /d/ called from the
 441     # directory /a/b/c/.
 442     self.fake_os = FakeOs(FakePath(
 443         current_dir=os.path.abspath('/a/b/c'),
 444         known_paths=[
 445             '/a/b/c/',
 446             AddExeExtension('/d/' + GTEST_DBG_DIR + '/gtest_unittest'),
 447             AddExeExtension('/d/' + GTEST_OPT_DIR + '/gtest_unittest'),
 448             '/d/test/gtest_color_test.py']))
 449     self.fake_configurations = ['dbg', 'opt']
 450     self.test_runner = run_tests_util.TestRunner(script_dir='/d/',
 451                                                  injected_os=self.fake_os,
 452                                                  injected_subprocess=None)
 453     # A binary test.
 454     self.AssertResultsEqual(
 455         self.test_runner.GetTestsToRun(
 456             ['gtest_unittest'],
 457             '',
 458             False,
 459             available_configurations=self.fake_configurations),
 460         ([],
 461          [('/d/' + GTEST_DBG_DIR, '/d/' + GTEST_DBG_DIR + '/gtest_unittest')]))
 462
 463     # A Python test.
 464     self.AssertResultsEqual(
 465         self.test_runner.GetTestsToRun(
 466             ['gtest_color_test.py'],
 467             '',
 468             False,
 469             available_configurations=self.fake_configurations),
 470         ([('/d/' + GTEST_DBG_DIR, '/d/test/gtest_color_test.py')], []))
 471
 472   def testNonTestBinary(self):
 473     """Exercises GetTestsToRun with a non-test parameter."""
 474
 475     self.assert_(
 476         not self.test_runner.GetTestsToRun(
 477             ['gtest_unittest_not_really'],
 478             '',
 479             False,
 480             available_configurations=self.fake_configurations))
 481
 482   def testNonExistingPythonTest(self):
 483     """Exercises GetTestsToRun with a non-existent Python test parameter."""
 484
 485     self.assert_(
 486         not self.test_runner.GetTestsToRun(
 487             ['nonexistent_test.py'],
 488             '',
 489             False,
 490             available_configurations=self.fake_configurations))
 491
 492   if run_tests_util.IS_WINDOWS or run_tests_util.IS_CYGWIN:
 493
 494     def testDoesNotPickNonExeFilesOnWindows(self):
 495       """Verifies that GetTestsToRun does not find _test files on Windows."""
 496
 497       self.fake_os = FakeOs(FakePath(
 498           current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)),
 499           known_paths=['/d/' + GTEST_DBG_DIR + '/gtest_test', 'test/']))
 500       self.test_runner = run_tests_util.TestRunner(script_dir='.',
 501                                                    injected_os=self.fake_os,
 502                                                    injected_subprocess=None)
 503       self.AssertResultsEqual(
 504           self.test_runner.GetTestsToRun(
 505               [],
 506               '',
 507               True,
 508               available_configurations=self.fake_configurations),
 509           ([], []))
 510
 511
 512 class RunTestsTest(unittest.TestCase):
 513   """Exercises TestRunner.RunTests."""
 514
 515   def SpawnSuccess(self, unused_executable, unused_argv):
 516     """Fakes test success by returning 0 as an exit code."""
 517
 518     self.num_spawn_calls += 1
 519     return 0
 520
 521   def SpawnFailure(self, unused_executable, unused_argv):
 522     """Fakes test success by returning 1 as an exit code."""
 523
 524     self.num_spawn_calls += 1
 525     return 1
 526
 527   def setUp(self):
 528     self.fake_os = FakeOs(FakePath(
 529         current_dir=os.path.abspath(os.path.dirname(run_tests_util.__file__)),
 530         known_paths=[
 531             AddExeExtension(GTEST_DBG_DIR + '/gtest_unittest'),
 532             AddExeExtension(GTEST_OPT_DIR + '/gtest_unittest'),
 533             'test/gtest_color_test.py']))
 534     self.fake_configurations = ['dbg', 'opt']
 535     self.test_runner = run_tests_util.TestRunner(
 536         script_dir=os.path.dirname(__file__) or '.',
 537         injected_os=self.fake_os,
 538         injected_subprocess=None)
 539     self.num_spawn_calls = 0  # A number of calls to spawn.
 540
 541   def testRunPythonTestSuccess(self):
 542     """Exercises RunTests to handle a Python test success."""
 543
 544     self.fake_os.spawn_impl = self.SpawnSuccess
 545     self.assertEqual(
 546         self.test_runner.RunTests(
 547             [(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 548             []),
 549         0)
 550     self.assertEqual(self.num_spawn_calls, 1)
 551
 552   def testRunBinaryTestSuccess(self):
 553     """Exercises RunTests to handle a binary test success."""
 554
 555     self.fake_os.spawn_impl = self.SpawnSuccess
 556     self.assertEqual(
 557         self.test_runner.RunTests(
 558             [],
 559             [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]),
 560         0)
 561     self.assertEqual(self.num_spawn_calls, 1)
 562
 563   def testRunPythonTestFauilure(self):
 564     """Exercises RunTests to handle a Python test failure."""
 565
 566     self.fake_os.spawn_impl = self.SpawnFailure
 567     self.assertEqual(
 568         self.test_runner.RunTests(
 569             [(GTEST_DBG_DIR, 'test/gtest_color_test.py')],
 570             []),
 571         1)
 572     self.assertEqual(self.num_spawn_calls, 1)
 573
 574   def testRunBinaryTestFailure(self):
 575     """Exercises RunTests to handle a binary test failure."""
 576
 577     self.fake_os.spawn_impl = self.SpawnFailure
 578     self.assertEqual(
 579         self.test_runner.RunTests(
 580             [],
 581             [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]),
 582         1)
 583     self.assertEqual(self.num_spawn_calls, 1)
 584
 585   def testCombinedTestSuccess(self):
 586     """Exercises RunTests to handle a success of both Python and binary test."""
 587
 588     self.fake_os.spawn_impl = self.SpawnSuccess
 589     self.assertEqual(
 590         self.test_runner.RunTests(
 591             [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')],
 592             [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]),
 593         0)
 594     self.assertEqual(self.num_spawn_calls, 2)
 595
 596   def testCombinedTestSuccessAndFailure(self):
 597     """Exercises RunTests to handle a success of both Python and binary test."""
 598
 599     def SpawnImpl(executable, argv):
 600       self.num_spawn_calls += 1
 601       # Simulates failure of a Python test and success of a binary test.
 602       if '.py' in executable or '.py' in argv[0]:
 603         return 1
 604       else:
 605         return 0
 606
 607     self.fake_os.spawn_impl = SpawnImpl
 608     self.assertEqual(
 609         self.test_runner.RunTests(
 610             [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')],
 611             [(GTEST_DBG_DIR, GTEST_DBG_DIR + '/gtest_unittest')]),
 612         0)
 613     self.assertEqual(self.num_spawn_calls, 2)
 614
 615
 616 class ParseArgsTest(unittest.TestCase):
 617   """Exercises ParseArgs."""
 618
 619   def testNoOptions(self):
 620     options, args = run_tests_util.ParseArgs('gtest', argv=['script.py'])
 621     self.assertEqual(args, ['script.py'])
 622     self.assert_(options.configurations is None)
 623     self.assertFalse(options.built_configurations)
 624
 625   def testOptionC(self):
 626     options, args = run_tests_util.ParseArgs(
 627         'gtest', argv=['script.py', '-c', 'dbg'])
 628     self.assertEqual(args, ['script.py'])
 629     self.assertEqual(options.configurations, 'dbg')
 630     self.assertFalse(options.built_configurations)
 631
 632   def testOptionA(self):
 633     options, args = run_tests_util.ParseArgs('gtest', argv=['script.py', '-a'])
 634     self.assertEqual(args, ['script.py'])
 635     self.assertEqual(options.configurations, 'all')
 636     self.assertFalse(options.built_configurations)
 637
 638   def testOptionB(self):
 639     options, args = run_tests_util.ParseArgs('gtest', argv=['script.py', '-b'])
 640     self.assertEqual(args, ['script.py'])
 641     self.assert_(options.configurations is None)
 642     self.assertTrue(options.built_configurations)
 643
 644   def testOptionCAndOptionB(self):
 645     options, args = run_tests_util.ParseArgs(
 646         'gtest', argv=['script.py', '-c', 'dbg', '-b'])
 647     self.assertEqual(args, ['script.py'])
 648     self.assertEqual(options.configurations, 'dbg')
 649     self.assertTrue(options.built_configurations)
 650
 651   def testOptionH(self):
 652     help_called = [False]
 653
 654     # Suppresses lint warning on unused arguments.  These arguments are
 655     # required by optparse, even though they are unused.
 656     # pylint: disable-msg=W0613
 657     def VerifyHelp(option, opt, value, parser):
 658       help_called[0] = True
 659
 660     # Verifies that -h causes the help callback to be called.
 661     help_called[0] = False
 662     _, args = run_tests_util.ParseArgs(
 663         'gtest', argv=['script.py', '-h'], help_callback=VerifyHelp)
 664     self.assertEqual(args, ['script.py'])
 665     self.assertTrue(help_called[0])
 666
 667     # Verifies that --help causes the help callback to be called.
 668     help_called[0] = False
 669     _, args = run_tests_util.ParseArgs(
 670         'gtest', argv=['script.py', '--help'], help_callback=VerifyHelp)
 671     self.assertEqual(args, ['script.py'])
 672     self.assertTrue(help_called[0])
 673
 674
 675 if __name__ == '__main__':
 676   unittest.main()