gtest_test_utils.py 9.44 KB
Newer Older
shiqian's avatar
shiqian committed
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
#!/usr/bin/env python
#
# Copyright 2006, 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.

"""Unit test utilities for Google C++ Testing Framework."""

__author__ = 'wan@google.com (Zhanyong Wan)'

36
import atexit
shiqian's avatar
shiqian committed
37
import os
38
import shutil
shiqian's avatar
shiqian committed
39
import sys
40
import tempfile
shiqian's avatar
shiqian committed
41
import unittest
42
_test_module = unittest
shiqian's avatar
shiqian committed
43

44
45
# Suppresses the 'Import not at the top of the file' lint complaint.
# pylint: disable-msg=C6204
46
47
48
49
50
51
try:
  import subprocess
  _SUBPROCESS_MODULE_AVAILABLE = True
except:
  import popen2
  _SUBPROCESS_MODULE_AVAILABLE = False
52
53
# pylint: enable-msg=C6204

54
GTEST_OUTPUT_VAR_NAME = 'GTEST_OUTPUT'
55

56
IS_WINDOWS = os.name == 'nt'
57
IS_CYGWIN = os.name == 'posix' and 'CYGWIN' in os.uname()[0]
shiqian's avatar
shiqian committed
58

59
60
61
62
63
# Here we expose a class from a particular module, depending on the
# environment. The comment suppresses the 'Invalid variable name' lint
# complaint.
TestCase = _test_module.TestCase  # pylint: disable-msg=C6409

64
65
# Initially maps a flag to its default value. After
# _ParseAndStripGTestFlags() is called, maps a flag to its actual value.
shiqian's avatar
shiqian committed
66
67
68
69
70
71
72
73
_flag_map = {'gtest_source_dir': os.path.dirname(sys.argv[0]),
             'gtest_build_dir': os.path.dirname(sys.argv[0])}
_gtest_flags_are_parsed = False


def _ParseAndStripGTestFlags(argv):
  """Parses and strips Google Test flags from argv.  This is idempotent."""

74
75
76
  # Suppresses the lint complaint about a global variable since we need it
  # here to maintain module-wide state.
  global _gtest_flags_are_parsed  # pylint: disable-msg=W0603
shiqian's avatar
shiqian committed
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
  if _gtest_flags_are_parsed:
    return

  _gtest_flags_are_parsed = True
  for flag in _flag_map:
    # The environment variable overrides the default value.
    if flag.upper() in os.environ:
      _flag_map[flag] = os.environ[flag.upper()]

    # The command line flag overrides the environment variable.
    i = 1  # Skips the program name.
    while i < len(argv):
      prefix = '--' + flag + '='
      if argv[i].startswith(prefix):
        _flag_map[flag] = argv[i][len(prefix):]
        del argv[i]
        break
      else:
        # We don't increment i in case we just found a --gtest_* flag
        # and removed it from argv.
        i += 1


def GetFlag(flag):
  """Returns the value of the given flag."""

  # In case GetFlag() is called before Main(), we always call
  # _ParseAndStripGTestFlags() here to make sure the --gtest_* flags
  # are parsed.
  _ParseAndStripGTestFlags(sys.argv)

  return _flag_map[flag]


def GetSourceDir():
  """Returns the absolute path of the directory where the .py files are."""

  return os.path.abspath(GetFlag('gtest_source_dir'))


def GetBuildDir():
  """Returns the absolute path of the directory where the test binaries are."""

  return os.path.abspath(GetFlag('gtest_build_dir'))


123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
_temp_dir = None

def _RemoveTempDir():
  if _temp_dir:
    shutil.rmtree(_temp_dir, ignore_errors=True)

atexit.register(_RemoveTempDir)


def GetTempDir():
  """Returns a directory for temporary files."""

  global _temp_dir
  if not _temp_dir:
    _temp_dir = tempfile.mkdtemp()
  return _temp_dir


141
def GetTestExecutablePath(executable_name, build_dir=None):
142
143
144
145
146
147
148
  """Returns the absolute path of the test binary given its name.

  The function will print a message and abort the program if the resulting file
  doesn't exist.

  Args:
    executable_name: name of the test binary that the test script runs.
149
150
    build_dir:       directory where to look for executables, by default
                     the result of GetBuildDir().
151
152
153
154
155

  Returns:
    The absolute path of the test binary.
  """

156
157
  path = os.path.abspath(os.path.join(build_dir or GetBuildDir(),
                                      executable_name))
