run_tests.py 16.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#!/usr/bin/env python
#
# Copyright 2008, 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.

"""Runs specified tests for Google Test.

SYNOPSIS
       run_tests.py [OPTION]... [BUILD_DIR]... [TEST]...

DESCRIPTION
       Runs the specified tests (either binary or Python), and prints a
       summary of the results. BUILD_DIRS will be used to search for the
       binaries. If no TESTs are specified, all binary tests found in
       BUILD_DIRs and all Python tests found in the directory test/ (in the
       gtest root) are run.

       TEST is a name of either a binary or a Python test. A binary test is
       an executable file named *_test or *_unittest (with the .exe
       extension on Windows) A Python test is a script named *_test.py or
       *_unittest.py.

OPTIONS
       -c CONFIGURATIONS
              Specify build directories via build configurations.
              CONFIGURATIONS is either a comma-separated list of build
              configurations or 'all'. Each configuration is equivalent to
53
              adding 'scons/build/<configuration>/gtest/scons' to BUILD_DIRs.
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
              Specifying -c=all is equivalent to providing all directories
              listed in KNOWN BUILD DIRECTORIES section below.

       -a
             Equivalent to -c=all

       -b
             Equivalent to -c=all with the exception that the script will not
             fail if some of the KNOWN BUILD DIRECTORIES do not exists; the
             script will simply not run the tests there. 'b' stands for
             'built directories'.

RETURN VALUE
       Returns 0 if all tests are successful; otherwise returns 1.

EXAMPLES
       run_tests.py
              Runs all tests for the default build configuration.

       run_tests.py -a
              Runs all tests with binaries in KNOWN BUILD DIRECTORIES.

       run_tests.py -b
              Runs all tests in KNOWN BUILD DIRECTORIES that have been
              built.

       run_tests.py foo/
              Runs all tests in the foo/ directory and all Python tests in
              the directory test. The Python tests are instructed to look
              for binaries in foo/.

       run_tests.py bar_test.exe test/baz_test.exe foo/ bar/
              Runs foo/bar_test.exe, bar/bar_test.exe, foo/baz_test.exe, and
              bar/baz_test.exe.

       run_tests.py foo bar test/foo_test.py
              Runs test/foo_test.py twice instructing it to look for its
              test binaries in the directories foo and bar,
              correspondingly.

KNOWN BUILD DIRECTORIES
      run_tests.py knows about directories where the SCons build script
      deposits its products. These are the directories where run_tests.py
      will be looking for its binaries. Currently, gtest's SConstruct file
      defines them as follows (the default build directory is the first one
      listed in each group):
      On Windows:
101
102
103
104
              <gtest root>/scons/build/win-dbg8/gtest/scons/
              <gtest root>/scons/build/win-opt8/gtest/scons/
              <gtest root>/scons/build/win-dbg/gtest/scons/
              <gtest root>/scons/build/win-opt/gtest/scons/
105
      On Mac:
106
107
              <gtest root>/scons/build/mac-dbg/gtest/scons/
              <gtest root>/scons/build/mac-opt/gtest/scons/
108
      On other platforms:
109
110
              <gtest root>/scons/build/dbg/gtest/scons/
              <gtest root>/scons/build/opt/gtest/scons/
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

AUTHOR
       Written by Zhanyong Wan (wan@google.com)
       and Vlad Losev(vladl@google.com).

REQUIREMENTS
       This script requires Python 2.3 or higher.
"""

import optparse
import os
import re
import sets
import sys

try:
  # subrocess module is a preferable way to invoke subprocesses but it may
  # not be available on MacOS X 10.4.
  import subprocess
except ImportError:
  subprocess = None

IS_WINDOWS = os.name == 'nt'
IS_MAC = os.name == 'posix' and os.uname()[0] == 'Darwin'
135
IS_CYGWIN = os.name == 'posix' and 'CYGWIN' in os.uname()[0]
136
137
138
139

# Definition of CONFIGS must match that of the build directory names in the
# SConstruct script. The first list item is the default build configuration.
if IS_WINDOWS:
140
  CONFIGS = ('win-dbg8', 'win-opt8', 'win-dbg', 'win-opt')
141
142
143
144
145
elif IS_MAC:
  CONFIGS = ('mac-dbg', 'mac-opt')
else:
  CONFIGS = ('dbg', 'opt')

146
if IS_WINDOWS or IS_CYGWIN:
147
148
  PYTHON_TEST_REGEX = re.compile(r'_(unit)?test\.py$', re.IGNORECASE)
  BINARY_TEST_REGEX = re.compile(r'_(unit)?test(\.exe)?$', re.IGNORECASE)
149
  BINARY_TEST_SEARCH_REGEX = re.compile(r'_(unit)?test\.exe$', re.IGNORECASE)
150
151
152
else:
  PYTHON_TEST_REGEX = re.compile(r'_(unit)?test\.py$')
  BINARY_TEST_REGEX = re.compile(r'_(unit)?test$')
153
  BINARY_TEST_SEARCH_REGEX = BINARY_TEST_REGEX
