mirror of
https://github.com/google/googletest.git
synced 2024-12-27 18:31:21 +08:00
Merge branch 'master' into master
This commit is contained in:
Gennadiy Civil
GitHub
commit
9e236748fb
14
.gitignore
vendored
14
.gitignore
vendored
@ -8,3 +8,17 @@ bazel-genfiles
|
||||
bazel-googletest
|
||||
bazel-out
|
||||
bazel-testlogs
|
||||
# python
|
||||
*.pyc
|
||||
|
||||
# Visual Studio files
|
||||
*.sdf
|
||||
*.opensdf
|
||||
*.VC.opendb
|
||||
*.suo
|
||||
*.user
|
||||
_ReSharper.Caches/
|
||||
Win32-Debug/
|
||||
Win32-Release/
|
||||
x64-Debug/
|
||||
x64-Release/
|
||||
|
||||
19
.travis.yml
19
.travis.yml
@ -7,7 +7,11 @@ install:
|
||||
# /usr/bin/gcc is 4.6 always, but gcc-X.Y is available.
|
||||
- if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi
|
||||
# /usr/bin/clang is 3.4, lets override with modern one.
|
||||
- if [ "$CXX" = "clang++" ] && [ "$TRAVIS_OS_NAME" = "linux" ]; then export CXX="clang++-3.7" CC="clang-3.7"; fi
|
||||
- if [ "$CXX" = "clang++" ] && [ "$TRAVIS_OS_NAME" = "linux" ]; then export CXX="clang++-3.7" CC="clang-3.7"; ln -sf /usr/bin/ccache /$HOME/bin/$CXX; ln -sf /usr/bin/ccache /$HOME/bin/$CC; fi
|
||||
# ccache on OS X needs installation first
|
||||
- if [ "$TRAVIS_OS_NAME" = "osx" ]; then brew update; brew install ccache; export PATH="/usr/local/opt/ccache/libexec:$PATH"; fi
|
||||
# reset ccache statistics
|
||||
- ccache --zero-stats
|
||||
- echo ${PATH}
|
||||
- echo ${CXX}
|
||||
- ${CXX} --version
|
||||
@ -22,25 +26,24 @@ addons:
|
||||
- ubuntu-toolchain-r-test
|
||||
- llvm-toolchain-precise-3.7
|
||||
packages:
|
||||
- gcc-4.9
|
||||
- g++-4.9
|
||||
- clang-3.7
|
||||
- valgrind
|
||||
os:
|
||||
- linux
|
||||
- osx
|
||||
language: cpp
|
||||
cache: ccache
|
||||
before_cache:
|
||||
# print statistics before uploading new cache
|
||||
- ccache --show-stats
|
||||
compiler:
|
||||
- gcc
|
||||
- clang
|
||||
script: ./travis.sh
|
||||
env:
|
||||
matrix:
|
||||
- GTEST_TARGET=googletest SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug VERBOSE_MAKE=true VERBOSE
|
||||
- GTEST_TARGET=googlemock SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug VERBOSE_MAKE=true VERBOSE
|
||||
- GTEST_TARGET=googlemock SHARED_LIB=OFF STATIC_LIB=ON CMAKE_PKG=OFF BUILD_TYPE=debug CXX_FLAGS=-std=c++11 VERBOSE_MAKE=true VERBOSE
|
||||
# - GTEST_TARGET=googletest SHARED_LIB=ON STATIC_LIB=ON CMAKE_PKG=ON BUILD_TYPE=release VERBOSE_MAKE=false
|
||||
# - GTEST_TARGET=googlemock SHARED_LIB=ON STATIC_LIB=ON CMAKE_PKG=ON BUILD_TYPE=release VERBOSE_MAKE=false
|
||||
- BUILD_TYPE=Debug VERBOSE=1
|
||||
- BUILD_TYPE=Release VERBOSE=1 CXX_FLAGS=-std=c++11
|
||||
notifications:
|
||||
email: false
|
||||
sudo: false
|
||||
|
||||
@ -26,7 +26,7 @@ in its interior [googletest/README.md](googletest/README.md) file.
|
||||
|
||||
## Features ##
|
||||
|
||||
* An [XUnit](https://en.wikipedia.org/wiki/XUnit) test framework.
|
||||
* An [xUnit](https://en.wikipedia.org/wiki/XUnit) test framework.
|
||||
* Test discovery.
|
||||
* A rich set of assertions.
|
||||
* User-defined assertions.
|
||||
|
||||
97
appveyor.yml
97
appveyor.yml
@ -4,68 +4,93 @@ os: Visual Studio 2015
|
||||
|
||||
environment:
|
||||
matrix:
|
||||
- Toolset: v140
|
||||
- Toolset: v120
|
||||
- Toolset: v110
|
||||
- Toolset: v100
|
||||
- compiler: msvc-15-seh
|
||||
generator: "Visual Studio 15 2017"
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
|
||||
platform:
|
||||
- Win32
|
||||
- x64
|
||||
- compiler: msvc-15-seh
|
||||
generator: "Visual Studio 15 2017 Win64"
|
||||
APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
|
||||
|
||||
- compiler: msvc-14-seh
|
||||
generator: "Visual Studio 14 2015"
|
||||
|
||||
- compiler: msvc-14-seh
|
||||
generator: "Visual Studio 14 2015 Win64"
|
||||
|
||||
- compiler: msvc-12-seh
|
||||
generator: "Visual Studio 12 2013"
|
||||
|
||||
- compiler: msvc-12-seh
|
||||
generator: "Visual Studio 12 2013 Win64"
|
||||
|
||||
- compiler: msvc-11-seh
|
||||
generator: "Visual Studio 11 2012"
|
||||
|
||||
- compiler: msvc-11-seh
|
||||
generator: "Visual Studio 11 2012 Win64"
|
||||
|
||||
- compiler: msvc-10-seh
|
||||
generator: "Visual Studio 10 2010"
|
||||
|
||||
- compiler: gcc-5.3.0-posix
|
||||
generator: "MinGW Makefiles"
|
||||
cxx_path: 'C:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin'
|
||||
|
||||
- compiler: gcc-6.3.0-posix
|
||||
generator: "MinGW Makefiles"
|
||||
cxx_path: 'C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin'
|
||||
|
||||
configuration:
|
||||
# - Release
|
||||
- Debug
|
||||
#- Release
|
||||
|
||||
build:
|
||||
verbosity: minimal
|
||||
|
||||
artifacts:
|
||||
- path: '_build/Testing/Temporary/*'
|
||||
name: test_results
|
||||
|
||||
before_build:
|
||||
install:
|
||||
- ps: |
|
||||
Write-Output "Configuration: $env:CONFIGURATION"
|
||||
Write-Output "Platform: $env:PLATFORM"
|
||||
$generator = switch ($env:TOOLSET)
|
||||
{
|
||||
"v140" {"Visual Studio 14 2015"}
|
||||
"v120" {"Visual Studio 12 2013"}
|
||||
"v110" {"Visual Studio 11 2012"}
|
||||
"v100" {"Visual Studio 10 2010"}
|
||||
}
|
||||
if ($env:PLATFORM -eq "x64")
|
||||
{
|
||||
$generator = "$generator Win64"
|
||||
Write-Output "Compiler: $env:compiler"
|
||||
Write-Output "Generator: $env:generator"
|
||||
|
||||
# git bash conflicts with MinGW makefiles
|
||||
if ($env:generator -eq "MinGW Makefiles") {
|
||||
$env:path = $env:path.replace("C:\Program Files\Git\usr\bin;", "")
|
||||
if ($env:cxx_path -ne "") {
|
||||
$env:path += ";$env:cxx_path"
|
||||
}
|
||||
}
|
||||
|
||||
build_script:
|
||||
- ps: |
|
||||
if (($env:TOOLSET -eq "v100") -and ($env:PLATFORM -eq "x64"))
|
||||
{
|
||||
return
|
||||
}
|
||||
md _build -Force | Out-Null
|
||||
cd _build
|
||||
|
||||
& cmake -G "$generator" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" -Dgtest_build_tests=ON -Dgtest_build_samples=ON -Dgmock_build_tests=ON ..
|
||||
$conf = if ($env:generator -eq "MinGW Makefiles") {"-DCMAKE_BUILD_TYPE=$env:configuration"} else {"-DCMAKE_CONFIGURATION_TYPES=Debug;Release"}
|
||||
# Disable test for MinGW (gtest tests fail, gmock tests can not build)
|
||||
$gtest_build_tests = if ($env:generator -eq "MinGW Makefiles") {"-Dgtest_build_tests=OFF"} else {"-Dgtest_build_tests=ON"}
|
||||
$gmock_build_tests = if ($env:generator -eq "MinGW Makefiles") {"-Dgmock_build_tests=OFF"} else {"-Dgmock_build_tests=ON"}
|
||||
& cmake -G "$env:generator" $conf -Dgtest_build_samples=ON $gtest_build_tests $gmock_build_tests ..
|
||||
if ($LastExitCode -ne 0) {
|
||||
throw "Exec: $ErrorMessage"
|
||||
}
|
||||
& cmake --build . --config $env:CONFIGURATION
|
||||
& cmake --build . --config $env:configuration
|
||||
if ($LastExitCode -ne 0) {
|
||||
throw "Exec: $ErrorMessage"
|
||||
}
|
||||
|
||||
test_script:
|
||||
- ps: |
|
||||
if (($env:Toolset -eq "v100") -and ($env:PLATFORM -eq "x64"))
|
||||
{
|
||||
return
|
||||
if ($env:generator -eq "MinGW Makefiles") {
|
||||
return # No test available for MinGW
|
||||
}
|
||||
|
||||
& ctest -C $env:CONFIGURATION --output-on-failure
|
||||
& ctest -C $env:configuration --timeout 300 --output-on-failure
|
||||
if ($LastExitCode -ne 0) {
|
||||
throw "Exec: $ErrorMessage"
|
||||
}
|
||||
|
||||
artifacts:
|
||||
- path: '_build/CMakeFiles/*.log'
|
||||
name: logs
|
||||
- path: '_build/Testing/**/*.xml'
|
||||
name: test_results
|
||||
|
||||
@ -164,7 +164,7 @@ if (gmock_build_tests)
|
||||
cxx_test(gmock_link_test gmock_main test/gmock_link2_test.cc)
|
||||
cxx_test(gmock_test gmock_main)
|
||||
|
||||
if (CMAKE_USE_PTHREADS_INIT)
|
||||
if (DEFINED GTEST_HAS_PTHREAD)
|
||||
cxx_test(gmock_stress_test gmock)
|
||||
endif()
|
||||
|
||||
|
||||
@ -78,7 +78,7 @@ posting a question on the
|
||||
|
||||
Google Mock is not a testing framework itself. Instead, it needs a
|
||||
testing framework for writing tests. Google Mock works seamlessly
|
||||
with [Google Test](http://code.google.com/p/googletest/), but
|
||||
with [Google Test](https://github.com/google/googletest), but
|
||||
you can also use it with [any C++ testing framework](../../master/googlemock/docs/ForDummies.md#using-google-mock-with-any-testing-framework).
|
||||
|
||||
### Requirements for End Users ###
|
||||
@ -333,8 +333,8 @@ may need to tweak your compiler and/or linker flags. Please see the
|
||||
If you have custom matchers defined using `MatcherInterface` or
|
||||
`MakePolymorphicMatcher()`, you'll need to update their definitions to
|
||||
use the new matcher API (
|
||||
[monomorphic](http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Monomorphic_Matchers),
|
||||
[polymorphic](http://code.google.com/p/googlemock/wiki/CookBook#Writing_New_Polymorphic_Matchers)).
|
||||
[monomorphic](./docs/CookBook.md#writing-new-monomorphic-matchers),
|
||||
[polymorphic](./docs/CookBook.md#writing-new-polymorphic-matchers)).
|
||||
Matchers defined using `MATCHER()` or `MATCHER_P*()` aren't affected.
|
||||
|
||||
### Developing Google Mock ###
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
m4_include(../googletest/m4/acx_pthread.m4)
|
||||
|
||||
AC_INIT([Google C++ Mocking Framework],
|
||||
[1.7.0],
|
||||
[1.8.0],
|
||||
[googlemock@googlegroups.com],
|
||||
[gmock])
|
||||
|
||||
@ -101,7 +101,7 @@ AC_ARG_VAR([GTEST_VERSION],
|
||||
[The version of Google Test available.])
|
||||
HAVE_BUILT_GTEST="no"
|
||||
|
||||
GTEST_MIN_VERSION="1.7.0"
|
||||
GTEST_MIN_VERSION="1.8.0"
|
||||
|
||||
AS_IF([test "x${enable_external_gtest}" = "xyes"],
|
||||
[# Begin filling in variables as we are able.
|
||||
|
||||
@ -65,7 +65,7 @@ can specify it by appending `_WITH_CALLTYPE` to any of the macros
|
||||
described in the previous two sections and supplying the calling
|
||||
convention as the first argument to the macro. For example,
|
||||
```
|
||||
MOCK_METHOD_1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
|
||||
MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int n));
|
||||
MOCK_CONST_METHOD2_WITH_CALLTYPE(STDMETHODCALLTYPE, Bar, int(double x, double y));
|
||||
```
|
||||
where `STDMETHODCALLTYPE` is defined by `<objbase.h>` on Windows.
|
||||
@ -249,7 +249,7 @@ match them more flexibly, or get more informative messages, you can use:
|
||||
| `SizeIs(m)` | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`. |
|
||||
| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under some permutation each element matches an `ei` (for a different `i`), which can be a value or a matcher. 0 to 10 arguments are allowed. |
|
||||
| `UnorderedElementsAreArray({ e0, e1, ..., en })`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, or C-style array. |
|
||||
| `WhenSorted(m)` | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(UnorderedElementsAre(1, 2, 3))` verifies that `argument` contains elements `1`, `2`, and `3`, ignoring order. |
|
||||
| `WhenSorted(m)` | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(ElementsAre(1, 2, 3))` verifies that `argument` contains elements `1`, `2`, and `3`, ignoring order. |
|
||||
| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater<int>(), ElementsAre(3, 2, 1))`. |
|
||||
|
||||
Notes:
|
||||
|
||||
@ -148,7 +148,7 @@ Note that the mock class doesn't define `AppendPacket()`, unlike the
|
||||
real class. That's fine as long as the test doesn't need to call it.
|
||||
|
||||
Next, you need a way to say that you want to use
|
||||
`ConcretePacketStream` in production code, and use `MockPacketStream`
|
||||
`ConcretePacketStream` in production code and to use `MockPacketStream`
|
||||
in tests. Since the functions are not virtual and the two classes are
|
||||
unrelated, you must specify your choice at _compile time_ (as opposed
|
||||
to run time).
|
||||
@ -227,7 +227,7 @@ If a mock method has no `EXPECT_CALL` spec but is called, Google Mock
|
||||
will print a warning about the "uninteresting call". The rationale is:
|
||||
|
||||
* New methods may be added to an interface after a test is written. We shouldn't fail a test just because a method it doesn't know about is called.
|
||||
* However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, he can add an `EXPECT_CALL()` to suppress the warning.
|
||||
* However, this may also mean there's a bug in the test, so Google Mock shouldn't be silent either. If the user believes these calls are harmless, they can add an `EXPECT_CALL()` to suppress the warning.
|
||||
|
||||
However, sometimes you may want to suppress all "uninteresting call"
|
||||
warnings, while sometimes you may want the opposite, i.e. to treat all
|
||||
@ -706,7 +706,7 @@ type `m` accepts):
|
||||
1. When both `T` and `U` are built-in arithmetic types (`bool`, integers, and floating-point numbers), the conversion from `T` to `U` is not lossy (in other words, any value representable by `T` can also be represented by `U`); and
|
||||
1. When `U` is a reference, `T` must also be a reference (as the underlying matcher may be interested in the address of the `U` value).
|
||||
|
||||
The code won't compile if any of these conditions isn't met.
|
||||
The code won't compile if any of these conditions aren't met.
|
||||
|
||||
Here's one example:
|
||||
|
||||
|
||||
@ -64,7 +64,7 @@ compile it in the [README](../README.md) file.
|
||||
A mocking framework is of no good if itself is not thoroughly tested.
|
||||
Tests should be written for any new code, and changes should be
|
||||
verified to not break existing tests before they are submitted for
|
||||
review. To perform the tests, follow the instructions in [README](http://code.google.com/p/googlemock/source/browse/trunk/README) and
|
||||
review. To perform the tests, follow the instructions in [README](../README.md) and
|
||||
verify that there are no failures.
|
||||
|
||||
# Contributing Code #
|
||||
@ -98,7 +98,7 @@ to conform to the style outlined [here](https://google.github.io/styleguide/cppg
|
||||
Please do submit code. Here's what you need to do:
|
||||
|
||||
1. Normally you should make your change against the SVN trunk instead of a branch or a tag, as the latter two are for release control and should be treated mostly as read-only.
|
||||
1. Decide which code you want to submit. A submission should be a set of changes that addresses one issue in the [Google Mock issue tracker](http://code.google.com/p/googlemock/issues/list). Please don't mix more than one logical change per submittal, because it makes the history hard to follow. If you want to make a change that doesn't have a corresponding issue in the issue tracker, please create one.
|
||||
1. Decide which code you want to submit. A submission should be a set of changes that addresses one issue in the [Google Mock issue tracker](https://github.com/google/googletest/issues). Please don't mix more than one logical change per submittal, because it makes the history hard to follow. If you want to make a change that doesn't have a corresponding issue in the issue tracker, please create one.
|
||||
1. Also, coordinate with team members that are listed on the issue in question. This ensures that work isn't being duplicated and communicating your plan early also generally leads to better patches.
|
||||
1. Ensure that your code adheres to the [Google Mock source code style](#Coding_Style.md).
|
||||
1. Ensure that there are unit tests for your code.
|
||||
|
||||
@ -217,7 +217,8 @@ The macro can be followed by some optional _clauses_ that provide more informati
|
||||
This syntax is designed to make an expectation read like English. For example, you can probably guess that
|
||||
|
||||
```
|
||||
using ::testing::Return;...
|
||||
using ::testing::Return;
|
||||
...
|
||||
EXPECT_CALL(turtle, GetX())
|
||||
.Times(5)
|
||||
.WillOnce(Return(100))
|
||||
@ -251,7 +252,8 @@ EXPECT_CALL(turtle, Forward(_));
|
||||
A list of built-in matchers can be found in the [CheatSheet](CheatSheet.md). For example, here's the `Ge` (greater than or equal) matcher:
|
||||
|
||||
```
|
||||
using ::testing::Ge;...
|
||||
using ::testing::Ge;
|
||||
...
|
||||
EXPECT_CALL(turtle, Forward(Ge(100)));
|
||||
```
|
||||
|
||||
@ -280,7 +282,8 @@ First, if the return type of a mock function is a built-in type or a pointer, th
|
||||
Second, if a mock function doesn't have a default action, or the default action doesn't suit you, you can specify the action to be taken each time the expectation matches using a series of `WillOnce()` clauses followed by an optional `WillRepeatedly()`. For example,
|
||||
|
||||
```
|
||||
using ::testing::Return;...
|
||||
using ::testing::Return;
|
||||
...
|
||||
EXPECT_CALL(turtle, GetX())
|
||||
.WillOnce(Return(100))
|
||||
.WillOnce(Return(200))
|
||||
@ -290,7 +293,8 @@ EXPECT_CALL(turtle, GetX())
|
||||
This says that `turtle.GetX()` will be called _exactly three times_ (Google Mock inferred this from how many `WillOnce()` clauses we've written, since we didn't explicitly write `Times()`), and will return 100, 200, and 300 respectively.
|
||||
|
||||
```
|
||||
using ::testing::Return;...
|
||||
using ::testing::Return;
|
||||
...
|
||||
EXPECT_CALL(turtle, GetY())
|
||||
.WillOnce(Return(100))
|
||||
.WillOnce(Return(200))
|
||||
@ -317,7 +321,8 @@ Instead of returning 100, 101, 102, ..., consecutively, this mock function will
|
||||
Time for another quiz! What do you think the following means?
|
||||
|
||||
```
|
||||
using ::testing::Return;...
|
||||
using ::testing::Return;
|
||||
...
|
||||
EXPECT_CALL(turtle, GetY())
|
||||
.Times(4)
|
||||
.WillOnce(Return(100));
|
||||
@ -331,7 +336,8 @@ So far we've only shown examples where you have a single expectation. More reali
|
||||
By default, when a mock method is invoked, Google Mock will search the expectations in the **reverse order** they are defined, and stop when an active expectation that matches the arguments is found (you can think of it as "newer rules override older ones."). If the matching expectation cannot take any more calls, you will get an upper-bound-violated failure. Here's an example:
|
||||
|
||||
```
|
||||
using ::testing::_;...
|
||||
using ::testing::_;
|
||||
...
|
||||
EXPECT_CALL(turtle, Forward(_)); // #1
|
||||
EXPECT_CALL(turtle, Forward(10)) // #2
|
||||
.Times(2);
|
||||
@ -347,7 +353,8 @@ By default, an expectation can match a call even though an earlier expectation h
|
||||
Sometimes, you may want all the expected calls to occur in a strict order. To say this in Google Mock is easy:
|
||||
|
||||
```
|
||||
using ::testing::InSequence;...
|
||||
using ::testing::InSequence;
|
||||
...
|
||||
TEST(FooTest, DrawsLineSegment) {
|
||||
...
|
||||
{
|
||||
@ -373,7 +380,8 @@ Now let's do a quick quiz to see how well you can use this mock stuff already. H
|
||||
After you've come up with your answer, take a look at ours and compare notes (solve it yourself first - don't cheat!):
|
||||
|
||||
```
|
||||
using ::testing::_;...
|
||||
using ::testing::_;
|
||||
...
|
||||
EXPECT_CALL(turtle, GoTo(_, _)) // #1
|
||||
.Times(AnyNumber());
|
||||
EXPECT_CALL(turtle, GoTo(0, 0)) // #2
|
||||
|
||||
@ -240,7 +240,7 @@ You cannot mock a variadic function (i.e. a function taking ellipsis
|
||||
The problem is that in general, there is _no way_ for a mock object to
|
||||
know how many arguments are passed to the variadic method, and what
|
||||
the arguments' types are. Only the _author of the base class_ knows
|
||||
the protocol, and we cannot look into his head.
|
||||
the protocol, and we cannot look into their head.
|
||||
|
||||
Therefore, to mock such a function, the _user_ must teach the mock
|
||||
object how to figure out the number of arguments and their types. One
|
||||
|
||||
@ -875,7 +875,7 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
|
||||
// MORE INFORMATION:
|
||||
//
|
||||
// To learn more about using these macros, please search for 'ACTION'
|
||||
// on http://code.google.com/p/googlemock/wiki/CookBook.
|
||||
// on https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
|
||||
|
||||
// An internal macro needed for implementing ACTION*().
|
||||
#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\
|
||||
|
||||
@ -357,7 +357,7 @@ $range j2 2..i
|
||||
// MORE INFORMATION:
|
||||
//
|
||||
// To learn more about using these macros, please search for 'ACTION'
|
||||
// on http://code.google.com/p/googlemock/wiki/CookBook.
|
||||
// on https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
|
||||
|
||||
$range i 0..n
|
||||
$range k 0..n-1
|
||||
|
||||
@ -1376,7 +1376,8 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
// ================
|
||||
//
|
||||
// To learn more about using these macros, please search for 'MATCHER'
|
||||
// on http://code.google.com/p/googlemock/wiki/CookBook.
|
||||
// on https://github.com/google/googletest/blob/master/googlemock/docs/
|
||||
// CookBook.md
|
||||
|
||||
#define MATCHER(name, description)\
|
||||
class name##Matcher {\
|
||||
@ -1397,8 +1398,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1446,8 +1448,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1499,8 +1502,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1557,8 +1561,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1620,8 +1625,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1691,8 +1697,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1765,8 +1772,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1843,8 +1851,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -1928,8 +1937,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -2019,8 +2029,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
@ -2115,8 +2126,9 @@ AnyOf(M1 m1, M2 m2, M3 m3, M4 m4, M5 m5, M6 m6, M7 m7, M8 m8, M9 m9, M10 m10) {
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
|
||||
@ -587,7 +587,7 @@ $$ // show up in the generated code.
|
||||
// ================
|
||||
//
|
||||
// To learn more about using these macros, please search for 'MATCHER'
|
||||
// on http://code.google.com/p/googlemock/wiki/CookBook.
|
||||
// on https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md
|
||||
|
||||
$range i 0..n
|
||||
$for i
|
||||
@ -639,8 +639,9 @@ $var param_field_decls2 = [[$for j
|
||||
private:\
|
||||
::testing::internal::string FormatDescription(bool negation) const {\
|
||||
const ::testing::internal::string gmock_description = (description);\
|
||||
if (!gmock_description.empty())\
|
||||
if (!gmock_description.empty()) {\
|
||||
return gmock_description;\
|
||||
}\
|
||||
return ::testing::internal::FormatMatcherDescription(\
|
||||
negation, #name, \
|
||||
::testing::internal::UniversalTersePrintTupleFieldsToStrings(\
|
||||
|
||||
@ -363,7 +363,6 @@ enum CallReaction {
|
||||
kAllow,
|
||||
kWarn,
|
||||
kFail,
|
||||
kDefault = kWarn // By default, warn about uninteresting calls.
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
@ -1775,7 +1774,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
|
||||
// There is no generally useful and implementable semantics of
|
||||
// copying a mock object, so copying a mock is usually a user error.
|
||||
// Thus we disallow copying function mockers. If the user really
|
||||
// wants to copy a mock object, he should implement his own copy
|
||||
// wants to copy a mock object, they should implement their own copy
|
||||
// operation, for example:
|
||||
//
|
||||
// class MockFoo : public Foo {
|
||||
|
||||
@ -71,6 +71,7 @@ namespace testing {
|
||||
// Declares Google Mock flags that we want a user to use programmatically.
|
||||
GMOCK_DECLARE_bool_(catch_leaked_mocks);
|
||||
GMOCK_DECLARE_string_(verbose);
|
||||
GMOCK_DECLARE_int32_(default_mock_behavior);
|
||||
|
||||
// Initializes Google Mock. This must be called before running the
|
||||
// tests. In particular, it parses the command line for the flags
|
||||
|
||||
@ -55,7 +55,7 @@ EXAMPLES
|
||||
This tool is experimental. In particular, it assumes that there is no
|
||||
conditional inclusion of Google Mock or Google Test headers. Please
|
||||
report any problems to googlemock@googlegroups.com. You can read
|
||||
http://code.google.com/p/googlemock/wiki/CookBook for more
|
||||
https://github.com/google/googletest/blob/master/googlemock/docs/CookBook.md for more
|
||||
information.
|
||||
"""
|
||||
|
||||
|
||||
@ -71,7 +71,7 @@ GTEST_API_ string ConvertIdentifierNameToWords(const char* id_name) {
|
||||
}
|
||||
|
||||
// This class reports Google Mock failures as Google Test failures. A
|
||||
// user can define another class in a similar fashion if he intends to
|
||||
// user can define another class in a similar fashion if they intend to
|
||||
// use Google Mock with a testing framework other than Google Test.
|
||||
class GoogleTestFailureReporter : public FailureReporterInterface {
|
||||
public:
|
||||
|
||||
@ -353,10 +353,10 @@ UntypedFunctionMockerBase::UntypedInvokeWith(const void* const untyped_args)
|
||||
// the behavior of ReportUninterestingCall().
|
||||
const bool need_to_report_uninteresting_call =
|
||||
// If the user allows this uninteresting call, we print it
|
||||
// only when he wants informational messages.
|
||||
// only when they want informational messages.
|
||||
reaction == kAllow ? LogIsVisible(kInfo) :
|
||||
// If the user wants this to be a warning, we print it only
|
||||
// when he wants to see warnings.
|
||||
// when they want to see warnings.
|
||||
reaction == kWarn ? LogIsVisible(kWarning) :
|
||||
// Otherwise, the user wants this to be an error, and we
|
||||
// should always print detailed information in the error.
|
||||
@ -508,6 +508,13 @@ bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
|
||||
return expectations_met;
|
||||
}
|
||||
|
||||
CallReaction intToCallReaction(int mock_behavior) {
|
||||
if (mock_behavior >= kAllow && mock_behavior <= kFail) {
|
||||
return static_cast<internal::CallReaction>(mock_behavior);
|
||||
}
|
||||
return kWarn;
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
|
||||
// Class Mock.
|
||||
@ -648,7 +655,8 @@ internal::CallReaction Mock::GetReactionOnUninterestingCalls(
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
|
||||
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||
return (g_uninteresting_call_reaction.count(mock_obj) == 0) ?
|
||||
internal::kDefault : g_uninteresting_call_reaction[mock_obj];
|
||||
internal::intToCallReaction(GMOCK_FLAG(default_mock_behavior)) :
|
||||
g_uninteresting_call_reaction[mock_obj];
|
||||
}
|
||||
|
||||
// Tells Google Mock to ignore mock_obj when checking for leaked mock
|
||||
|
||||
@ -48,6 +48,13 @@ GMOCK_DEFINE_string_(verbose, internal::kWarningVerbosity,
|
||||
" warning - prints warnings and errors.\n"
|
||||
" error - prints errors only.");
|
||||
|
||||
GMOCK_DEFINE_int32_(default_mock_behavior, 1,
|
||||
"Controls the default behavior of mocks."
|
||||
" Valid values:\n"
|
||||
" 0 - by default, mocks act as NiceMocks.\n"
|
||||
" 1 - by default, mocks act as NaggyMocks.\n"
|
||||
" 2 - by default, mocks act as StrictMocks.");
|
||||
|
||||
namespace internal {
|
||||
|
||||
// Parses a string as a command line flag. The string should have the
|
||||
@ -120,6 +127,19 @@ static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
|
||||
int* value) {
|
||||
// Gets the value of the flag as a string.
|
||||
const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
|
||||
|
||||
// Aborts if the parsing failed.
|
||||
if (value_str == NULL) return false;
|
||||
|
||||
// Sets *value to the value of the flag.
|
||||
*value = atoi(value_str);
|
||||
return true;
|
||||
}
|
||||
|
||||
// The internal implementation of InitGoogleMock().
|
||||
//
|
||||
// The type parameter CharType can be instantiated to either char or
|
||||
@ -138,7 +158,9 @@ void InitGoogleMockImpl(int* argc, CharType** argv) {
|
||||
// Do we see a Google Mock flag?
|
||||
if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
|
||||
&GMOCK_FLAG(catch_leaked_mocks)) ||
|
||||
ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose))) {
|
||||
ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
|
||||
ParseGoogleMockIntFlag(arg, "default_mock_behavior",
|
||||
&GMOCK_FLAG(default_mock_behavior))) {
|
||||
// Yes. Shift the remainder of the argv list left by one. Note
|
||||
// that argv has (*argc + 1) elements, the last one always being
|
||||
// NULL. The following loop moves the trailing NULL element as
|
||||
|
||||
@ -391,7 +391,7 @@ TEST(ExactlyTest, HasCorrectBounds) {
|
||||
EXPECT_EQ(3, c.ConservativeUpperBound());
|
||||
}
|
||||
|
||||
// Tests that a user can make his own cardinality by implementing
|
||||
// Tests that a user can make their own cardinality by implementing
|
||||
// CardinalityInterface and calling MakeCardinality().
|
||||
|
||||
class EvenCardinality : public CardinalityInterface {
|
||||
|
||||
@ -120,7 +120,7 @@ TEST(ArgsTest, AcceptsOneTemplateArg) {
|
||||
}
|
||||
|
||||
TEST(ArgsTest, AcceptsTwoTemplateArgs) {
|
||||
const tuple<short, int, long> t(4, 5, 6L); // NOLINT
|
||||
const tuple<short, int, long> t(static_cast<short>(4), 5, 6L); // NOLINT
|
||||
|
||||
EXPECT_THAT(t, (Args<0, 1>(Lt())));
|
||||
EXPECT_THAT(t, (Args<1, 2>(Lt())));
|
||||
@ -128,13 +128,13 @@ TEST(ArgsTest, AcceptsTwoTemplateArgs) {
|
||||
}
|
||||
|
||||
TEST(ArgsTest, AcceptsRepeatedTemplateArgs) {
|
||||
const tuple<short, int, long> t(4, 5, 6L); // NOLINT
|
||||
const tuple<short, int, long> t(static_cast<short>(4), 5, 6L); // NOLINT
|
||||
EXPECT_THAT(t, (Args<0, 0>(Eq())));
|
||||
EXPECT_THAT(t, Not(Args<1, 1>(Ne())));
|
||||
}
|
||||
|
||||
TEST(ArgsTest, AcceptsDecreasingTemplateArgs) {
|
||||
const tuple<short, int, long> t(4, 5, 6L); // NOLINT
|
||||
const tuple<short, int, long> t(static_cast<short>(4), 5, 6L); // NOLINT
|
||||
EXPECT_THAT(t, (Args<2, 0>(Gt())));
|
||||
EXPECT_THAT(t, Not(Args<2, 1>(Lt())));
|
||||
}
|
||||
@ -159,7 +159,7 @@ TEST(ArgsTest, AcceptsMoreTemplateArgsThanArityOfOriginalTuple) {
|
||||
}
|
||||
|
||||
TEST(ArgsTest, CanBeNested) {
|
||||
const tuple<short, int, long, int> t(4, 5, 6L, 6); // NOLINT
|
||||
const tuple<short, int, long, int> t(static_cast<short>(4), 5, 6L, 6); // NOLINT
|
||||
EXPECT_THAT(t, (Args<1, 2, 3>(Args<1, 2>(Eq()))));
|
||||
EXPECT_THAT(t, (Args<0, 1, 3>(Args<0, 2>(Lt()))));
|
||||
}
|
||||
|
||||
@ -49,7 +49,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -58,6 +58,11 @@
|
||||
# include <forward_list> // NOLINT
|
||||
#endif
|
||||
|
||||
// Disable MSVC2015 warning for std::pair: "decorated name length exceeded, name was truncated".
|
||||
#if defined(_MSC_VER) && (_MSC_VER == 1900)
|
||||
# pragma warning(disable:4503)
|
||||
#endif
|
||||
|
||||
namespace testing {
|
||||
|
||||
namespace internal {
|
||||
@ -3931,8 +3936,11 @@ TEST(ResultOfTest, WorksForFunctionReferences) {
|
||||
|
||||
// Tests that ResultOf(f, ...) compiles and works as expected when f is a
|
||||
// function object.
|
||||
struct Functor : public ::std::unary_function<int, std::string> {
|
||||
result_type operator()(argument_type input) const {
|
||||
struct Functor {
|
||||
typedef std::string result_type;
|
||||
typedef int argument_type;
|
||||
|
||||
std::string operator()(int input) const {
|
||||
return IntToStringFunction(input);
|
||||
}
|
||||
};
|
||||
|
||||
@ -93,8 +93,11 @@ using testing::Sequence;
|
||||
using testing::SetArgPointee;
|
||||
using testing::internal::ExpectationTester;
|
||||
using testing::internal::FormatFileLocation;
|
||||
using testing::internal::kAllow;
|
||||
using testing::internal::kErrorVerbosity;
|
||||
using testing::internal::kFail;
|
||||
using testing::internal::kInfoVerbosity;
|
||||
using testing::internal::kWarn;
|
||||
using testing::internal::kWarningVerbosity;
|
||||
using testing::internal::linked_ptr;
|
||||
|
||||
@ -691,6 +694,61 @@ TEST(ExpectCallSyntaxTest, WarnsOnTooFewActions) {
|
||||
b.DoB();
|
||||
}
|
||||
|
||||
TEST(ExpectCallSyntaxTest, WarningIsErrorWithFlag) {
|
||||
int original_behavior = testing::GMOCK_FLAG(default_mock_behavior);
|
||||
|
||||
testing::GMOCK_FLAG(default_mock_behavior) = kAllow;
|
||||
CaptureStdout();
|
||||
{
|
||||
MockA a;
|
||||
a.DoA(0);
|
||||
}
|
||||
std::string output = GetCapturedStdout();
|
||||
EXPECT_TRUE(output.empty()) << output;
|
||||
|
||||
testing::GMOCK_FLAG(default_mock_behavior) = kWarn;
|
||||
CaptureStdout();
|
||||
{
|
||||
MockA a;
|
||||
a.DoA(0);
|
||||
}
|
||||
std::string warning_output = GetCapturedStdout();
|
||||
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
|
||||
EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
|
||||
warning_output);
|
||||
|
||||
testing::GMOCK_FLAG(default_mock_behavior) = kFail;
|
||||
EXPECT_NONFATAL_FAILURE({
|
||||
MockA a;
|
||||
a.DoA(0);
|
||||
}, "Uninteresting mock function call");
|
||||
|
||||
// Out of bounds values are converted to kWarn
|
||||
testing::GMOCK_FLAG(default_mock_behavior) = -1;
|
||||
CaptureStdout();
|
||||
{
|
||||
MockA a;
|
||||
a.DoA(0);
|
||||
}
|
||||
warning_output = GetCapturedStdout();
|
||||
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
|
||||
EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
|
||||
warning_output);
|
||||
testing::GMOCK_FLAG(default_mock_behavior) = 3;
|
||||
CaptureStdout();
|
||||
{
|
||||
MockA a;
|
||||
a.DoA(0);
|
||||
}
|
||||
warning_output = GetCapturedStdout();
|
||||
EXPECT_PRED_FORMAT2(IsSubstring, "GMOCK WARNING", warning_output);
|
||||
EXPECT_PRED_FORMAT2(IsSubstring, "Uninteresting mock function call",
|
||||
warning_output);
|
||||
|
||||
testing::GMOCK_FLAG(default_mock_behavior) = original_behavior;
|
||||
}
|
||||
|
||||
|
||||
#endif // GTEST_HAS_STREAM_REDIRECTION
|
||||
|
||||
// Tests the semantics of ON_CALL().
|
||||
@ -2624,7 +2682,7 @@ TEST(SynchronizationTest, CanCallMockMethodInAction) {
|
||||
|
||||
} // namespace
|
||||
|
||||
// Allows the user to define his own main and then invoke gmock_main
|
||||
// Allows the user to define their own main and then invoke gmock_main
|
||||
// from it. This might be necessary on some platforms which require
|
||||
// specific setup and teardown.
|
||||
#if GMOCK_RENAME_MAIN
|
||||
|
||||
@ -40,6 +40,7 @@
|
||||
|
||||
#if !defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
|
||||
|
||||
using testing::GMOCK_FLAG(default_mock_behavior);
|
||||
using testing::GMOCK_FLAG(verbose);
|
||||
using testing::InitGoogleMock;
|
||||
|
||||
@ -103,6 +104,26 @@ TEST(InitGoogleMockTest, ParsesSingleFlag) {
|
||||
TestInitGoogleMock(argv, new_argv, "info");
|
||||
}
|
||||
|
||||
TEST(InitGoogleMockTest, ParsesMultipleFlags) {
|
||||
int old_default_behavior = GMOCK_FLAG(default_mock_behavior);
|
||||
const wchar_t* argv[] = {
|
||||
L"foo.exe",
|
||||
L"--gmock_verbose=info",
|
||||
L"--gmock_default_mock_behavior=2",
|
||||
NULL
|
||||
};
|
||||
|
||||
const wchar_t* new_argv[] = {
|
||||
L"foo.exe",
|
||||
NULL
|
||||
};
|
||||
|
||||
TestInitGoogleMock(argv, new_argv, "info");
|
||||
EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior));
|
||||
EXPECT_NE(2, old_default_behavior);
|
||||
GMOCK_FLAG(default_mock_behavior) = old_default_behavior;
|
||||
}
|
||||
|
||||
TEST(InitGoogleMockTest, ParsesUnrecognizedFlag) {
|
||||
const char* argv[] = {
|
||||
"foo.exe",
|
||||
@ -177,6 +198,26 @@ TEST(WideInitGoogleMockTest, ParsesSingleFlag) {
|
||||
TestInitGoogleMock(argv, new_argv, "info");
|
||||
}
|
||||
|
||||
TEST(WideInitGoogleMockTest, ParsesMultipleFlags) {
|
||||
int old_default_behavior = GMOCK_FLAG(default_mock_behavior);
|
||||
const wchar_t* argv[] = {
|
||||
L"foo.exe",
|
||||
L"--gmock_verbose=info",
|
||||
L"--gmock_default_mock_behavior=2",
|
||||
NULL
|
||||
};
|
||||
|
||||
const wchar_t* new_argv[] = {
|
||||
L"foo.exe",
|
||||
NULL
|
||||
};
|
||||
|
||||
TestInitGoogleMock(argv, new_argv, "info");
|
||||
EXPECT_EQ(2, GMOCK_FLAG(default_mock_behavior));
|
||||
EXPECT_NE(2, old_default_behavior);
|
||||
GMOCK_FLAG(default_mock_behavior) = old_default_behavior;
|
||||
}
|
||||
|
||||
TEST(WideInitGoogleMockTest, ParsesUnrecognizedFlag) {
|
||||
const wchar_t* argv[] = {
|
||||
L"foo.exe",
|
||||
|
||||
2
googletest/.gitignore
vendored
2
googletest/.gitignore
vendored
@ -1,2 +0,0 @@
|
||||
# python
|
||||
*.pyc
|
||||
@ -27,6 +27,8 @@ option(
|
||||
"Build gtest with internal symbols hidden in shared libraries."
|
||||
OFF)
|
||||
|
||||
set(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "Generate debug library name with a postfix.")
|
||||
|
||||
# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build().
|
||||
include(cmake/hermetic_build.cmake OPTIONAL)
|
||||
|
||||
@ -75,9 +77,6 @@ include_directories(
|
||||
${gtest_SOURCE_DIR}/include
|
||||
${gtest_SOURCE_DIR})
|
||||
|
||||
# Where Google Test's libraries can be found.
|
||||
link_directories(${gtest_BINARY_DIR}/src)
|
||||
|
||||
# Summary of tuple support for Microsoft Visual Studio:
|
||||
# Compiler version(MS) version(cmake) Support
|
||||
# ---------- ----------- -------------- -----------------------------
|
||||
|
||||
@ -161,7 +161,8 @@ Existing build's `CMakeLists.txt`:
|
||||
# Add googletest directly to our build. This defines
|
||||
# the gtest and gtest_main targets.
|
||||
add_subdirectory(${CMAKE_BINARY_DIR}/googletest-src
|
||||
${CMAKE_BINARY_DIR}/googletest-build)
|
||||
${CMAKE_BINARY_DIR}/googletest-build
|
||||
EXCLUDE_FROM_ALL)
|
||||
|
||||
# The gtest/gtest_main targets carry header search path
|
||||
# dependencies automatically when using CMake 2.8.11 or
|
||||
@ -182,6 +183,17 @@ technique is discussed in more detail in
|
||||
which also contains a link to a fully generalized implementation
|
||||
of the technique.
|
||||
|
||||
##### Visual Studio Dynamic vs Static Runtimes #####
|
||||
|
||||
By default, new Visual Studio projects link the C runtimes dynamically
|
||||
but Google Test links them statically.
|
||||
This will generate an error that looks something like the following:
|
||||
gtest.lib(gtest-all.obj) : error LNK2038: mismatch detected for 'RuntimeLibrary': value 'MTd_StaticDebug' doesn't match value 'MDd_DynamicDebug' in main.obj
|
||||
|
||||
Google Test already has a CMake option for this: `gtest_force_shared_crt`
|
||||
|
||||
Enabling this option will make gtest link the runtimes dynamically too,
|
||||
and match the project in which it is included.
|
||||
|
||||
### Legacy Build Scripts ###
|
||||
|
||||
|
||||
@ -48,10 +48,14 @@ endmacro()
|
||||
macro(config_compiler_and_linker)
|
||||
# Note: pthreads on MinGW is not supported, even if available
|
||||
# instead, we use windows threading primitives
|
||||
unset(GTEST_HAS_PTHREAD)
|
||||
if (NOT gtest_disable_pthreads AND NOT MINGW)
|
||||
# Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT.
|
||||
set(THREADS_PREFER_PTHREAD_FLAG ON)
|
||||
find_package(Threads)
|
||||
if (CMAKE_USE_PTHREADS_INIT)
|
||||
set(GTEST_HAS_PTHREAD ON)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
fix_default_compiler_settings_()
|
||||
@ -83,10 +87,6 @@ macro(config_compiler_and_linker)
|
||||
# http://stackoverflow.com/questions/3232669 explains the issue.
|
||||
set(cxx_base_flags "${cxx_base_flags} -wd4702")
|
||||
endif()
|
||||
if (NOT (MSVC_VERSION GREATER 1900)) # 1900 is Visual Studio 2015
|
||||
# BigObj required for tests.
|
||||
set(cxx_base_flags "${cxx_base_flags} -bigobj")
|
||||
endif()
|
||||
|
||||
set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32")
|
||||
set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN")
|
||||
@ -94,7 +94,7 @@ macro(config_compiler_and_linker)
|
||||
set(cxx_no_exception_flags "-D_HAS_EXCEPTIONS=0")
|
||||
set(cxx_no_rtti_flags "-GR-")
|
||||
elseif (CMAKE_COMPILER_IS_GNUCXX)
|
||||
set(cxx_base_flags "-Wall -Wshadow")
|
||||
set(cxx_base_flags "-Wall -Wshadow -Werror")
|
||||
set(cxx_exception_flags "-fexceptions")
|
||||
set(cxx_no_exception_flags "-fno-exceptions")
|
||||
# Until version 4.3.2, GCC doesn't define a macro to indicate
|
||||
@ -126,7 +126,8 @@ macro(config_compiler_and_linker)
|
||||
set(cxx_no_rtti_flags "")
|
||||
endif()
|
||||
|
||||
if (CMAKE_USE_PTHREADS_INIT) # The pthreads library is available and allowed.
|
||||
# The pthreads library is available and allowed?
|
||||
if (DEFINED GTEST_HAS_PTHREAD)
|
||||
set(GTEST_HAS_PTHREAD_MACRO "-DGTEST_HAS_PTHREAD=1")
|
||||
else()
|
||||
set(GTEST_HAS_PTHREAD_MACRO "-DGTEST_HAS_PTHREAD=0")
|
||||
@ -159,7 +160,7 @@ function(cxx_library_with_type name type cxx_flags)
|
||||
PROPERTIES
|
||||
COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1")
|
||||
endif()
|
||||
if (CMAKE_USE_PTHREADS_INIT)
|
||||
if (DEFINED GTEST_HAS_PTHREAD)
|
||||
target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT})
|
||||
endif()
|
||||
endfunction()
|
||||
@ -182,6 +183,10 @@ endfunction()
|
||||
# is built from the given source files with the given compiler flags.
|
||||
function(cxx_executable_with_flags name cxx_flags libs)
|
||||
add_executable(${name} ${ARGN})
|
||||
if (MSVC AND (NOT (MSVC_VERSION LESS 1700))) # 1700 is Visual Studio 2012.
|
||||
# BigObj required for tests.
|
||||
set(cxx_flags "${cxx_flags} -bigobj")
|
||||
endif()
|
||||
if (cxx_flags)
|
||||
set_target_properties(${name}
|
||||
PROPERTIES
|
||||
@ -236,23 +241,33 @@ endfunction()
|
||||
# creates a Python test with the given name whose main module is in
|
||||
# test/name.py. It does nothing if Python is not installed.
|
||||
function(py_test name)
|
||||
# We are not supporting Python tests on Linux yet as they consider
|
||||
# all Linux environments to be google3 and try to use google3 features.
|
||||
if (PYTHONINTERP_FOUND)
|
||||
# ${CMAKE_BINARY_DIR} is known at configuration time, so we can
|
||||
# directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known
|
||||
# only at ctest runtime (by calling ctest -c <Configuration>), so
|
||||
# we have to escape $ to delay variable substitution here.
|
||||
if (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
|
||||
add_test(
|
||||
NAME ${name}
|
||||
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
|
||||
--build_dir=${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>)
|
||||
if (CMAKE_CONFIGURATION_TYPES)
|
||||
# Multi-configuration build generators as for Visual Studio save
|
||||
# output in a subdirectory of CMAKE_CURRENT_BINARY_DIR (Debug,
|
||||
# Release etc.), so we have to provide it here.
|
||||
add_test(
|
||||
NAME ${name}
|
||||
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
|
||||
--build_dir=${CMAKE_CURRENT_BINARY_DIR}/$<CONFIG>)
|
||||
else (CMAKE_CONFIGURATION_TYPES)
|
||||
# Single-configuration build generators like Makefile generators
|
||||
# don't have subdirs below CMAKE_CURRENT_BINARY_DIR.
|
||||
add_test(
|
||||
NAME ${name}
|
||||
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
|
||||
--build_dir=${CMAKE_CURRENT_BINARY_DIR})
|
||||
endif (CMAKE_CONFIGURATION_TYPES)
|
||||
else (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
|
||||
# ${CMAKE_CURRENT_BINARY_DIR} is known at configuration time, so we can
|
||||
# directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known
|
||||
# only at ctest runtime (by calling ctest -c <Configuration>), so
|
||||
# we have to escape $ to delay variable substitution here.
|
||||
add_test(
|
||||
${name}
|
||||
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py
|
||||
--build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE})
|
||||
endif (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 3.1)
|
||||
endif()
|
||||
endif(PYTHONINTERP_FOUND)
|
||||
endfunction()
|
||||
|
||||
@ -5,7 +5,7 @@ m4_include(m4/acx_pthread.m4)
|
||||
# "[1.0.1]"). It also asumes that there won't be any closing parenthesis
|
||||
# between "AC_INIT(" and the closing ")" including comments and strings.
|
||||
AC_INIT([Google C++ Testing Framework],
|
||||
[1.7.0],
|
||||
[1.8.0],
|
||||
[googletestframework@googlegroups.com],
|
||||
[gtest])
|
||||
|
||||
|
||||
@ -1263,7 +1263,7 @@ known as <i>abstract tests</i>. As an example of its application, when you
|
||||
are designing an interface you can write a standard suite of abstract
|
||||
tests (perhaps using a factory function as the test parameter) that
|
||||
all implementations of the interface are expected to pass. When
|
||||
someone implements the interface, he can instantiate your suite to get
|
||||
someone implements the interface, they can instantiate your suite to get
|
||||
all the interface-conformance tests for free.
|
||||
|
||||
To define abstract tests, you should organize your code like this:
|
||||
@ -1623,8 +1623,8 @@ printf("We are in test %s of test case %s.\n",
|
||||
```
|
||||
|
||||
`current_test_info()` returns a null pointer if no test is running. In
|
||||
particular, you cannot find the test case name in `TestCaseSetUp()`,
|
||||
`TestCaseTearDown()` (where you know the test case name implicitly), or
|
||||
particular, you cannot find the test case name in `SetUpTestCase()`,
|
||||
`TearDownTestCase()` (where you know the test case name implicitly), or
|
||||
functions called from them.
|
||||
|
||||
_Availability:_ Linux, Windows, Mac.
|
||||
|
||||
@ -101,6 +101,10 @@ Please do submit code. Here's what you need to do:
|
||||
1. Sign a Contributor License Agreement.
|
||||
1. Create a Pull Request in the usual way.
|
||||
|
||||
If you are a Googler, it is preferable to first create an internal change and
|
||||
have it reviewed and submitted, and then create an upstreaming pull
|
||||
request here.
|
||||
|
||||
## Google Test Committers ##
|
||||
|
||||
The current members of the Google Test engineering team are the only
|
||||
|
||||
@ -102,9 +102,9 @@ Then every user of your machine can write tests without
|
||||
recompiling Google Test.
|
||||
|
||||
This seemed like a good idea, but it has a
|
||||
got-cha: every user needs to compile his tests using the _same_ compiler
|
||||
got-cha: every user needs to compile their tests using the _same_ compiler
|
||||
flags used to compile the installed Google Test libraries; otherwise
|
||||
he may run into undefined behaviors (i.e. the tests can behave
|
||||
they may run into undefined behaviors (i.e. the tests can behave
|
||||
strangely and may even crash for no obvious reasons).
|
||||
|
||||
Why? Because C++ has this thing called the One-Definition Rule: if
|
||||
@ -494,7 +494,7 @@ EXPECT_PRED1(IsPositive, 5);
|
||||
However, this will work:
|
||||
|
||||
``` cpp
|
||||
EXPECT_PRED1(*static_cast<bool (*)(int)>*(IsPositive), 5);
|
||||
EXPECT_PRED1(static_cast<bool (*)(int)>(IsPositive), 5);
|
||||
```
|
||||
|
||||
(The stuff inside the angled brackets for the `static_cast` operator is the
|
||||
@ -512,14 +512,14 @@ bool IsNegative(T x) {
|
||||
you can use it in a predicate assertion like this:
|
||||
|
||||
``` cpp
|
||||
ASSERT_PRED1(IsNegative*<int>*, -5);
|
||||
ASSERT_PRED1(IsNegative<int>, -5);
|
||||
```
|
||||
|
||||
Things are more interesting if your template has more than one parameters. The
|
||||
following won't compile:
|
||||
|
||||
``` cpp
|
||||
ASSERT_PRED2(*GreaterThan<int, int>*, 5, 0);
|
||||
ASSERT_PRED2(GreaterThan<int, int>, 5, 0);
|
||||
```
|
||||
|
||||
|
||||
@ -528,7 +528,7 @@ which is one more than expected. The workaround is to wrap the predicate
|
||||
function in parentheses:
|
||||
|
||||
``` cpp
|
||||
ASSERT_PRED2(*(GreaterThan<int, int>)*, 5, 0);
|
||||
ASSERT_PRED2((GreaterThan<int, int>), 5, 0);
|
||||
```
|
||||
|
||||
|
||||
@ -1034,7 +1034,7 @@ namespace bar {
|
||||
TEST(CoolTest, DoSomething) {
|
||||
SUCCEED();
|
||||
}
|
||||
} // namespace foo
|
||||
} // namespace bar
|
||||
```
|
||||
|
||||
However, the following code is **not allowed** and will produce a runtime error from Google Test because the test methods are using different test fixture classes with the same test case name.
|
||||
@ -1052,7 +1052,7 @@ class CoolTest : public ::testing::Test {}; // Fixture: bar::CoolTest
|
||||
TEST_F(CoolTest, DoSomething) {
|
||||
SUCCEED();
|
||||
}
|
||||
} // namespace foo
|
||||
} // namespace bar
|
||||
```
|
||||
|
||||
## How do I build Google Testing Framework with Xcode 4? ##
|
||||
|
||||
@ -40,7 +40,7 @@ maintain.
|
||||
## Highlights ##
|
||||
|
||||
* The implementation is in a single Python script and thus ultra portable: no build or installation is needed and it works cross platforms.
|
||||
* Pump tries to be smart with respect to [Google's style guide](http://code.google.com/p/google-styleguide/): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
|
||||
* Pump tries to be smart with respect to [Google's style guide](https://github.com/google/styleguide): it breaks long lines (easy to have when they are generated) at acceptable places to fit within 80 columns and indent the continuation lines correctly.
|
||||
* The format is human-readable and more concise than XML.
|
||||
* The format works relatively well with Emacs' C++ mode.
|
||||
|
||||
|
||||
@ -137,7 +137,8 @@ class TypeWithoutFormatter {
|
||||
public:
|
||||
// This default version is called when kTypeKind is kOtherType.
|
||||
static void PrintValue(const T& value, ::std::ostream* os) {
|
||||
PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value),
|
||||
PrintBytesInObjectTo(static_cast<const unsigned char*>(
|
||||
reinterpret_cast<const void *>(&value)),
|
||||
sizeof(value), os);
|
||||
}
|
||||
};
|
||||
|
||||
@ -69,6 +69,8 @@
|
||||
# endif
|
||||
#elif defined __FreeBSD__
|
||||
# define GTEST_OS_FREEBSD 1
|
||||
#elif defined __Fuchsia__
|
||||
# define GTEST_OS_FUCHSIA 1
|
||||
#elif defined __linux__
|
||||
# define GTEST_OS_LINUX 1
|
||||
# if defined __ANDROID__
|
||||
|
||||
@ -122,6 +122,7 @@
|
||||
// GTEST_OS_AIX - IBM AIX
|
||||
// GTEST_OS_CYGWIN - Cygwin
|
||||
// GTEST_OS_FREEBSD - FreeBSD
|
||||
// GTEST_OS_FUCHSIA - Fuchsia
|
||||
// GTEST_OS_HPUX - HP-UX
|
||||
// GTEST_OS_LINUX - Linux
|
||||
// GTEST_OS_LINUX_ANDROID - Google Android
|
||||
@ -324,7 +325,7 @@
|
||||
// -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a
|
||||
// value for __cplusplus, and recent versions of clang, gcc, and
|
||||
// probably other compilers set that too in C++11 mode.
|
||||
# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L
|
||||
# if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L || _MSC_VER >= 1900
|
||||
// Compiling in at least C++11 mode.
|
||||
# define GTEST_LANG_CXX11 1
|
||||
# else
|
||||
@ -356,12 +357,16 @@
|
||||
#if GTEST_STDLIB_CXX11
|
||||
# define GTEST_HAS_STD_BEGIN_AND_END_ 1
|
||||
# define GTEST_HAS_STD_FORWARD_LIST_ 1
|
||||
# define GTEST_HAS_STD_FUNCTION_ 1
|
||||
# if !defined(_MSC_VER) || (_MSC_FULL_VER >= 190023824) // works only with VS2015U2 and better
|
||||
# define GTEST_HAS_STD_FUNCTION_ 1
|
||||
# endif
|
||||
# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
|
||||
# define GTEST_HAS_STD_MOVE_ 1
|
||||
# define GTEST_HAS_STD_SHARED_PTR_ 1
|
||||
# define GTEST_HAS_STD_TYPE_TRAITS_ 1
|
||||
# define GTEST_HAS_STD_UNIQUE_PTR_ 1
|
||||
# define GTEST_HAS_UNORDERED_MAP_ 1
|
||||
# define GTEST_HAS_UNORDERED_SET_ 1
|
||||
#endif
|
||||
|
||||
// C++11 specifies that <tuple> provides std::tuple.
|
||||
@ -607,8 +612,9 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
|
||||
//
|
||||
// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0
|
||||
// to your compiler flags.
|
||||
# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \
|
||||
|| GTEST_OS_QNX || GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD)
|
||||
#define GTEST_HAS_PTHREAD \
|
||||
(GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX || GTEST_OS_QNX || \
|
||||
GTEST_OS_FREEBSD || GTEST_OS_NACL || GTEST_OS_NETBSD || GTEST_OS_FUCHSIA)
|
||||
#endif // GTEST_HAS_PTHREAD
|
||||
|
||||
#if GTEST_HAS_PTHREAD
|
||||
@ -658,7 +664,8 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
|
||||
// support TR1 tuple. libc++ only provides std::tuple, in C++11 mode,
|
||||
// and it can be used with some compilers that define __GNUC__.
|
||||
# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \
|
||||
&& !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600
|
||||
&& !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) \
|
||||
|| (_MSC_VER >= 1600 && _MSC_VER < 1900)
|
||||
# define GTEST_ENV_HAS_TR1_TUPLE_ 1
|
||||
# endif
|
||||
|
||||
@ -739,7 +746,7 @@ using ::std::tuple_size;
|
||||
# define _TR1_FUNCTIONAL 1
|
||||
# include <tr1/tuple>
|
||||
# undef _TR1_FUNCTIONAL // Allows the user to #include
|
||||
// <tr1/functional> if he chooses to.
|
||||
// <tr1/functional> if they choose to.
|
||||
# else
|
||||
# include <tr1/tuple> // NOLINT
|
||||
# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302
|
||||
@ -2059,7 +2066,7 @@ extern "C" inline void DeleteThreadLocalValue(void* value_holder) {
|
||||
|
||||
// Implements thread-local storage on pthreads-based systems.
|
||||
template <typename T>
|
||||
class ThreadLocal {
|
||||
class GTEST_API_ ThreadLocal {
|
||||
public:
|
||||
ThreadLocal()
|
||||
: key_(CreateKey()), default_factory_(new DefaultValueHolderFactory()) {}
|
||||
@ -2191,7 +2198,7 @@ class GTestMutexLock {
|
||||
typedef GTestMutexLock MutexLock;
|
||||
|
||||
template <typename T>
|
||||
class ThreadLocal {
|
||||
class GTEST_API_ ThreadLocal {
|
||||
public:
|
||||
ThreadLocal() : value_() {}
|
||||
explicit ThreadLocal(const T& value) : value_(value) {}
|
||||
@ -2589,10 +2596,6 @@ std::string StringFromGTestEnv(const char* flag, const char* default_val);
|
||||
|
||||
} // namespace internal
|
||||
|
||||
// Returns a path to temporary directory.
|
||||
// Tries to determine an appropriate directory for the platform.
|
||||
GTEST_API_ std::string TempDir();
|
||||
|
||||
} // namespace testing
|
||||
|
||||
#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_
|
||||
|
||||
@ -38,7 +38,6 @@
|
||||
using ::testing::EmptyTestEventListener;
|
||||
using ::testing::InitGoogleTest;
|
||||
using ::testing::Test;
|
||||
using ::testing::TestCase;
|
||||
using ::testing::TestEventListeners;
|
||||
using ::testing::TestInfo;
|
||||
using ::testing::TestPartResult;
|
||||
|
||||
@ -52,7 +52,7 @@ EXAMPLES
|
||||
This tool is experimental. In particular, it assumes that there is no
|
||||
conditional inclusion of Google Test headers. Please report any
|
||||
problems to googletestframework@googlegroups.com. You can read
|
||||
http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide for
|
||||
https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuide.md for
|
||||
more information.
|
||||
"""
|
||||
|
||||
|
||||
@ -137,7 +137,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
@ -1313,13 +1313,14 @@ AssertionResult EqFailure(const char* lhs_expression,
|
||||
const std::string& rhs_value,
|
||||
bool ignoring_case) {
|
||||
Message msg;
|
||||
msg << " Expected: " << lhs_expression;
|
||||
msg << "Expected equality of these values:";
|
||||
msg << "\n " << lhs_expression;
|
||||
if (lhs_value != lhs_expression) {
|
||||
msg << "\n Which is: " << lhs_value;
|
||||
msg << "\n Which is: " << lhs_value;
|
||||
}
|
||||
msg << "\nTo be equal to: " << rhs_expression;
|
||||
msg << "\n " << rhs_expression;
|
||||
if (rhs_value != rhs_expression) {
|
||||
msg << "\n Which is: " << rhs_value;
|
||||
msg << "\n Which is: " << rhs_value;
|
||||
}
|
||||
|
||||
if (ignoring_case) {
|
||||
@ -2569,10 +2570,10 @@ void ReportInvalidTestCaseType(const char* test_case_name,
|
||||
<< "probably rename one of the classes to put the tests into different\n"
|
||||
<< "test cases.";
|
||||
|
||||
fprintf(stderr, "%s %s",
|
||||
FormatFileLocation(code_location.file.c_str(),
|
||||
code_location.line).c_str(),
|
||||
errors.GetString().c_str());
|
||||
GTEST_LOG_(ERROR)
|
||||
<< FormatFileLocation(code_location.file.c_str(),
|
||||
code_location.line)
|
||||
<< " " << errors.GetString();
|
||||
}
|
||||
#endif // GTEST_HAS_PARAM_TEST
|
||||
|
||||
@ -2883,7 +2884,7 @@ enum GTestColor {
|
||||
};
|
||||
|
||||
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
|
||||
!GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
|
||||
!GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
|
||||
|
||||
// Returns the character attribute for the given color.
|
||||
WORD GetColorAttribute(GTestColor color) {
|
||||
@ -2942,7 +2943,7 @@ bool ShouldUseColor(bool stdout_is_tty) {
|
||||
const char* const gtest_color = GTEST_FLAG(color).c_str();
|
||||
|
||||
if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
|
||||
#if GTEST_OS_WINDOWS
|
||||
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MINGW
|
||||
// On Windows the TERM variable is usually not set, but the
|
||||
// console there does support colors.
|
||||
return stdout_is_tty;
|
||||
@ -3000,7 +3001,7 @@ void ColoredPrintf(GTestColor color, const char* fmt, ...) {
|
||||
}
|
||||
|
||||
#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
|
||||
!GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
|
||||
!GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT && !GTEST_OS_WINDOWS_MINGW
|
||||
const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
|
||||
// Gets the current text color.
|
||||
@ -3449,9 +3450,7 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
|
||||
XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
|
||||
: output_file_(output_file) {
|
||||
if (output_file_.c_str() == NULL || output_file_.empty()) {
|
||||
fprintf(stderr, "XML output file may not be null\n");
|
||||
fflush(stderr);
|
||||
exit(EXIT_FAILURE);
|
||||
GTEST_LOG_(FATAL) << "XML output file may not be null";
|
||||
}
|
||||
}
|
||||
|
||||
@ -3476,11 +3475,8 @@ void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
|
||||
// 3. To interpret the meaning of errno in a thread-safe way,
|
||||
// we need the strerror_r() function, which is not available on
|
||||
// Windows.
|
||||
fprintf(stderr,
|
||||
"Unable to open file \"%s\"\n",
|
||||
output_file_.c_str());
|
||||
fflush(stderr);
|
||||
exit(EXIT_FAILURE);
|
||||
GTEST_LOG_(FATAL) << "Unable to open file \""
|
||||
<< output_file_ << "\"";
|
||||
}
|
||||
std::stringstream stream;
|
||||
PrintXmlUnitTest(&stream, unit_test);
|
||||
@ -4431,9 +4427,9 @@ void UnitTestImpl::ConfigureXmlOutput() {
|
||||
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
|
||||
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
|
||||
} else if (output_format != "") {
|
||||
printf("WARNING: unrecognized output format \"%s\" ignored.\n",
|
||||
output_format.c_str());
|
||||
fflush(stdout);
|
||||
GTEST_LOG_(WARNING) << "WARNING: unrecognized output format \""
|
||||
<< output_format
|
||||
<< "\" ignored.";
|
||||
}
|
||||
}
|
||||
|
||||
@ -4448,9 +4444,9 @@ void UnitTestImpl::ConfigureStreamingOutput() {
|
||||
listeners()->Append(new StreamingListener(target.substr(0, pos),
|
||||
target.substr(pos+1)));
|
||||
} else {
|
||||
printf("WARNING: unrecognized streaming target \"%s\" ignored.\n",
|
||||
target.c_str());
|
||||
fflush(stdout);
|
||||
GTEST_LOG_(WARNING) << "unrecognized streaming target \""
|
||||
<< target
|
||||
<< "\" ignored.";
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -4579,9 +4575,9 @@ static void TearDownEnvironment(Environment* env) { env->TearDown(); }
|
||||
bool UnitTestImpl::RunAllTests() {
|
||||
// Makes sure InitGoogleTest() was called.
|
||||
if (!GTestIsInitialized()) {
|
||||
printf("%s",
|
||||
"\nThis test program did NOT call ::testing::InitGoogleTest "
|
||||
"before calling RUN_ALL_TESTS(). Please fix it.\n");
|
||||
GTEST_LOG_(ERROR) <<
|
||||
"\nThis test program did NOT call ::testing::InitGoogleTest "
|
||||
"before calling RUN_ALL_TESTS(). Please fix it.";
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -4812,7 +4808,7 @@ bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) {
|
||||
// each TestCase and TestInfo object.
|
||||
// If shard_tests == true, further filters tests based on sharding
|
||||
// variables in the environment - see
|
||||
// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide.
|
||||
// https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuide.md .
|
||||
// Returns the number of tests that should run.
|
||||
int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) {
|
||||
const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ?
|
||||
@ -5281,11 +5277,9 @@ bool ParseGoogleTestFlag(const char* const arg) {
|
||||
void LoadFlagsFromFile(const std::string& path) {
|
||||
FILE* flagfile = posix::FOpen(path.c_str(), "r");
|
||||
if (!flagfile) {
|
||||
fprintf(stderr,
|
||||
"Unable to open file \"%s\"\n",
|
||||
GTEST_FLAG(flagfile).c_str());
|
||||
fflush(stderr);
|
||||
exit(EXIT_FAILURE);
|
||||
GTEST_LOG_(FATAL) << "Unable to open file \""
|
||||
<< GTEST_FLAG(flagfile)
|
||||
<< "\"";
|
||||
}
|
||||
std::string contents(ReadEntireFile(flagfile));
|
||||
posix::FClose(flagfile);
|
||||
|
||||
@ -61,7 +61,7 @@ using testing::internal::AlwaysTrue;
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
# define GTEST_IMPLEMENTATION_ 1
|
||||
# include "src/gtest-internal-inl.h"
|
||||
# undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -45,7 +45,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -50,7 +50,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -141,7 +141,7 @@ void VerifyGenerator(const ParamGenerator<T>& generator,
|
||||
<< ", expected_values[i] is " << PrintValue(expected_values[i])
|
||||
<< ", *it is " << PrintValue(*it)
|
||||
<< ", and 'it' is an iterator created with the copy constructor.\n";
|
||||
it++;
|
||||
++it;
|
||||
}
|
||||
EXPECT_TRUE(it == generator.end())
|
||||
<< "At the presumed end of sequence when accessing via an iterator "
|
||||
@ -161,7 +161,7 @@ void VerifyGenerator(const ParamGenerator<T>& generator,
|
||||
<< ", expected_values[i] is " << PrintValue(expected_values[i])
|
||||
<< ", *it is " << PrintValue(*it)
|
||||
<< ", and 'it' is an iterator created with the copy constructor.\n";
|
||||
it++;
|
||||
++it;
|
||||
}
|
||||
EXPECT_TRUE(it == generator.end())
|
||||
<< "At the presumed end of sequence when accessing via an iterator "
|
||||
@ -196,7 +196,7 @@ TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
|
||||
<< "element same as its source points to";
|
||||
|
||||
// Verifies that iterator assignment works as expected.
|
||||
it++;
|
||||
++it;
|
||||
EXPECT_FALSE(*it == *it2);
|
||||
it2 = it;
|
||||
EXPECT_TRUE(*it == *it2) << "Assigned iterators must point to the "
|
||||
@ -215,7 +215,7 @@ TEST(IteratorTest, ParamIteratorConformsToForwardIteratorConcept) {
|
||||
// Verifies that prefix and postfix operator++() advance an iterator
|
||||
// all the same.
|
||||
it2 = it;
|
||||
it++;
|
||||
++it;
|
||||
++it2;
|
||||
EXPECT_TRUE(*it == *it2);
|
||||
}
|
||||
@ -857,8 +857,8 @@ TEST_P(CustomLambdaNamingTest, CustomTestNames) {}
|
||||
INSTANTIATE_TEST_CASE_P(CustomParamNameLambda,
|
||||
CustomLambdaNamingTest,
|
||||
Values(std::string("LambdaName")),
|
||||
[](const ::testing::TestParamInfo<std::string>& info) {
|
||||
return info.param;
|
||||
[](const ::testing::TestParamInfo<std::string>& tpinfo) {
|
||||
return tpinfo.param;
|
||||
});
|
||||
|
||||
#endif // GTEST_LANG_CXX11
|
||||
|
||||
@ -50,7 +50,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -51,10 +51,15 @@
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
// hash_map and hash_set are available under Visual C++, or on Linux.
|
||||
#if GTEST_HAS_HASH_MAP_
|
||||
#if GTEST_HAS_UNORDERED_MAP_
|
||||
# include <unordered_map> // NOLINT
|
||||
#elif GTEST_HAS_HASH_MAP_
|
||||
# include <hash_map> // NOLINT
|
||||
#endif // GTEST_HAS_HASH_MAP_
|
||||
#if GTEST_HAS_HASH_SET_
|
||||
|
||||
#if GTEST_HAS_UNORDERED_SET_
|
||||
# include <unordered_set> // NOLINT
|
||||
#elif GTEST_HAS_HASH_SET_
|
||||
# include <hash_set> // NOLINT
|
||||
#endif // GTEST_HAS_HASH_SET_
|
||||
|
||||
@ -239,21 +244,47 @@ using ::testing::internal::UniversalTersePrintTupleFieldsToStrings;
|
||||
#endif
|
||||
using ::testing::internal::string;
|
||||
|
||||
#if GTEST_HAS_HASH_MAP_
|
||||
// The hash_* classes are not part of the C++ standard. STLport
|
||||
// defines them in namespace std. MSVC defines them in ::stdext. GCC
|
||||
// defines them in ::.
|
||||
#if GTEST_HAS_UNORDERED_MAP_
|
||||
|
||||
#define GTEST_HAS_HASH_MAP_ 1
|
||||
template<class Key, class T>
|
||||
using hash_map = ::std::unordered_map<Key, T>;
|
||||
template<class Key, class T>
|
||||
using hash_multimap = ::std::unordered_multimap<Key, T>;
|
||||
|
||||
#elif GTEST_HAS_HASH_MAP_
|
||||
|
||||
#ifdef _STLP_HASH_MAP // We got <hash_map> from STLport.
|
||||
using ::std::hash_map;
|
||||
using ::std::hash_set;
|
||||
using ::std::hash_multimap;
|
||||
using ::std::hash_multiset;
|
||||
#elif _MSC_VER
|
||||
using ::stdext::hash_map;
|
||||
using ::stdext::hash_set;
|
||||
using ::stdext::hash_multimap;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#if GTEST_HAS_UNORDERED_SET_
|
||||
|
||||
#define GTEST_HAS_HASH_SET_ 1
|
||||
template<class Key>
|
||||
using hash_set = ::std::unordered_set<Key>;
|
||||
template<class Key>
|
||||
using hash_multiset = ::std::unordered_multiset<Key>;
|
||||
|
||||
#elif GTEST_HAS_HASH_SET_
|
||||
|
||||
#ifdef _STLP_HASH_MAP // We got <hash_map> from STLport.
|
||||
using ::std::hash_set;
|
||||
using ::std::hash_multiset;
|
||||
#elif _MSC_VER
|
||||
using ::stdext::hash_set;
|
||||
using ::stdext::hash_multiset;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
// Prints a value to a string using the universal value printer. This
|
||||
@ -1061,8 +1092,8 @@ TEST(PrintTr1TupleTest, VariousSizes) {
|
||||
::std::tr1::tuple<bool, char, short, testing::internal::Int32, // NOLINT
|
||||
testing::internal::Int64, float, double, const char*, void*,
|
||||
std::string>
|
||||
t10(false, 'a', 3, 4, 5, 1.5F, -2.5, str, ImplicitCast_<void*>(NULL),
|
||||
"10");
|
||||
t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str,
|
||||
ImplicitCast_<void*>(NULL), "10");
|
||||
EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
|
||||
" pointing to \"8\", NULL, \"10\")",
|
||||
Print(t10));
|
||||
@ -1121,8 +1152,8 @@ TEST(PrintStdTupleTest, VariousSizes) {
|
||||
::std::tuple<bool, char, short, testing::internal::Int32, // NOLINT
|
||||
testing::internal::Int64, float, double, const char*, void*,
|
||||
std::string>
|
||||
t10(false, 'a', 3, 4, 5, 1.5F, -2.5, str, ImplicitCast_<void*>(NULL),
|
||||
"10");
|
||||
t10(false, 'a', static_cast<short>(3), 4, 5, 1.5F, -2.5, str,
|
||||
ImplicitCast_<void*>(NULL), "10");
|
||||
EXPECT_EQ("(false, 'a' (97, 0x61), 3, 4, 5, 1.5, -2.5, " + PrintPointer(str) +
|
||||
" pointing to \"8\", NULL, \"10\")",
|
||||
Print(t10));
|
||||
|
||||
@ -138,7 +138,7 @@ TEST_F(CxxExceptionInConstructorTest, ThrowsExceptionInConstructor) {
|
||||
}
|
||||
|
||||
// Exceptions in destructors are not supported in C++11.
|
||||
#if !defined(__GXX_EXPERIMENTAL_CXX0X__) && __cplusplus < 201103L && _MSC_VER < 1900
|
||||
#if !GTEST_LANG_CXX11
|
||||
class CxxExceptionInDestructorTest : public Test {
|
||||
public:
|
||||
static void TearDownTestCase() {
|
||||
|
||||
@ -41,7 +41,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -42,7 +42,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -5,8 +5,9 @@ Value of: false
|
||||
Actual: false
|
||||
Expected: true
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 2
|
||||
To be equal to: 3
|
||||
Expected equality of these values:
|
||||
2
|
||||
3
|
||||
[0;32m[==========] [mRunning 66 tests from 29 test cases.
|
||||
[0;32m[----------] [mGlobal test environment set-up.
|
||||
FooEnvironment::SetUp() called.
|
||||
@ -34,21 +35,24 @@ BarEnvironment::SetUp() called.
|
||||
[0;32m[----------] [m2 tests from NonfatalFailureTest
|
||||
[0;32m[ RUN ] [mNonfatalFailureTest.EscapesStringOperands
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: kGoldenString
|
||||
Which is: "\"Line"
|
||||
To be equal to: actual
|
||||
Which is: "actual \"string\""
|
||||
Expected equality of these values:
|
||||
kGoldenString
|
||||
Which is: "\"Line"
|
||||
actual
|
||||
Which is: "actual \"string\""
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: golden
|
||||
Which is: "\"Line"
|
||||
To be equal to: actual
|
||||
Which is: "actual \"string\""
|
||||
Expected equality of these values:
|
||||
golden
|
||||
Which is: "\"Line"
|
||||
actual
|
||||
Which is: "actual \"string\""
|
||||
[0;31m[ FAILED ] [mNonfatalFailureTest.EscapesStringOperands
|
||||
[0;32m[ RUN ] [mNonfatalFailureTest.DiffForLongStrings
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: golden_str
|
||||
Which is: "\"Line\0 1\"\nLine 2"
|
||||
To be equal to: "Line 2"
|
||||
Expected equality of these values:
|
||||
golden_str
|
||||
Which is: "\"Line\0 1\"\nLine 2"
|
||||
"Line 2"
|
||||
With diff:
|
||||
@@ -1,2 @@
|
||||
-\"Line\0 1\"
|
||||
@ -59,16 +63,18 @@ With diff:
|
||||
[0;32m[ RUN ] [mFatalFailureTest.FatalFailureInSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: x
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
x
|
||||
Which is: 2
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.FatalFailureInSubroutine
|
||||
[0;32m[ RUN ] [mFatalFailureTest.FatalFailureInNestedSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: x
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
x
|
||||
Which is: 2
|
||||
[0;31m[ FAILED ] [mFatalFailureTest.FatalFailureInNestedSubroutine
|
||||
[0;32m[ RUN ] [mFatalFailureTest.NonfatalFailureInSubroutine
|
||||
(expecting a failure on false)
|
||||
@ -107,39 +113,44 @@ This failure is expected, and shouldn't have a trace.
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.WorksInLoop
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 2
|
||||
To be equal to: n
|
||||
Which is: 1
|
||||
Expected equality of these values:
|
||||
2
|
||||
n
|
||||
Which is: 1
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: i = 1
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: n
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
n
|
||||
Which is: 2
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: i = 2
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksInLoop
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.WorksInSubroutine
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 2
|
||||
To be equal to: n
|
||||
Which is: 1
|
||||
Expected equality of these values:
|
||||
2
|
||||
n
|
||||
Which is: 1
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: n = 1
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: n
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
n
|
||||
Which is: 2
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: n = 2
|
||||
[0;31m[ FAILED ] [mSCOPED_TRACETest.WorksInSubroutine
|
||||
[0;32m[ RUN ] [mSCOPED_TRACETest.CanBeNested
|
||||
(expected to fail)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: n
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
n
|
||||
Which is: 2
|
||||
Google Test trace:
|
||||
gtest_output_test_.cc:#: n = 2
|
||||
gtest_output_test_.cc:#:
|
||||
@ -437,9 +448,10 @@ Expected: 1 fatal failure
|
||||
[0;32m[ OK ] [mTypedTest/0.Success
|
||||
[0;32m[ RUN ] [mTypedTest/0.Failure
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: TypeParam()
|
||||
Which is: 0
|
||||
Expected equality of these values:
|
||||
1
|
||||
TypeParam()
|
||||
Which is: 0
|
||||
Expected failure
|
||||
[0;31m[ FAILED ] [mTypedTest/0.Failure, where TypeParam = int
|
||||
[0;32m[----------] [m2 tests from Unsigned/TypedTestP/0, where TypeParam = unsigned char
|
||||
@ -447,10 +459,11 @@ Expected failure
|
||||
[0;32m[ OK ] [mUnsigned/TypedTestP/0.Success
|
||||
[0;32m[ RUN ] [mUnsigned/TypedTestP/0.Failure
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1U
|
||||
Which is: 1
|
||||
To be equal to: TypeParam()
|
||||
Which is: '\0'
|
||||
Expected equality of these values:
|
||||
1U
|
||||
Which is: 1
|
||||
TypeParam()
|
||||
Which is: '\0'
|
||||
Expected failure
|
||||
[0;31m[ FAILED ] [mUnsigned/TypedTestP/0.Failure, where TypeParam = unsigned char
|
||||
[0;32m[----------] [m2 tests from Unsigned/TypedTestP/1, where TypeParam = unsigned int
|
||||
@ -458,10 +471,11 @@ Expected failure
|
||||
[0;32m[ OK ] [mUnsigned/TypedTestP/1.Success
|
||||
[0;32m[ RUN ] [mUnsigned/TypedTestP/1.Failure
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1U
|
||||
Which is: 1
|
||||
To be equal to: TypeParam()
|
||||
Which is: 0
|
||||
Expected equality of these values:
|
||||
1U
|
||||
Which is: 1
|
||||
TypeParam()
|
||||
Which is: 0
|
||||
Expected failure
|
||||
[0;31m[ FAILED ] [mUnsigned/TypedTestP/1.Failure, where TypeParam = unsigned int
|
||||
[0;32m[----------] [m4 tests from ExpectFailureTest
|
||||
@ -597,18 +611,20 @@ Expected non-fatal failure.
|
||||
[0;32m[----------] [m1 test from PrintingFailingParams/FailingParamTest
|
||||
[0;32m[ RUN ] [mPrintingFailingParams/FailingParamTest.Fails/0
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: GetParam()
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
GetParam()
|
||||
Which is: 2
|
||||
[0;31m[ FAILED ] [mPrintingFailingParams/FailingParamTest.Fails/0, where GetParam() = 2
|
||||
[0;32m[----------] [m2 tests from PrintingStrings/ParamTest
|
||||
[0;32m[ RUN ] [mPrintingStrings/ParamTest.Success/a
|
||||
[0;32m[ OK ] [mPrintingStrings/ParamTest.Success/a
|
||||
[0;32m[ RUN ] [mPrintingStrings/ParamTest.Failure/a
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: "b"
|
||||
To be equal to: GetParam()
|
||||
Which is: "a"
|
||||
Expected equality of these values:
|
||||
"b"
|
||||
GetParam()
|
||||
Which is: "a"
|
||||
Expected failure
|
||||
[0;31m[ FAILED ] [mPrintingStrings/ParamTest.Failure/a, where GetParam() = "a"
|
||||
[0;32m[----------] [mGlobal test environment tear-down
|
||||
@ -678,16 +694,18 @@ Expected fatal failure.
|
||||
[ RUN ] FatalFailureTest.FatalFailureInSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: x
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
x
|
||||
Which is: 2
|
||||
[ FAILED ] FatalFailureTest.FatalFailureInSubroutine (? ms)
|
||||
[ RUN ] FatalFailureTest.FatalFailureInNestedSubroutine
|
||||
(expecting a failure that x should be 1)
|
||||
gtest_output_test_.cc:#: Failure
|
||||
Expected: 1
|
||||
To be equal to: x
|
||||
Which is: 2
|
||||
Expected equality of these values:
|
||||
1
|
||||
x
|
||||
Which is: 2
|
||||
[ FAILED ] FatalFailureTest.FatalFailureInNestedSubroutine (? ms)
|
||||
[ RUN ] FatalFailureTest.NonfatalFailureInSubroutine
|
||||
(expecting a failure on false)
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
|
||||
@ -71,7 +71,7 @@ TEST(CommandLineFlagsTest, CanBeAccessedInCodeOnceGTestHIsIncluded) {
|
||||
// implementation. It must come before gtest-internal-inl.h is
|
||||
// included, or there will be a compiler error. This trick is to
|
||||
// prevent a user from accidentally including gtest-internal-inl.h in
|
||||
// his code.
|
||||
// their code.
|
||||
#define GTEST_IMPLEMENTATION_ 1
|
||||
#include "src/gtest-internal-inl.h"
|
||||
#undef GTEST_IMPLEMENTATION_
|
||||
@ -2096,7 +2096,7 @@ class UnitTestRecordPropertyTestEnvironment : public Environment {
|
||||
};
|
||||
|
||||
// This will test property recording outside of any test or test case.
|
||||
static Environment* record_property_env =
|
||||
Environment* record_property_env GTEST_ATTRIBUTE_UNUSED_ =
|
||||
AddGlobalTestEnvironment(new UnitTestRecordPropertyTestEnvironment);
|
||||
|
||||
// This group of tests is for predicate assertions (ASSERT_PRED*, etc)
|
||||
@ -2429,8 +2429,9 @@ TEST(StringAssertionTest, ASSERT_STREQ) {
|
||||
const char p2[] = "good";
|
||||
ASSERT_STREQ(p1, p2);
|
||||
|
||||
EXPECT_FATAL_FAILURE(ASSERT_STREQ("bad", "good"),
|
||||
"Expected: \"bad\"");
|
||||
EXPECT_FATAL_FAILURE(
|
||||
ASSERT_STREQ("bad", "good"),
|
||||
"Expected equality of these values:\n \"bad\"\n \"good\"");
|
||||
}
|
||||
|
||||
// Tests ASSERT_STREQ with NULL arguments.
|
||||
@ -3115,13 +3116,13 @@ TEST(DISABLED_TestCase, DISABLED_TestShouldNotRun) {
|
||||
FAIL() << "Unexpected failure: Test in disabled test case should not be run.";
|
||||
}
|
||||
|
||||
// Check that when all tests in a test case are disabled, SetupTestCase() and
|
||||
// Check that when all tests in a test case are disabled, SetUpTestCase() and
|
||||
// TearDownTestCase() are not called.
|
||||
class DisabledTestsTest : public Test {
|
||||
protected:
|
||||
static void SetUpTestCase() {
|
||||
FAIL() << "Unexpected failure: All tests disabled in test case. "
|
||||
"SetupTestCase() should not be called.";
|
||||
"SetUpTestCase() should not be called.";
|
||||
}
|
||||
|
||||
static void TearDownTestCase() {
|
||||
@ -3528,35 +3529,39 @@ TEST(AssertionTest, EqFailure) {
|
||||
EqFailure("foo", "bar", foo_val, bar_val, false)
|
||||
.failure_message());
|
||||
EXPECT_STREQ(
|
||||
" Expected: foo\n"
|
||||
" Which is: 5\n"
|
||||
"To be equal to: bar\n"
|
||||
" Which is: 6",
|
||||
"Expected equality of these values:\n"
|
||||
" foo\n"
|
||||
" Which is: 5\n"
|
||||
" bar\n"
|
||||
" Which is: 6",
|
||||
msg1.c_str());
|
||||
|
||||
const std::string msg2(
|
||||
EqFailure("foo", "6", foo_val, bar_val, false)
|
||||
.failure_message());
|
||||
EXPECT_STREQ(
|
||||
" Expected: foo\n"
|
||||
" Which is: 5\n"
|
||||
"To be equal to: 6",
|
||||
"Expected equality of these values:\n"
|
||||
" foo\n"
|
||||
" Which is: 5\n"
|
||||
" 6",
|
||||
msg2.c_str());
|
||||
|
||||
const std::string msg3(
|
||||
EqFailure("5", "bar", foo_val, bar_val, false)
|
||||
.failure_message());
|
||||
EXPECT_STREQ(
|
||||
" Expected: 5\n"
|
||||
"To be equal to: bar\n"
|
||||
" Which is: 6",
|
||||
"Expected equality of these values:\n"
|
||||
" 5\n"
|
||||
" bar\n"
|
||||
" Which is: 6",
|
||||
msg3.c_str());
|
||||
|
||||
const std::string msg4(
|
||||
EqFailure("5", "6", foo_val, bar_val, false).failure_message());
|
||||
EXPECT_STREQ(
|
||||
" Expected: 5\n"
|
||||
"To be equal to: 6",
|
||||
"Expected equality of these values:\n"
|
||||
" 5\n"
|
||||
" 6",
|
||||
msg4.c_str());
|
||||
|
||||
const std::string msg5(
|
||||
@ -3564,10 +3569,11 @@ TEST(AssertionTest, EqFailure) {
|
||||
std::string("\"x\""), std::string("\"y\""),
|
||||
true).failure_message());
|
||||
EXPECT_STREQ(
|
||||
" Expected: foo\n"
|
||||
" Which is: \"x\"\n"
|
||||
"To be equal to: bar\n"
|
||||
" Which is: \"y\"\n"
|
||||
"Expected equality of these values:\n"
|
||||
" foo\n"
|
||||
" Which is: \"x\"\n"
|
||||
" bar\n"
|
||||
" Which is: \"y\"\n"
|
||||
"Ignoring case",
|
||||
msg5.c_str());
|
||||
}
|
||||
@ -3580,11 +3586,12 @@ TEST(AssertionTest, EqFailureWithDiff) {
|
||||
const std::string msg1(
|
||||
EqFailure("left", "right", left, right, false).failure_message());
|
||||
EXPECT_STREQ(
|
||||
" Expected: left\n"
|
||||
" Which is: "
|
||||
"Expected equality of these values:\n"
|
||||
" left\n"
|
||||
" Which is: "
|
||||
"1\\n2XXX\\n3\\n5\\n6\\n7\\n8\\n9\\n10\\n11\\n12XXX\\n13\\n14\\n15\n"
|
||||
"To be equal to: right\n"
|
||||
" Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
|
||||
" right\n"
|
||||
" Which is: 1\\n2\\n3\\n4\\n5\\n6\\n7\\n8\\n9\\n11\\n12\\n13\\n14\n"
|
||||
"With diff:\n@@ -1,5 +1,6 @@\n 1\n-2XXX\n+2\n 3\n+4\n 5\n 6\n"
|
||||
"@@ -7,8 +8,6 @@\n 8\n 9\n-10\n 11\n-12XXX\n+12\n 13\n 14\n-15\n",
|
||||
msg1.c_str());
|
||||
@ -3679,9 +3686,10 @@ TEST(ExpectTest, ASSERT_EQ_Double) {
|
||||
TEST(AssertionTest, ASSERT_EQ) {
|
||||
ASSERT_EQ(5, 2 + 3);
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(5, 2*3),
|
||||
" Expected: 5\n"
|
||||
"To be equal to: 2*3\n"
|
||||
" Which is: 6");
|
||||
"Expected equality of these values:\n"
|
||||
" 5\n"
|
||||
" 2*3\n"
|
||||
" Which is: 6");
|
||||
}
|
||||
|
||||
// Tests ASSERT_EQ(NULL, pointer).
|
||||
@ -3698,7 +3706,7 @@ TEST(AssertionTest, ASSERT_EQ_NULL) {
|
||||
// A failure.
|
||||
static int n = 0;
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(NULL, &n),
|
||||
"To be equal to: &n\n");
|
||||
" &n\n Which is:");
|
||||
}
|
||||
#endif // GTEST_CAN_COMPARE_NULL
|
||||
|
||||
@ -3714,7 +3722,7 @@ TEST(ExpectTest, ASSERT_EQ_0) {
|
||||
|
||||
// A failure.
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(0, 5.6),
|
||||
"Expected: 0");
|
||||
" 0\n 5.6");
|
||||
}
|
||||
|
||||
// Tests ASSERT_NE.
|
||||
@ -3813,7 +3821,7 @@ void TestEq1(int x) {
|
||||
// Tests calling a test subroutine that's not part of a fixture.
|
||||
TEST(AssertionTest, NonFixtureSubroutine) {
|
||||
EXPECT_FATAL_FAILURE(TestEq1(2),
|
||||
"To be equal to: x");
|
||||
"Which is: 2");
|
||||
}
|
||||
|
||||
// An uncopyable class.
|
||||
@ -3862,7 +3870,8 @@ TEST(AssertionTest, AssertWorksWithUncopyableObject) {
|
||||
EXPECT_FATAL_FAILURE(TestAssertNonPositive(),
|
||||
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
|
||||
EXPECT_FATAL_FAILURE(TestAssertEqualsUncopyable(),
|
||||
"Expected: x\n Which is: 5\nTo be equal to: y\n Which is: -1");
|
||||
"Expected equality of these values:\n"
|
||||
" x\n Which is: 5\n y\n Which is: -1");
|
||||
}
|
||||
|
||||
// Tests that uncopyable objects can be used in expects.
|
||||
@ -3874,7 +3883,8 @@ TEST(AssertionTest, ExpectWorksWithUncopyableObject) {
|
||||
"IsPositiveUncopyable(y) evaluates to false, where\ny evaluates to -1");
|
||||
EXPECT_EQ(x, x);
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(x, y),
|
||||
"Expected: x\n Which is: 5\nTo be equal to: y\n Which is: -1");
|
||||
"Expected equality of these values:\n"
|
||||
" x\n Which is: 5\n y\n Which is: -1");
|
||||
}
|
||||
|
||||
enum NamedEnum {
|
||||
@ -3950,7 +3960,7 @@ TEST(AssertionTest, AnonymousEnum) {
|
||||
|
||||
// ICE's in C++Builder.
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseB),
|
||||
"To be equal to: kCaseB");
|
||||
"kCaseB");
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(kCaseA, kCaseC),
|
||||
"Which is: 42");
|
||||
# endif
|
||||
@ -4390,9 +4400,10 @@ TEST(ExpectTest, ExpectFalseWithAssertionResult) {
|
||||
TEST(ExpectTest, EXPECT_EQ) {
|
||||
EXPECT_EQ(5, 2 + 3);
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2*3),
|
||||
" Expected: 5\n"
|
||||
"To be equal to: 2*3\n"
|
||||
" Which is: 6");
|
||||
"Expected equality of these values:\n"
|
||||
" 5\n"
|
||||
" 2*3\n"
|
||||
" Which is: 6");
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(5, 2 - 3),
|
||||
"2 - 3");
|
||||
}
|
||||
@ -4423,7 +4434,7 @@ TEST(ExpectTest, EXPECT_EQ_NULL) {
|
||||
// A failure.
|
||||
int n = 0;
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(NULL, &n),
|
||||
"To be equal to: &n\n");
|
||||
"&n\n");
|
||||
}
|
||||
#endif // GTEST_CAN_COMPARE_NULL
|
||||
|
||||
@ -4439,7 +4450,7 @@ TEST(ExpectTest, EXPECT_EQ_0) {
|
||||
|
||||
// A failure.
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(0, 5.6),
|
||||
"Expected: 0");
|
||||
"Expected equality of these values:\n 0\n 5.6");
|
||||
}
|
||||
|
||||
// Tests EXPECT_NE.
|
||||
@ -4539,7 +4550,7 @@ TEST(ExpectTest, EXPECT_ANY_THROW) {
|
||||
TEST(ExpectTest, ExpectPrecedence) {
|
||||
EXPECT_EQ(1 < 2, true);
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(true, true && false),
|
||||
"To be equal to: true && false");
|
||||
"true && false");
|
||||
}
|
||||
|
||||
|
||||
@ -4686,7 +4697,7 @@ TEST(EqAssertionTest, Bool) {
|
||||
EXPECT_FATAL_FAILURE({
|
||||
bool false_value = false;
|
||||
ASSERT_EQ(false_value, true);
|
||||
}, "To be equal to: true");
|
||||
}, "Which is: false");
|
||||
}
|
||||
|
||||
// Tests using int values in {EXPECT|ASSERT}_EQ.
|
||||
@ -4720,10 +4731,11 @@ TEST(EqAssertionTest, WideChar) {
|
||||
EXPECT_EQ(L'b', L'b');
|
||||
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(L'\0', L'x'),
|
||||
" Expected: L'\0'\n"
|
||||
" Which is: L'\0' (0, 0x0)\n"
|
||||
"To be equal to: L'x'\n"
|
||||
" Which is: L'x' (120, 0x78)");
|
||||
"Expected equality of these values:\n"
|
||||
" L'\0'\n"
|
||||
" Which is: L'\0' (0, 0x0)\n"
|
||||
" L'x'\n"
|
||||
" Which is: L'x' (120, 0x78)");
|
||||
|
||||
static wchar_t wchar;
|
||||
wchar = L'b';
|
||||
@ -4731,7 +4743,7 @@ TEST(EqAssertionTest, WideChar) {
|
||||
"wchar");
|
||||
wchar = 0x8119;
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(static_cast<wchar_t>(0x8120), wchar),
|
||||
"To be equal to: wchar");
|
||||
"wchar");
|
||||
}
|
||||
|
||||
// Tests using ::std::string values in {EXPECT|ASSERT}_EQ.
|
||||
@ -4760,8 +4772,8 @@ TEST(EqAssertionTest, StdString) {
|
||||
static ::std::string str3(str1);
|
||||
str3.at(2) = '\0';
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(str1, str3),
|
||||
"To be equal to: str3\n"
|
||||
" Which is: \"A \\0 in the middle\"");
|
||||
" str3\n"
|
||||
" Which is: \"A \\0 in the middle\"");
|
||||
}
|
||||
|
||||
#if GTEST_HAS_STD_WSTRING
|
||||
@ -4881,7 +4893,7 @@ TEST(EqAssertionTest, CharPointer) {
|
||||
ASSERT_EQ(p1, p1);
|
||||
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
|
||||
"To be equal to: p2");
|
||||
"p2");
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
|
||||
"p2");
|
||||
EXPECT_FATAL_FAILURE(ASSERT_EQ(reinterpret_cast<char*>(0x1234),
|
||||
@ -4903,7 +4915,7 @@ TEST(EqAssertionTest, WideCharPointer) {
|
||||
EXPECT_EQ(p0, p0);
|
||||
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p0, p2),
|
||||
"To be equal to: p2");
|
||||
"p2");
|
||||
EXPECT_NONFATAL_FAILURE(EXPECT_EQ(p1, p2),
|
||||
"p2");
|
||||
void* pv3 = (void*)0x1234; // NOLINT
|
||||
@ -7655,7 +7667,7 @@ TEST(NativeArrayTest, MethodsWork) {
|
||||
EXPECT_EQ(0, *it);
|
||||
++it;
|
||||
EXPECT_EQ(1, *it);
|
||||
it++;
|
||||
++it;
|
||||
EXPECT_EQ(2, *it);
|
||||
++it;
|
||||
EXPECT_EQ(na.end(), it);
|
||||
|
||||
@ -64,20 +64,23 @@ EXPECTED_NON_EMPTY_XML = """<?xml version="1.0" encoding="UTF-8"?>
|
||||
</testsuite>
|
||||
<testsuite name="FailedTest" tests="1" failures="1" disabled="0" errors="0" time="*">
|
||||
<testcase name="Fails" status="run" time="*" classname="FailedTest">
|
||||
<failure message="gtest_xml_output_unittest_.cc:*
 Expected: 1
To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Expected: 1
|
||||
To be equal to: 2%(stack)s]]></failure>
|
||||
<failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
 1
 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Expected equality of these values:
|
||||
1
|
||||
2%(stack)s]]></failure>
|
||||
</testcase>
|
||||
</testsuite>
|
||||
<testsuite name="MixedResultTest" tests="3" failures="1" disabled="1" errors="0" time="*">
|
||||
<testcase name="Succeeds" status="run" time="*" classname="MixedResultTest"/>
|
||||
<testcase name="Fails" status="run" time="*" classname="MixedResultTest">
|
||||
<failure message="gtest_xml_output_unittest_.cc:*
 Expected: 1
To be equal to: 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Expected: 1
|
||||
To be equal to: 2%(stack)s]]></failure>
|
||||
<failure message="gtest_xml_output_unittest_.cc:*
 Expected: 2
To be equal to: 3" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Expected: 2
|
||||
To be equal to: 3%(stack)s]]></failure>
|
||||
<failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
 1
 2" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Expected equality of these values:
|
||||
1
|
||||
2%(stack)s]]></failure>
|
||||
<failure message="gtest_xml_output_unittest_.cc:*
Expected equality of these values:
 2
 3" type=""><![CDATA[gtest_xml_output_unittest_.cc:*
|
||||
Expected equality of these values:
|
||||
2
|
||||
3%(stack)s]]></failure>
|
||||
</testcase>
|
||||
<testcase name="DISABLED_test" status="notrun" time="*" classname="MixedResultTest"/>
|
||||
</testsuite>
|
||||
|
||||
27
travis.sh
27
travis.sh
@ -1,15 +1,34 @@
|
||||
#!/usr/bin/env sh
|
||||
set -evx
|
||||
|
||||
# if possible, ask for the precise number of processors,
|
||||
# otherwise take 2 processors as reasonable default; see
|
||||
# https://docs.travis-ci.com/user/speeding-up-the-build/#Makefile-optimization
|
||||
if [ -x /usr/bin/getconf ]; then
|
||||
NPROCESSORS=$(/usr/bin/getconf _NPROCESSORS_ONLN)
|
||||
else
|
||||
NPROCESSORS=2
|
||||
fi
|
||||
# as of 2017-09-04 Travis CI reports 32 processors, but GCC build
|
||||
# crashes if parallelized too much (maybe memory consumption problem),
|
||||
# so limit to 4 processors for the time being.
|
||||
if [ $NPROCESSORS -gt 4 ] ; then
|
||||
echo "$0:Note: Limiting processors to use by make from $NPROCESSORS to 4."
|
||||
NPROCESSORS=4
|
||||
fi
|
||||
# Tell make to use the processors. No preceding '-' required.
|
||||
MAKEFLAGS="j${NPROCESSORS}"
|
||||
export MAKEFLAGS
|
||||
|
||||
env | sort
|
||||
|
||||
mkdir build || true
|
||||
mkdir build/$GTEST_TARGET || true
|
||||
cd build/$GTEST_TARGET
|
||||
cd build
|
||||
cmake -Dgtest_build_samples=ON \
|
||||
-Dgmock_build_samples=ON \
|
||||
-Dgtest_build_tests=ON \
|
||||
-Dgmock_build_tests=ON \
|
||||
-DCMAKE_CXX_FLAGS=$CXX_FLAGS \
|
||||
../../$GTEST_TARGET
|
||||
-DCMAKE_BUILD_TYPE=$BUILD_TYPE \
|
||||
..
|
||||
make
|
||||
CTEST_OUTPUT_ON_FAILURE=1 make test
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user