158
  if (IS_WINDOWS or IS_CYGWIN) and not path.endswith('.exe'):
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
    path += '.exe'

  if not os.path.exists(path):
    message = (
        'Unable to find the test binary. Please make sure to provide path\n'
        'to the binary via the --gtest_build_dir flag or the GTEST_BUILD_DIR\n'
        'environment variable. For convenient use, invoke this script via\n'
        'mk_test.py.\n'
        # TODO(vladl@google.com): change mk_test.py to test.py after renaming
        # the file.
        'Please run mk_test.py -h for help.')
    print >> sys.stderr, message
    sys.exit(1)

  return path


176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
def GetExitStatus(exit_code):
  """Returns the argument to exit(), or -1 if exit() wasn't called.

  Args:
    exit_code: the result value of os.system(command).
  """

  if os.name == 'nt':
    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
    # the argument to exit() directly.
    return exit_code
  else:
    # On Unix, os.WEXITSTATUS() must be used to extract the exit status
    # from the result of os.system().
    if os.WIFEXITED(exit_code):
      return os.WEXITSTATUS(exit_code)
    else:
      return -1


196
class Subprocess:
197
  def __init__(self, command, working_dir=None, capture_stderr=True):
198
199
200
201
202
203
204
205
206
207
208
209
    """Changes into a specified directory, if provided, and executes a command.
    Restores the old directory afterwards. Execution results are returned
    via the following attributes:
      terminated_by_sygnal   True iff the child process has been terminated
                             by a signal.
      signal                 Sygnal that terminated the child process.
      exited                 True iff the child process exited normally.
      exit_code              The code with which the child proces exited.
      output                 Child process's stdout and stderr output
                             combined in a string.

    Args:
210
211
212
213
      command:        The command to run, in the form of sys.argv.
      working_dir:    The directory to change into.
      capture_stderr: Determines whether to capture stderr in the output member
                      or to discard it.
214
215
216
217
218
219
220
221
222
223
    """

    # The subprocess module is the preferrable way of running programs
    # since it is available and behaves consistently on all platforms,
    # including Windows. But it is only available starting in python 2.4.
    # In earlier python versions, we revert to the popen2 module, which is
    # available in python 2.0 and later but doesn't provide required
    # functionality (Popen4) under Windows. This allows us to support Mac
    # OS X 10.4 Tiger, which has python 2.3 installed.
    if _SUBPROCESS_MODULE_AVAILABLE:
224
225
226
227
228
      if capture_stderr:
        stderr = subprocess.STDOUT
      else:
        stderr = subprocess.PIPE

229
      p = subprocess.Popen(command,
230
                           stdout=subprocess.PIPE, stderr=stderr,
231
232
233
                           cwd=working_dir, universal_newlines=True)
      # communicate returns a tuple with the file obect for the child's
      # output.
234
235
      self.output = p.communicate()[0]
      self._return_code = p.returncode
236
    else:
237
      old_dir = os.getcwd()
238
239
240
      try:
        if working_dir is not None:
          os.chdir(working_dir)
241
242
243
244
        if capture_stderr:
          p = popen2.Popen4(command)
        else:
          p = popen2.Popen3(command)
245
        p.tochild.close()
246
        self.output = p.fromchild.read()
247
248
249
250
251
252
        ret_code = p.wait()
      finally:
        os.chdir(old_dir)
      # Converts ret_code to match the semantics of
      # subprocess.Popen.returncode.
      if os.WIFSIGNALED(ret_code):
253
        self._return_code = -os.WTERMSIG(ret_code)
254
      else:  # os.WIFEXITED(ret_code) should return True here.
255
        self._return_code = os.WEXITSTATUS(ret_code)
256

257
258
259
260
    if self._return_code < 0:
      self.terminated_by_signal = True
      self.exited = False
      self.signal = -self._return_code
261
    else:
262
263
264
      self.terminated_by_signal = False
      self.exited = True
      self.exit_code = self._return_code
265
266


shiqian's avatar
shiqian committed
267
268
269
270
271
272
273
def Main():
  """Runs the unit test."""

  # We must call _ParseAndStripGTestFlags() before calling
  # unittest.main().  Otherwise the latter will be confused by the
  # --gtest_* flags.
  _ParseAndStripGTestFlags(sys.argv)
274
275
276
277
278
279
280
  # The tested binaries should not be writing XML output files unless the
  # script explicitly instructs them to.
  # TODO(vladl@google.com): Move this into Subprocess when we implement
  # passing environment into it as a parameter.
  if GTEST_OUTPUT_VAR_NAME in os.environ:
    del os.environ[GTEST_OUTPUT_VAR_NAME]

281
  _test_module.main()