154

155
156
157
158
159
160
161
162

def _GetGtestBuildDir(os, script_dir, config):
  """Calculates path to the Google Test SCons build directory."""

  return os.path.normpath(os.path.join(script_dir,
                                       'scons/build',
                                       config,
                                       'gtest/scons'))
163
164


165
166
# All paths in this script are either absolute or relative to the current
# working directory, unless otherwise specified.
167
168
169
class TestRunner(object):
  """Provides facilities for running Python and binary tests for Google Test."""

170
  def __init__(self,
171
               build_dir_var_name='GTEST_BUILD_DIR',
172
173
               injected_os=os,
               injected_subprocess=subprocess,
174
175
               injected_script_dir=os.path.dirname(__file__),
               injected_build_dir_finder=_GetGtestBuildDir):
176
177
    self.os = injected_os
    self.subprocess = injected_subprocess
178
179
    self.build_dir_finder = injected_build_dir_finder
    self.build_dir_var_name = build_dir_var_name
180
181
182
183
184
185
186
    # If a program using this file is invoked via a relative path, the
    # script directory will be relative to the path of the main program
    # file.  It may be '.' when this script is invoked directly or '..' when
    # it is imported for testing.  To simplify testing we inject the script
    # directory into TestRunner.
    self.script_dir = injected_script_dir

187
  def _GetBuildDirForConfig(self, config):
188
189
    """Returns the build directory for a given configuration."""

190
    return self.build_dir_finder(self.os, self.script_dir, config)
191

192
  def _Run(self, args):
193
194
195
196
197
198
199
200
201
202
203
204
205
    """Runs the executable with given args (args[0] is the executable name).

    Args:
      args: Command line arguments for the process.

    Returns:
      Process's exit code if it exits normally, or -signal if the process is
      killed by a signal.
    """

    if self.subprocess:
      return self.subprocess.Popen(args).wait()
    else:
206
      return self.os.spawnv(self.os.P_WAIT, args[0], args)
207

208
  def _RunBinaryTest(self, test):
209
    """Runs the binary test given its path.
210
211

    Args:
212
      test: Path to the test binary.
213
214
215
216
217
218

    Returns:
      Process's exit code if it exits normally, or -signal if the process is
      killed by a signal.
    """

219
    return self._Run([test])
220

221
  def _RunPythonTest(self, test, build_dir):
222
223
224
    """Runs the Python test script with the specified build directory.

    Args:
225
      test: Path to the test's Python script.
226
227
228
229
230
231
232
      build_dir: Path to the directory where the test binary is to be found.

    Returns:
      Process's exit code if it exits normally, or -signal if the process is
      killed by a signal.
    """

233
    old_build_dir = self.os.environ.get(self.build_dir_var_name)
234
235

    try:
236
      self.os.environ[self.build_dir_var_name] = build_dir
237
238
239
240

      # If this script is run on a Windows machine that has no association
      # between the .py extension and a python interpreter, simply passing
      # the script name into subprocess.Popen/os.spawn will not work.
241
      print 'Running %s . . .' % (test,)
242
      return self._Run([sys.executable, test])
243
244
245

    finally:
      if old_build_dir is None:
246
        del self.os.environ[self.build_dir_var_name]
247
      else:
248
        self.os.environ[self.build_dir_var_name] = old_build_dir
249

250
  def _FindFilesByRegex(self, directory, regex):
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
    """Returns files in a directory whose names match a regular expression.

    Args:
      directory: Path to the directory to search for files.
      regex: Regular expression to filter file names.

    Returns:
      The list of the paths to the files in the directory.
    """

    return [self.os.path.join(directory, file_name)
            for file_name in self.os.listdir(directory)
            if re.search(regex, file_name)]

  # TODO(vladl@google.com): Implement parsing of scons/SConscript to run all
  # tests defined there when no tests are specified.
  # TODO(vladl@google.com): Update the docstring after the code is changed to
  # try to test all builds defined in scons/SConscript.
  def GetTestsToRun(self,
                    args,
                    named_configurations,
                    built_configurations,
                    available_configurations=CONFIGS):
    """Determines what tests should be run.

    Args:
      args: The list of non-option arguments from the command line.
      named_configurations: The list of configurations specified via -c or -a.
      built_configurations: True if -b has been specified.
      available_configurations: a list of configurations available on the
                                current platform, injectable for testing.

    Returns:
      A tuple with 2 elements: the list of Python tests to run and the list of
      binary tests to run.
    """

    if named_configurations == 'all':
      named_configurations = ','.join(available_configurations)

291
292
    normalized_args = [self.os.path.normpath(arg) for arg in args]

293
294
295
    # A final list of build directories which will be searched for the test
    # binaries. First, add directories specified directly on the command
    # line.
296
    build_dirs = filter(self.os.path.isdir, normalized_args)
297
298
299
300

    # Adds build directories specified via their build configurations using
    # the -c or -a options.
    if named_configurations:
