Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F77737707
run_tests_util_test.py
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Fri, Aug 16, 03:37
Size
23 KB
Mime Type
text/x-python
Expires
Sun, Aug 18, 03:37 (1 d, 23 h)
Engine
blob
Format
Raw Data
Handle
19914913
Attached To
R9484 sp4e-homework-lars-bertil
run_tests_util_test.py
View Options
#!/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
\n
expected:
\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
()
Event Timeline
Log In to Comment