301
      build_dirs += [self._GetBuildDirForConfig(config)
302
303
304
305
                     for config in named_configurations.split(',')]

    # Adds KNOWN BUILD DIRECTORIES if -b is specified.
    if built_configurations:
306
      build_dirs += [self._GetBuildDirForConfig(config)
307
                     for config in available_configurations
308
                     if self.os.path.isdir(self._GetBuildDirForConfig(config))]
309
310
311
312

    # If no directories were specified either via -a, -b, -c, or directly, use
    # the default configuration.
    elif not build_dirs:
313
      build_dirs = [self._GetBuildDirForConfig(available_configurations[0])]
314
315
316
317
318
319
320
321

    # Makes sure there are no duplications.
    build_dirs = sets.Set(build_dirs)

    errors_found = False
    listed_python_tests = []  # All Python tests listed on the command line.
    listed_binary_tests = []  # All binary tests listed on the command line.

322
323
    test_dir = self.os.path.normpath(self.os.path.join(self.script_dir, 'test'))

324
325
    # Sifts through non-directory arguments fishing for any Python or binary
    # tests and detecting errors.
326
    for argument in sets.Set(normalized_args) - build_dirs:
327
      if re.search(PYTHON_TEST_REGEX, argument):
328
        python_path = self.os.path.join(test_dir,
329
330
                                        self.os.path.basename(argument))
        if self.os.path.isfile(python_path):
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
          listed_python_tests.append(python_path)
        else:
          sys.stderr.write('Unable to find Python test %s' % argument)
          errors_found = True
      elif re.search(BINARY_TEST_REGEX, argument):
        # This script also accepts binary test names prefixed with test/ for
        # the convenience of typing them (can use path completions in the
        # shell).  Strips test/ prefix from the binary test names.
        listed_binary_tests.append(self.os.path.basename(argument))
      else:
        sys.stderr.write('%s is neither test nor build directory' % argument)
        errors_found = True

    if errors_found:
      return None

    user_has_listed_tests = listed_python_tests or listed_binary_tests

    if user_has_listed_tests:
      selected_python_tests = listed_python_tests
    else:
352
353
      selected_python_tests = self._FindFilesByRegex(test_dir,
                                                     PYTHON_TEST_REGEX)
354
355
356
357
358
359
360
361
362
363
364
365
366
367

    # TODO(vladl@google.com): skip unbuilt Python tests when -b is specified.
    python_test_pairs = []
    for directory in build_dirs:
      for test in selected_python_tests:
        python_test_pairs.append((directory, test))

    binary_test_pairs = []
    for directory in build_dirs:
      if user_has_listed_tests:
        binary_test_pairs.extend(
            [(directory, self.os.path.join(directory, test))
             for test in listed_binary_tests])
      else:
368
        tests = self._FindFilesByRegex(directory, BINARY_TEST_SEARCH_REGEX)
369
370
371
372
373
        binary_test_pairs.extend([(directory, test) for test in tests])

    return (python_test_pairs, binary_test_pairs)

  def RunTests(self, python_tests, binary_tests):
374
    """Runs Python and binary tests and reports results to the standard output.
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390

    Args:
      python_tests: List of Python tests to run in the form of tuples
                    (build directory, Python test script).
      binary_tests: List of binary tests to run in the form of tuples
                    (build directory, binary file).

    Returns:
      The exit code the program should pass into sys.exit().
    """

    if python_tests or binary_tests:
      results = []
      for directory, test in python_tests:
        results.append((directory,
                        test,
391
                        self._RunPythonTest(test, directory) == 0))
392
393
394
      for directory, test in binary_tests:
        results.append((directory,
                        self.os.path.basename(test),
395
                        self._RunBinaryTest(test) == 0))
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449

      failed = [(directory, test)
                for (directory, test, success) in results
                if not success]
      print
      print '%d tests run.' % len(results)
      if failed:
        print 'The following %d tests failed:' % len(failed)
        for (directory, test) in failed:
          print '%s in %s' % (test, directory)
        return 1
      else:
        print 'All tests passed!'
    else:  # No tests defined
      print 'Nothing to test - no tests specified!'

    return 0


def _Main():
  """Runs all tests for Google Test."""

  parser = optparse.OptionParser()
  parser.add_option('-c',
                    action='store',
                    dest='configurations',
                    default=None,
                    help='Test in the specified build directories')
  parser.add_option('-a',
                    action='store_const',
                    dest='configurations',
                    default=None,
                    const='all',
                    help='Test in all default build directories')
  parser.add_option('-b',
                    action='store_const',
                    dest='built_configurations',
                    default=False,
                    const=True,
                    help=('Test in all default build directories, do not fail'
                          'if some of them do not exist'))
  (options, args) = parser.parse_args()

  test_runner = TestRunner()
  tests = test_runner.GetTestsToRun(args,
                                    options.configurations,
                                    options.built_configurations)
  if not tests:
    sys.exit(1)  # Incorrect parameters given, abort execution.

  sys.exit(test_runner.RunTests(tests[0], tests[1]))

if __name__ == '__main__':
  _Main()