зеркало из https://github.com/mozilla/gecko-dev.git
Bug 1778991 - Update GTest to a newer upstream version. r=ahal
Differential Revision: https://phabricator.services.mozilla.com/D151500
This commit is contained in:
Ryan VanderMeulen
Родитель
ed1ef2fc65
Коммит
105faf89b5
|
|
@ -120,8 +120,14 @@ cc_library(
|
|||
linkopts = select({
|
||||
":qnx": ["-lregex"],
|
||||
":windows": [],
|
||||
":freebsd": ["-lm", "-pthread"],
|
||||
":openbsd": ["-lm", "-pthread"],
|
||||
":freebsd": [
|
||||
"-lm",
|
||||
"-pthread",
|
||||
],
|
||||
":openbsd": [
|
||||
"-lm",
|
||||
"-pthread",
|
||||
],
|
||||
"//conditions:default": ["-pthread"],
|
||||
}),
|
||||
deps = select({
|
||||
|
|
@ -129,10 +135,15 @@ cc_library(
|
|||
"@com_google_absl//absl/debugging:failure_signal_handler",
|
||||
"@com_google_absl//absl/debugging:stacktrace",
|
||||
"@com_google_absl//absl/debugging:symbolize",
|
||||
"@com_google_absl//absl/flags:flag",
|
||||
"@com_google_absl//absl/flags:parse",
|
||||
"@com_google_absl//absl/flags:reflection",
|
||||
"@com_google_absl//absl/flags:usage",
|
||||
"@com_google_absl//absl/strings",
|
||||
"@com_google_absl//absl/types:any",
|
||||
"@com_google_absl//absl/types:optional",
|
||||
"@com_google_absl//absl/types:variant",
|
||||
"@com_googlesource_code_re2//:re2",
|
||||
],
|
||||
"//conditions:default": [],
|
||||
}),
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ if (POLICY CMP0077)
|
|||
endif (POLICY CMP0077)
|
||||
|
||||
project(googletest-distribution)
|
||||
set(GOOGLETEST_VERSION 1.11.0)
|
||||
set(GOOGLETEST_VERSION 1.12.1)
|
||||
|
||||
if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX)
|
||||
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||
|
|
|
|||
|
|
@ -21,8 +21,8 @@ accept your pull requests.
|
|||
|
||||
## Are you a Googler?
|
||||
|
||||
If you are a Googler, please make an attempt to submit an internal change rather
|
||||
than a GitHub Pull Request. If you are not able to submit an internal change a
|
||||
If you are a Googler, please make an attempt to submit an internal contribution
|
||||
rather than a GitHub Pull Request. If you are not able to submit internally, a
|
||||
PR is acceptable as an alternative.
|
||||
|
||||
## Contributing A Patch
|
||||
|
|
|
|||
|
|
@ -6,7 +6,8 @@
|
|||
|
||||
GoogleTest now follows the
|
||||
[Abseil Live at Head philosophy](https://abseil.io/about/philosophy#upgrade-support).
|
||||
We recommend using the latest commit in the `main` branch in your projects.
|
||||
We recommend
|
||||
[updating to the latest commit in the `main` branch as often as possible](https://github.com/abseil/abseil-cpp/blob/master/FAQ.md#what-is-live-at-head-and-how-do-i-do-it).
|
||||
|
||||
#### Documentation Updates
|
||||
|
||||
|
|
@ -14,11 +15,14 @@ Our documentation is now live on GitHub Pages at
|
|||
https://google.github.io/googletest/. We recommend browsing the documentation on
|
||||
GitHub Pages rather than directly in the repository.
|
||||
|
||||
#### Release 1.11.0
|
||||
#### Release 1.12.1
|
||||
|
||||
[Release 1.11.0](https://github.com/google/googletest/releases/tag/release-1.11.0)
|
||||
[Release 1.12.1](https://github.com/google/googletest/releases/tag/release-1.12.1)
|
||||
is now available.
|
||||
|
||||
The 1.12.x branch will be the last to support C++11. Future releases will
|
||||
require at least C++14.
|
||||
|
||||
#### Coming Soon
|
||||
|
||||
* We are planning to take a dependency on
|
||||
|
|
@ -55,7 +59,7 @@ More information about building GoogleTest can be found at
|
|||
|
||||
## Supported Platforms
|
||||
|
||||
GoogleTest requires a codebase and compiler compliant with the C++11 standard or
|
||||
GoogleTest requires a codebase and compiler compliant with the C++14 standard or
|
||||
newer.
|
||||
|
||||
The GoogleTest code is officially supported on the following platforms.
|
||||
|
|
@ -121,11 +125,11 @@ result output. If your test runner understands TAP, you may find it useful.
|
|||
runs tests from your binary in parallel to provide significant speed-up.
|
||||
|
||||
[GoogleTest Adapter](https://marketplace.visualstudio.com/items?itemName=DavidSchuldenfrei.gtest-adapter)
|
||||
is a VS Code extension allowing to view GoogleTest in a tree view, and run/debug
|
||||
is a VS Code extension allowing to view GoogleTest in a tree view and run/debug
|
||||
your tests.
|
||||
|
||||
[C++ TestMate](https://github.com/matepek/vscode-catch2-test-adapter) is a VS
|
||||
Code extension allowing to view GoogleTest in a tree view, and run/debug your
|
||||
Code extension allowing to view GoogleTest in a tree view and run/debug your
|
||||
tests.
|
||||
|
||||
[Cornichon](https://pypi.org/project/cornichon/) is a small Gherkin DSL parser
|
||||
|
|
|
|||
|
|
@ -4,14 +4,36 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
|
|||
|
||||
http_archive(
|
||||
name = "com_google_absl",
|
||||
sha256 = "aeba534f7307e36fe084b452299e49b97420667a8d28102cf9a0daeed340b859",
|
||||
strip_prefix = "abseil-cpp-7971fb358ae376e016d2d4fc9327aad95659b25e",
|
||||
urls = ["https://github.com/abseil/abseil-cpp/archive/7971fb358ae376e016d2d4fc9327aad95659b25e.zip"], # 2021-05-20T02:59:16Z
|
||||
sha256 = "1a1745b5ee81392f5ea4371a4ca41e55d446eeaee122903b2eaffbd8a3b67a2b",
|
||||
strip_prefix = "abseil-cpp-01cc6567cff77738e416a7ddc17de2d435a780ce",
|
||||
urls = ["https://github.com/abseil/abseil-cpp/archive/01cc6567cff77738e416a7ddc17de2d435a780ce.zip"], # 2022-06-21T19:28:27Z
|
||||
)
|
||||
|
||||
# Note this must use a commit from the `abseil` branch of the RE2 project.
|
||||
# https://github.com/google/re2/tree/abseil
|
||||
http_archive(
|
||||
name = "com_googlesource_code_re2",
|
||||
sha256 = "0a890c2aa0bb05b2ce906a15efb520d0f5ad4c7d37b8db959c43772802991887",
|
||||
strip_prefix = "re2-a427f10b9fb4622dd6d8643032600aa1b50fbd12",
|
||||
urls = ["https://github.com/google/re2/archive/a427f10b9fb4622dd6d8643032600aa1b50fbd12.zip"], # 2022-06-09
|
||||
)
|
||||
|
||||
http_archive(
|
||||
name = "rules_python",
|
||||
sha256 = "98b3c592faea9636ac8444bfd9de7f3fb4c60590932d6e6ac5946e3f8dbd5ff6",
|
||||
strip_prefix = "rules_python-ed6cc8f2c3692a6a7f013ff8bc185ba77eb9b4d2",
|
||||
urls = ["https://github.com/bazelbuild/rules_python/archive/ed6cc8f2c3692a6a7f013ff8bc185ba77eb9b4d2.zip"], # 2021-05-17T00:24:16Z
|
||||
sha256 = "0b460f17771258341528753b1679335b629d1d25e3af28eda47d009c103a6e15",
|
||||
strip_prefix = "rules_python-aef17ad72919d184e5edb7abf61509eb78e57eda",
|
||||
urls = ["https://github.com/bazelbuild/rules_python/archive/aef17ad72919d184e5edb7abf61509eb78e57eda.zip"], # 2022-06-21T23:44:47Z
|
||||
)
|
||||
|
||||
http_archive(
|
||||
name = "bazel_skylib",
|
||||
urls = ["https://github.com/bazelbuild/bazel-skylib/releases/download/1.2.1/bazel-skylib-1.2.1.tar.gz"],
|
||||
sha256 = "f7be3474d42aae265405a592bb7da8e171919d74c16f082a5457840f06054728",
|
||||
)
|
||||
|
||||
http_archive(
|
||||
name = "platforms",
|
||||
sha256 = "a879ea428c6d56ab0ec18224f976515948822451473a80d06c2e50af0bbe5121",
|
||||
strip_prefix = "platforms-da5541f26b7de1dc8e04c075c99df5351742a4a2",
|
||||
urls = ["https://github.com/bazelbuild/platforms/archive/da5541f26b7de1dc8e04c075c99df5351742a4a2.zip"], # 2022-05-27
|
||||
)
|
||||
|
|
|
|||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -313,7 +313,9 @@ class StringMatchResultListener : public MatchResultListener {
|
|||
private:
|
||||
::std::stringstream ss_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(StringMatchResultListener);
|
||||
StringMatchResultListener(const StringMatchResultListener&) = delete;
|
||||
StringMatchResultListener& operator=(const StringMatchResultListener&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
// Anything inside the 'internal' namespace IS INTERNAL IMPLEMENTATION
|
||||
|
|
@ -533,19 +535,18 @@ inline Matcher<T> SafeMatcherCast(const Matcher<U>& matcher) {
|
|||
"T must be implicitly convertible to U");
|
||||
// Enforce that we are not converting a non-reference type T to a reference
|
||||
// type U.
|
||||
GTEST_COMPILE_ASSERT_(
|
||||
std::is_reference<T>::value || !std::is_reference<U>::value,
|
||||
cannot_convert_non_reference_arg_to_reference);
|
||||
static_assert(std::is_reference<T>::value || !std::is_reference<U>::value,
|
||||
"cannot convert non reference arg to reference");
|
||||
// In case both T and U are arithmetic types, enforce that the
|
||||
// conversion is not lossy.
|
||||
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(T) RawT;
|
||||
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(U) RawU;
|
||||
constexpr bool kTIsOther = GMOCK_KIND_OF_(RawT) == internal::kOther;
|
||||
constexpr bool kUIsOther = GMOCK_KIND_OF_(RawU) == internal::kOther;
|
||||
GTEST_COMPILE_ASSERT_(
|
||||
static_assert(
|
||||
kTIsOther || kUIsOther ||
|
||||
(internal::LosslessArithmeticConvertible<RawT, RawU>::value),
|
||||
conversion_of_arithmetic_types_must_be_lossless);
|
||||
"conversion of arithmetic types must be lossless");
|
||||
return MatcherCast<T>(matcher);
|
||||
}
|
||||
|
||||
|
|
@ -678,9 +679,9 @@ bool TupleMatches(const MatcherTuple& matcher_tuple,
|
|||
const ValueTuple& value_tuple) {
|
||||
// Makes sure that matcher_tuple and value_tuple have the same
|
||||
// number of fields.
|
||||
GTEST_COMPILE_ASSERT_(std::tuple_size<MatcherTuple>::value ==
|
||||
std::tuple_size<ValueTuple>::value,
|
||||
matcher_and_value_have_different_numbers_of_fields);
|
||||
static_assert(std::tuple_size<MatcherTuple>::value ==
|
||||
std::tuple_size<ValueTuple>::value,
|
||||
"matcher and value have different numbers of fields");
|
||||
return TuplePrefix<std::tuple_size<ValueTuple>::value>::Matches(matcher_tuple,
|
||||
value_tuple);
|
||||
}
|
||||
|
|
@ -2258,7 +2259,11 @@ class ResultOfMatcher {
|
|||
}
|
||||
|
||||
bool MatchAndExplain(T obj, MatchResultListener* listener) const override {
|
||||
*listener << "which is mapped by the given callable to ";
|
||||
if (result_description_.empty()) {
|
||||
*listener << "which is mapped by the given callable to ";
|
||||
} else {
|
||||
*listener << "whose " << result_description_ << " is ";
|
||||
}
|
||||
// Cannot pass the return value directly to MatchPrintAndExplain, which
|
||||
// takes a non-const reference as argument.
|
||||
// Also, specifying template argument explicitly is needed because T could
|
||||
|
|
@ -2552,7 +2557,8 @@ class WhenSortedByMatcher {
|
|||
const Comparator comparator_;
|
||||
const Matcher<const ::std::vector<LhsValue>&> matcher_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(Impl);
|
||||
Impl(const Impl&) = delete;
|
||||
Impl& operator=(const Impl&) = delete;
|
||||
};
|
||||
|
||||
private:
|
||||
|
|
@ -2566,9 +2572,9 @@ class WhenSortedByMatcher {
|
|||
// container and the RHS container respectively.
|
||||
template <typename TupleMatcher, typename RhsContainer>
|
||||
class PointwiseMatcher {
|
||||
GTEST_COMPILE_ASSERT_(
|
||||
static_assert(
|
||||
!IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(RhsContainer)>::value,
|
||||
use_UnorderedPointwise_with_hash_tables);
|
||||
"use UnorderedPointwise with hash tables");
|
||||
|
||||
public:
|
||||
typedef internal::StlContainerView<RhsContainer> RhsView;
|
||||
|
|
@ -2587,9 +2593,9 @@ class PointwiseMatcher {
|
|||
|
||||
template <typename LhsContainer>
|
||||
operator Matcher<LhsContainer>() const {
|
||||
GTEST_COMPILE_ASSERT_(
|
||||
static_assert(
|
||||
!IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(LhsContainer)>::value,
|
||||
use_UnorderedPointwise_with_hash_tables);
|
||||
"use UnorderedPointwise with hash tables");
|
||||
|
||||
return Matcher<LhsContainer>(
|
||||
new Impl<const LhsContainer&>(tuple_matcher_, rhs_));
|
||||
|
|
@ -3229,6 +3235,11 @@ auto UnpackStructImpl(const T& t, MakeIndexSequence<16>, char) {
|
|||
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p] = t;
|
||||
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
|
||||
}
|
||||
template <typename T>
|
||||
auto UnpackStructImpl(const T& t, MakeIndexSequence<17>, char) {
|
||||
const auto& [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = t;
|
||||
return std::tie(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q);
|
||||
}
|
||||
#endif // defined(__cpp_structured_bindings)
|
||||
|
||||
template <size_t I, typename T>
|
||||
|
|
@ -3721,10 +3732,10 @@ class ElementsAreMatcher {
|
|||
|
||||
template <typename Container>
|
||||
operator Matcher<Container>() const {
|
||||
GTEST_COMPILE_ASSERT_(
|
||||
static_assert(
|
||||
!IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value ||
|
||||
::std::tuple_size<MatcherTuple>::value < 2,
|
||||
use_UnorderedElementsAre_with_hash_tables);
|
||||
"use UnorderedElementsAre with hash tables");
|
||||
|
||||
typedef GTEST_REMOVE_REFERENCE_AND_CONST_(Container) RawContainer;
|
||||
typedef typename internal::StlContainerView<RawContainer>::type View;
|
||||
|
|
@ -3772,9 +3783,9 @@ class ElementsAreArrayMatcher {
|
|||
|
||||
template <typename Container>
|
||||
operator Matcher<Container>() const {
|
||||
GTEST_COMPILE_ASSERT_(
|
||||
static_assert(
|
||||
!IsHashTable<GTEST_REMOVE_REFERENCE_AND_CONST_(Container)>::value,
|
||||
use_UnorderedElementsAreArray_with_hash_tables);
|
||||
"use UnorderedElementsAreArray with hash tables");
|
||||
|
||||
return Matcher<Container>(new ElementsAreMatcherImpl<const Container&>(
|
||||
matchers_.begin(), matchers_.end()));
|
||||
|
|
@ -5062,7 +5073,8 @@ inline bool ExplainMatchResult(M matcher, const T& value,
|
|||
//
|
||||
// MATCHER_P(XAndYThat, matcher,
|
||||
// "X that " + DescribeMatcher<int>(matcher, negation) +
|
||||
// " and Y that " + DescribeMatcher<double>(matcher, negation)) {
|
||||
// (negation ? " or" : " and") + " Y that " +
|
||||
// DescribeMatcher<double>(matcher, negation)) {
|
||||
// return ExplainMatchResult(matcher, arg.x(), result_listener) &&
|
||||
// ExplainMatchResult(matcher, arg.y(), result_listener);
|
||||
// }
|
||||
|
|
|
|||
|
|
@ -600,7 +600,8 @@ auto InvokeArgument(F f, Args... args) -> decltype(f(args...)) {
|
|||
|
||||
template <std::size_t index, typename... Params>
|
||||
struct InvokeArgumentAction {
|
||||
template <typename... Args>
|
||||
template <typename... Args,
|
||||
typename = typename std::enable_if<(index < sizeof...(Args))>::type>
|
||||
auto operator()(Args&&... args) const -> decltype(internal::InvokeArgument(
|
||||
std::get<index>(std::forward_as_tuple(std::forward<Args>(args)...)),
|
||||
std::declval<const Params&>()...)) {
|
||||
|
|
|
|||
|
|
@ -63,6 +63,7 @@
|
|||
#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
|
||||
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_NICE_STRICT_H_
|
||||
|
||||
#include <cstdint>
|
||||
#include <type_traits>
|
||||
|
||||
#include "gmock/gmock-spec-builders.h"
|
||||
|
|
@ -109,25 +110,37 @@ constexpr bool HasStrictnessModifier() {
|
|||
template <typename Base>
|
||||
class NiceMockImpl {
|
||||
public:
|
||||
NiceMockImpl() { ::testing::Mock::AllowUninterestingCalls(this); }
|
||||
NiceMockImpl() {
|
||||
::testing::Mock::AllowUninterestingCalls(reinterpret_cast<uintptr_t>(this));
|
||||
}
|
||||
|
||||
~NiceMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
|
||||
~NiceMockImpl() {
|
||||
::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Base>
|
||||
class NaggyMockImpl {
|
||||
public:
|
||||
NaggyMockImpl() { ::testing::Mock::WarnUninterestingCalls(this); }
|
||||
NaggyMockImpl() {
|
||||
::testing::Mock::WarnUninterestingCalls(reinterpret_cast<uintptr_t>(this));
|
||||
}
|
||||
|
||||
~NaggyMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
|
||||
~NaggyMockImpl() {
|
||||
::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Base>
|
||||
class StrictMockImpl {
|
||||
public:
|
||||
StrictMockImpl() { ::testing::Mock::FailUninterestingCalls(this); }
|
||||
StrictMockImpl() {
|
||||
::testing::Mock::FailUninterestingCalls(reinterpret_cast<uintptr_t>(this));
|
||||
}
|
||||
|
||||
~StrictMockImpl() { ::testing::Mock::UnregisterCallReaction(this); }
|
||||
~StrictMockImpl() {
|
||||
::testing::Mock::UnregisterCallReaction(reinterpret_cast<uintptr_t>(this));
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
|
@ -169,7 +182,8 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS NiceMock
|
|||
}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
|
||||
NiceMock(const NiceMock&) = delete;
|
||||
NiceMock& operator=(const NiceMock&) = delete;
|
||||
};
|
||||
|
||||
template <class MockClass>
|
||||
|
|
@ -210,7 +224,8 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS NaggyMock
|
|||
}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(NaggyMock);
|
||||
NaggyMock(const NaggyMock&) = delete;
|
||||
NaggyMock& operator=(const NaggyMock&) = delete;
|
||||
};
|
||||
|
||||
template <class MockClass>
|
||||
|
|
@ -251,7 +266,8 @@ class GTEST_INTERNAL_EMPTY_BASE_CLASS StrictMock
|
|||
}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
|
||||
StrictMock(const StrictMock&) = delete;
|
||||
StrictMock& operator=(const StrictMock&) = delete;
|
||||
};
|
||||
|
||||
#undef GTEST_INTERNAL_EMPTY_BASE_CLASS
|
||||
|
|
|
|||
|
|
@ -61,6 +61,7 @@
|
|||
#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
|
||||
#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_SPEC_BUILDERS_H_
|
||||
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
|
|
@ -132,9 +133,6 @@ class NaggyMockImpl;
|
|||
// calls to ensure the integrity of the mock objects' states.
|
||||
GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_gmock_mutex);
|
||||
|
||||
// Untyped base class for ActionResultHolder<R>.
|
||||
class UntypedActionResultHolderBase;
|
||||
|
||||
// Abstract base class of FunctionMocker. This is the
|
||||
// type-agnostic part of the function mocker interface. Its pure
|
||||
// virtual methods are implemented by FunctionMocker.
|
||||
|
|
@ -157,20 +155,6 @@ class GTEST_API_ UntypedFunctionMockerBase {
|
|||
// responsibility to guarantee the correctness of the arguments'
|
||||
// types.
|
||||
|
||||
// Performs the default action with the given arguments and returns
|
||||
// the action's result. The call description string will be used in
|
||||
// the error message to describe the call in the case the default
|
||||
// action fails.
|
||||
// L = *
|
||||
virtual UntypedActionResultHolderBase* UntypedPerformDefaultAction(
|
||||
void* untyped_args, const std::string& call_description) const = 0;
|
||||
|
||||
// Performs the given action with the given arguments and returns
|
||||
// the action's result.
|
||||
// L = *
|
||||
virtual UntypedActionResultHolderBase* UntypedPerformAction(
|
||||
const void* untyped_action, void* untyped_args) const = 0;
|
||||
|
||||
// Writes a message that the call is uninteresting (i.e. neither
|
||||
// explicitly expected nor explicitly unexpected) to the given
|
||||
// ostream.
|
||||
|
|
@ -214,13 +198,6 @@ class GTEST_API_ UntypedFunctionMockerBase {
|
|||
// SetOwnerAndName() has been called.
|
||||
const char* Name() const GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
|
||||
|
||||
// Returns the result of invoking this mock function with the given
|
||||
// arguments. This function can be safely called from multiple
|
||||
// threads concurrently. The caller is responsible for deleting the
|
||||
// result.
|
||||
UntypedActionResultHolderBase* UntypedInvokeWith(void* untyped_args)
|
||||
GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
|
||||
|
||||
protected:
|
||||
typedef std::vector<const void*> UntypedOnCallSpecs;
|
||||
|
||||
|
|
@ -428,22 +405,22 @@ class GTEST_API_ Mock {
|
|||
|
||||
// Tells Google Mock to allow uninteresting calls on the given mock
|
||||
// object.
|
||||
static void AllowUninterestingCalls(const void* mock_obj)
|
||||
static void AllowUninterestingCalls(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
|
||||
|
||||
// Tells Google Mock to warn the user about uninteresting calls on
|
||||
// the given mock object.
|
||||
static void WarnUninterestingCalls(const void* mock_obj)
|
||||
static void WarnUninterestingCalls(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
|
||||
|
||||
// Tells Google Mock to fail uninteresting calls on the given mock
|
||||
// object.
|
||||
static void FailUninterestingCalls(const void* mock_obj)
|
||||
static void FailUninterestingCalls(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
|
||||
|
||||
// Tells Google Mock the given mock object is being destroyed and
|
||||
// its entry in the call-reaction table should be removed.
|
||||
static void UnregisterCallReaction(const void* mock_obj)
|
||||
static void UnregisterCallReaction(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex);
|
||||
|
||||
// Returns the reaction Google Mock will have on uninteresting calls
|
||||
|
|
@ -677,7 +654,8 @@ class GTEST_API_ InSequence {
|
|||
private:
|
||||
bool sequence_created_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(InSequence); // NOLINT
|
||||
InSequence(const InSequence&) = delete;
|
||||
InSequence& operator=(const InSequence&) = delete;
|
||||
} GTEST_ATTRIBUTE_UNUSED_;
|
||||
|
||||
namespace internal {
|
||||
|
|
@ -877,9 +855,15 @@ class GTEST_API_ ExpectationBase {
|
|||
mutable Mutex mutex_; // Protects action_count_checked_.
|
||||
}; // class ExpectationBase
|
||||
|
||||
// Implements an expectation for the given function type.
|
||||
template <typename F>
|
||||
class TypedExpectation : public ExpectationBase {
|
||||
class TypedExpectation;
|
||||
|
||||
// Implements an expectation for the given function type.
|
||||
template <typename R, typename... Args>
|
||||
class TypedExpectation<R(Args...)> : public ExpectationBase {
|
||||
private:
|
||||
using F = R(Args...);
|
||||
|
||||
public:
|
||||
typedef typename Function<F>::ArgumentTuple ArgumentTuple;
|
||||
typedef typename Function<F>::ArgumentMatcherTuple ArgumentMatcherTuple;
|
||||
|
|
@ -992,14 +976,31 @@ class TypedExpectation : public ExpectationBase {
|
|||
return After(s1, s2, s3, s4).After(s5);
|
||||
}
|
||||
|
||||
// Implements the .WillOnce() clause.
|
||||
TypedExpectation& WillOnce(const Action<F>& action) {
|
||||
// Preferred, type-safe overload: consume anything that can be directly
|
||||
// converted to a OnceAction, except for Action<F> objects themselves.
|
||||
TypedExpectation& WillOnce(OnceAction<F> once_action) {
|
||||
// Call the overload below, smuggling the OnceAction as a copyable callable.
|
||||
// We know this is safe because a WillOnce action will not be called more
|
||||
// than once.
|
||||
return WillOnce(Action<F>(ActionAdaptor{
|
||||
std::make_shared<OnceAction<F>>(std::move(once_action)),
|
||||
}));
|
||||
}
|
||||
|
||||
// Fallback overload: accept Action<F> objects and those actions that define
|
||||
// `operator Action<F>` but not `operator OnceAction<F>`.
|
||||
//
|
||||
// This is templated in order to cause the overload above to be preferred
|
||||
// when the input is convertible to either type.
|
||||
template <int&... ExplicitArgumentBarrier, typename = void>
|
||||
TypedExpectation& WillOnce(Action<F> action) {
|
||||
ExpectSpecProperty(last_clause_ <= kWillOnce,
|
||||
".WillOnce() cannot appear after "
|
||||
".WillRepeatedly() or .RetiresOnSaturation().");
|
||||
last_clause_ = kWillOnce;
|
||||
|
||||
untyped_actions_.push_back(new Action<F>(action));
|
||||
untyped_actions_.push_back(new Action<F>(std::move(action)));
|
||||
|
||||
if (!cardinality_specified()) {
|
||||
set_cardinality(Exactly(static_cast<int>(untyped_actions_.size())));
|
||||
}
|
||||
|
|
@ -1071,6 +1072,16 @@ class TypedExpectation : public ExpectationBase {
|
|||
template <typename Function>
|
||||
friend class FunctionMocker;
|
||||
|
||||
// An adaptor that turns a OneAction<F> into something compatible with
|
||||
// Action<F>. Must be called at most once.
|
||||
struct ActionAdaptor {
|
||||
std::shared_ptr<OnceAction<R(Args...)>> once_action;
|
||||
|
||||
R operator()(Args&&... args) const {
|
||||
return std::move(*once_action).Call(std::forward<Args>(args)...);
|
||||
}
|
||||
};
|
||||
|
||||
// Returns an Expectation object that references and co-owns this
|
||||
// expectation.
|
||||
Expectation GetHandle() override { return owner_->GetHandleOf(this); }
|
||||
|
|
@ -1217,7 +1228,8 @@ class TypedExpectation : public ExpectationBase {
|
|||
Matcher<const ArgumentTuple&> extra_matcher_;
|
||||
Action<F> repeated_action_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
|
||||
TypedExpectation(const TypedExpectation&) = delete;
|
||||
TypedExpectation& operator=(const TypedExpectation&) = delete;
|
||||
}; // class TypedExpectation
|
||||
|
||||
// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
|
||||
|
|
@ -1333,97 +1345,27 @@ class ReferenceOrValueWrapper<T&> {
|
|||
T* value_ptr_;
|
||||
};
|
||||
|
||||
// C++ treats the void type specially. For example, you cannot define
|
||||
// a void-typed variable or pass a void value to a function.
|
||||
// ActionResultHolder<T> holds a value of type T, where T must be a
|
||||
// copyable type or void (T doesn't need to be default-constructable).
|
||||
// It hides the syntactic difference between void and other types, and
|
||||
// is used to unify the code for invoking both void-returning and
|
||||
// non-void-returning mock functions.
|
||||
|
||||
// Untyped base class for ActionResultHolder<T>.
|
||||
class UntypedActionResultHolderBase {
|
||||
public:
|
||||
virtual ~UntypedActionResultHolderBase() {}
|
||||
|
||||
// Prints the held value as an action's result to os.
|
||||
virtual void PrintAsActionResult(::std::ostream* os) const = 0;
|
||||
};
|
||||
|
||||
// This generic definition is used when T is not void.
|
||||
// Prints the held value as an action's result to os.
|
||||
template <typename T>
|
||||
class ActionResultHolder : public UntypedActionResultHolderBase {
|
||||
void PrintAsActionResult(const T& result, std::ostream& os) {
|
||||
os << "\n Returns: ";
|
||||
// T may be a reference type, so we don't use UniversalPrint().
|
||||
UniversalPrinter<T>::Print(result, &os);
|
||||
}
|
||||
|
||||
// Reports an uninteresting call (whose description is in msg) in the
|
||||
// manner specified by 'reaction'.
|
||||
GTEST_API_ void ReportUninterestingCall(CallReaction reaction,
|
||||
const std::string& msg);
|
||||
|
||||
// A generic RAII type that runs a user-provided function in its destructor.
|
||||
class Cleanup final {
|
||||
public:
|
||||
// Returns the held value. Must not be called more than once.
|
||||
T Unwrap() { return result_.Unwrap(); }
|
||||
|
||||
// Prints the held value as an action's result to os.
|
||||
void PrintAsActionResult(::std::ostream* os) const override {
|
||||
*os << "\n Returns: ";
|
||||
// T may be a reference type, so we don't use UniversalPrint().
|
||||
UniversalPrinter<T>::Print(result_.Peek(), os);
|
||||
}
|
||||
|
||||
// Performs the given mock function's default action and returns the
|
||||
// result in a new-ed ActionResultHolder.
|
||||
template <typename F>
|
||||
static ActionResultHolder* PerformDefaultAction(
|
||||
const FunctionMocker<F>* func_mocker,
|
||||
typename Function<F>::ArgumentTuple&& args,
|
||||
const std::string& call_description) {
|
||||
return new ActionResultHolder(Wrapper(
|
||||
func_mocker->PerformDefaultAction(std::move(args), call_description)));
|
||||
}
|
||||
|
||||
// Performs the given action and returns the result in a new-ed
|
||||
// ActionResultHolder.
|
||||
template <typename F>
|
||||
static ActionResultHolder* PerformAction(
|
||||
const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
|
||||
return new ActionResultHolder(Wrapper(action.Perform(std::move(args))));
|
||||
}
|
||||
explicit Cleanup(std::function<void()> f) : f_(std::move(f)) {}
|
||||
~Cleanup() { f_(); }
|
||||
|
||||
private:
|
||||
typedef ReferenceOrValueWrapper<T> Wrapper;
|
||||
|
||||
explicit ActionResultHolder(Wrapper result) : result_(std::move(result)) {}
|
||||
|
||||
Wrapper result_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
|
||||
};
|
||||
|
||||
// Specialization for T = void.
|
||||
template <>
|
||||
class ActionResultHolder<void> : public UntypedActionResultHolderBase {
|
||||
public:
|
||||
void Unwrap() {}
|
||||
|
||||
void PrintAsActionResult(::std::ostream* /* os */) const override {}
|
||||
|
||||
// Performs the given mock function's default action and returns ownership
|
||||
// of an empty ActionResultHolder*.
|
||||
template <typename F>
|
||||
static ActionResultHolder* PerformDefaultAction(
|
||||
const FunctionMocker<F>* func_mocker,
|
||||
typename Function<F>::ArgumentTuple&& args,
|
||||
const std::string& call_description) {
|
||||
func_mocker->PerformDefaultAction(std::move(args), call_description);
|
||||
return new ActionResultHolder;
|
||||
}
|
||||
|
||||
// Performs the given action and returns ownership of an empty
|
||||
// ActionResultHolder*.
|
||||
template <typename F>
|
||||
static ActionResultHolder* PerformAction(
|
||||
const Action<F>& action, typename Function<F>::ArgumentTuple&& args) {
|
||||
action.Perform(std::move(args));
|
||||
return new ActionResultHolder;
|
||||
}
|
||||
|
||||
private:
|
||||
ActionResultHolder() {}
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
|
||||
std::function<void()> f_;
|
||||
};
|
||||
|
||||
template <typename F>
|
||||
|
|
@ -1506,32 +1448,6 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
|
|||
return DefaultValue<Result>::Get();
|
||||
}
|
||||
|
||||
// Performs the default action with the given arguments and returns
|
||||
// the action's result. The call description string will be used in
|
||||
// the error message to describe the call in the case the default
|
||||
// action fails. The caller is responsible for deleting the result.
|
||||
// L = *
|
||||
UntypedActionResultHolderBase* UntypedPerformDefaultAction(
|
||||
void* untyped_args, // must point to an ArgumentTuple
|
||||
const std::string& call_description) const override {
|
||||
ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
|
||||
return ResultHolder::PerformDefaultAction(this, std::move(*args),
|
||||
call_description);
|
||||
}
|
||||
|
||||
// Performs the given action with the given arguments and returns
|
||||
// the action's result. The caller is responsible for deleting the
|
||||
// result.
|
||||
// L = *
|
||||
UntypedActionResultHolderBase* UntypedPerformAction(
|
||||
const void* untyped_action, void* untyped_args) const override {
|
||||
// Make a copy of the action before performing it, in case the
|
||||
// action deletes the mock object (and thus deletes itself).
|
||||
const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
|
||||
ArgumentTuple* args = static_cast<ArgumentTuple*>(untyped_args);
|
||||
return ResultHolder::PerformAction(action, std::move(*args));
|
||||
}
|
||||
|
||||
// Implements UntypedFunctionMockerBase::ClearDefaultActionsLocked():
|
||||
// clears the ON_CALL()s set on this mock function.
|
||||
void ClearDefaultActionsLocked() override
|
||||
|
|
@ -1563,10 +1479,7 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
|
|||
// arguments. This function can be safely called from multiple
|
||||
// threads concurrently.
|
||||
Result Invoke(Args... args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
|
||||
ArgumentTuple tuple(std::forward<Args>(args)...);
|
||||
std::unique_ptr<ResultHolder> holder(DownCast_<ResultHolder*>(
|
||||
this->UntypedInvokeWith(static_cast<void*>(&tuple))));
|
||||
return holder->Unwrap();
|
||||
return InvokeWith(ArgumentTuple(std::forward<Args>(args)...));
|
||||
}
|
||||
|
||||
MockSpec<F> With(Matcher<Args>... m) {
|
||||
|
|
@ -1577,8 +1490,6 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
|
|||
template <typename Function>
|
||||
friend class MockSpec;
|
||||
|
||||
typedef ActionResultHolder<Result> ResultHolder;
|
||||
|
||||
// Adds and returns a default action spec for this mock function.
|
||||
OnCallSpec<F>& AddNewOnCallSpec(const char* file, int line,
|
||||
const ArgumentMatcherTuple& m)
|
||||
|
|
@ -1749,11 +1660,177 @@ class FunctionMocker<R(Args...)> final : public UntypedFunctionMockerBase {
|
|||
expectation->DescribeCallCountTo(why);
|
||||
}
|
||||
}
|
||||
|
||||
// Performs the given action (or the default if it's null) with the given
|
||||
// arguments and returns the action's result.
|
||||
// L = *
|
||||
R PerformAction(const void* untyped_action, ArgumentTuple&& args,
|
||||
const std::string& call_description) const {
|
||||
if (untyped_action == nullptr) {
|
||||
return PerformDefaultAction(std::move(args), call_description);
|
||||
}
|
||||
|
||||
// Make a copy of the action before performing it, in case the
|
||||
// action deletes the mock object (and thus deletes itself).
|
||||
const Action<F> action = *static_cast<const Action<F>*>(untyped_action);
|
||||
return action.Perform(std::move(args));
|
||||
}
|
||||
|
||||
// Is it possible to store an object of the supplied type in a local variable
|
||||
// for the sake of printing it, then return it on to the caller?
|
||||
template <typename T>
|
||||
using can_print_result = internal::conjunction<
|
||||
// void can't be stored as an object (and we also don't need to print it).
|
||||
internal::negation<std::is_void<T>>,
|
||||
// Non-moveable types can't be returned on to the user, so there's no way
|
||||
// for us to intercept and print them.
|
||||
std::is_move_constructible<T>>;
|
||||
|
||||
// Perform the supplied action, printing the result to os.
|
||||
template <typename T = R,
|
||||
typename std::enable_if<can_print_result<T>::value, int>::type = 0>
|
||||
R PerformActionAndPrintResult(const void* const untyped_action,
|
||||
ArgumentTuple&& args,
|
||||
const std::string& call_description,
|
||||
std::ostream& os) {
|
||||
R result = PerformAction(untyped_action, std::move(args), call_description);
|
||||
|
||||
PrintAsActionResult(result, os);
|
||||
return std::forward<R>(result);
|
||||
}
|
||||
|
||||
// An overload for when it's not possible to print the result. In this case we
|
||||
// simply perform the action.
|
||||
template <typename T = R,
|
||||
typename std::enable_if<
|
||||
internal::negation<can_print_result<T>>::value, int>::type = 0>
|
||||
R PerformActionAndPrintResult(const void* const untyped_action,
|
||||
ArgumentTuple&& args,
|
||||
const std::string& call_description,
|
||||
std::ostream&) {
|
||||
return PerformAction(untyped_action, std::move(args), call_description);
|
||||
}
|
||||
|
||||
// Returns the result of invoking this mock function with the given
|
||||
// arguments. This function can be safely called from multiple
|
||||
// threads concurrently.
|
||||
R InvokeWith(ArgumentTuple&& args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
|
||||
}; // class FunctionMocker
|
||||
|
||||
// Reports an uninteresting call (whose description is in msg) in the
|
||||
// manner specified by 'reaction'.
|
||||
void ReportUninterestingCall(CallReaction reaction, const std::string& msg);
|
||||
// Calculates the result of invoking this mock function with the given
|
||||
// arguments, prints it, and returns it.
|
||||
template <typename R, typename... Args>
|
||||
R FunctionMocker<R(Args...)>::InvokeWith(ArgumentTuple&& args)
|
||||
GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
|
||||
// See the definition of untyped_expectations_ for why access to it
|
||||
// is unprotected here.
|
||||
if (untyped_expectations_.size() == 0) {
|
||||
// No expectation is set on this mock method - we have an
|
||||
// uninteresting call.
|
||||
|
||||
// We must get Google Mock's reaction on uninteresting calls
|
||||
// made on this mock object BEFORE performing the action,
|
||||
// because the action may DELETE the mock object and make the
|
||||
// following expression meaningless.
|
||||
const CallReaction reaction =
|
||||
Mock::GetReactionOnUninterestingCalls(MockObject());
|
||||
|
||||
// True if and only if we need to print this call's arguments and return
|
||||
// value. This definition must be kept in sync with
|
||||
// the behavior of ReportUninterestingCall().
|
||||
const bool need_to_report_uninteresting_call =
|
||||
// If the user allows this uninteresting call, we print it
|
||||
// only when they want informational messages.
|
||||
reaction == kAllow ? LogIsVisible(kInfo) :
|
||||
// If the user wants this to be a warning, we print
|
||||
// it only 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.
|
||||
true;
|
||||
|
||||
if (!need_to_report_uninteresting_call) {
|
||||
// Perform the action without printing the call information.
|
||||
return this->PerformDefaultAction(
|
||||
std::move(args), "Function call: " + std::string(Name()));
|
||||
}
|
||||
|
||||
// Warns about the uninteresting call.
|
||||
::std::stringstream ss;
|
||||
this->UntypedDescribeUninterestingCall(&args, &ss);
|
||||
|
||||
// Perform the action, print the result, and then report the uninteresting
|
||||
// call.
|
||||
//
|
||||
// We use RAII to do the latter in case R is void or a non-moveable type. In
|
||||
// either case we can't assign it to a local variable.
|
||||
const Cleanup report_uninteresting_call(
|
||||
[&] { ReportUninterestingCall(reaction, ss.str()); });
|
||||
|
||||
return PerformActionAndPrintResult(nullptr, std::move(args), ss.str(), ss);
|
||||
}
|
||||
|
||||
bool is_excessive = false;
|
||||
::std::stringstream ss;
|
||||
::std::stringstream why;
|
||||
::std::stringstream loc;
|
||||
const void* untyped_action = nullptr;
|
||||
|
||||
// The UntypedFindMatchingExpectation() function acquires and
|
||||
// releases g_gmock_mutex.
|
||||
|
||||
const ExpectationBase* const untyped_expectation =
|
||||
this->UntypedFindMatchingExpectation(&args, &untyped_action,
|
||||
&is_excessive, &ss, &why);
|
||||
const bool found = untyped_expectation != nullptr;
|
||||
|
||||
// True if and only if we need to print the call's arguments
|
||||
// and return value.
|
||||
// This definition must be kept in sync with the uses of Expect()
|
||||
// and Log() in this function.
|
||||
const bool need_to_report_call =
|
||||
!found || is_excessive || LogIsVisible(kInfo);
|
||||
if (!need_to_report_call) {
|
||||
// Perform the action without printing the call information.
|
||||
return PerformAction(untyped_action, std::move(args), "");
|
||||
}
|
||||
|
||||
ss << " Function call: " << Name();
|
||||
this->UntypedPrintArgs(&args, &ss);
|
||||
|
||||
// In case the action deletes a piece of the expectation, we
|
||||
// generate the message beforehand.
|
||||
if (found && !is_excessive) {
|
||||
untyped_expectation->DescribeLocationTo(&loc);
|
||||
}
|
||||
|
||||
// Perform the action, print the result, and then fail or log in whatever way
|
||||
// is appropriate.
|
||||
//
|
||||
// We use RAII to do the latter in case R is void or a non-moveable type. In
|
||||
// either case we can't assign it to a local variable.
|
||||
const Cleanup handle_failures([&] {
|
||||
ss << "\n" << why.str();
|
||||
|
||||
if (!found) {
|
||||
// No expectation matches this call - reports a failure.
|
||||
Expect(false, nullptr, -1, ss.str());
|
||||
} else if (is_excessive) {
|
||||
// We had an upper-bound violation and the failure message is in ss.
|
||||
Expect(false, untyped_expectation->file(), untyped_expectation->line(),
|
||||
ss.str());
|
||||
} else {
|
||||
// We had an expected call and the matching expectation is
|
||||
// described in ss.
|
||||
Log(kInfo, loc.str() + ss.str(), 2);
|
||||
}
|
||||
});
|
||||
|
||||
return PerformActionAndPrintResult(untyped_action, std::move(args), ss.str(),
|
||||
ss);
|
||||
}
|
||||
|
||||
} // namespace internal
|
||||
|
||||
|
|
|
|||
|
|
@ -305,10 +305,13 @@ GTEST_API_ WithoutMatchers GetWithoutMatchers();
|
|||
template <typename T>
|
||||
inline T Invalid() {
|
||||
Assert(false, "", -1, "Internal error: attempt to return invalid value");
|
||||
// This statement is unreachable, and would never terminate even if it
|
||||
// could be reached. It is provided only to placate compiler warnings
|
||||
// about missing return statements.
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
__builtin_unreachable();
|
||||
#elif defined(_MSC_VER)
|
||||
__assume(0);
|
||||
#else
|
||||
return Invalid<T>();
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@
|
|||
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <iostream>
|
||||
|
||||
|
|
@ -57,6 +56,11 @@
|
|||
#include "gmock/internal/custom/gmock-port.h"
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
#if GTEST_HAS_ABSL
|
||||
#include "absl/flags/declare.h"
|
||||
#include "absl/flags/flag.h"
|
||||
#endif
|
||||
|
||||
// For MS Visual C++, check the compiler version. At least VS 2015 is
|
||||
// required to compile Google Mock.
|
||||
#if defined(_MSC_VER) && _MSC_VER < 1900
|
||||
|
|
@ -65,9 +69,50 @@
|
|||
|
||||
// Macro for referencing flags. This is public as we want the user to
|
||||
// use this syntax to reference Google Mock flags.
|
||||
#define GMOCK_FLAG_NAME_(name) gmock_##name
|
||||
#define GMOCK_FLAG(name) FLAGS_gmock_##name
|
||||
|
||||
#if !defined(GMOCK_DECLARE_bool_)
|
||||
// Pick a command line flags implementation.
|
||||
#if GTEST_HAS_ABSL
|
||||
|
||||
// Macros for defining flags.
|
||||
#define GMOCK_DEFINE_bool_(name, default_val, doc) \
|
||||
ABSL_FLAG(bool, GMOCK_FLAG_NAME_(name), default_val, doc)
|
||||
#define GMOCK_DEFINE_int32_(name, default_val, doc) \
|
||||
ABSL_FLAG(int32_t, GMOCK_FLAG_NAME_(name), default_val, doc)
|
||||
#define GMOCK_DEFINE_string_(name, default_val, doc) \
|
||||
ABSL_FLAG(std::string, GMOCK_FLAG_NAME_(name), default_val, doc)
|
||||
|
||||
// Macros for declaring flags.
|
||||
#define GMOCK_DECLARE_bool_(name) \
|
||||
ABSL_DECLARE_FLAG(bool, GMOCK_FLAG_NAME_(name))
|
||||
#define GMOCK_DECLARE_int32_(name) \
|
||||
ABSL_DECLARE_FLAG(int32_t, GMOCK_FLAG_NAME_(name))
|
||||
#define GMOCK_DECLARE_string_(name) \
|
||||
ABSL_DECLARE_FLAG(std::string, GMOCK_FLAG_NAME_(name))
|
||||
|
||||
#define GMOCK_FLAG_GET(name) ::absl::GetFlag(GMOCK_FLAG(name))
|
||||
#define GMOCK_FLAG_SET(name, value) \
|
||||
(void)(::absl::SetFlag(&GMOCK_FLAG(name), value))
|
||||
|
||||
#else // GTEST_HAS_ABSL
|
||||
|
||||
// Macros for defining flags.
|
||||
#define GMOCK_DEFINE_bool_(name, default_val, doc) \
|
||||
namespace testing { \
|
||||
GTEST_API_ bool GMOCK_FLAG(name) = (default_val); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GMOCK_DEFINE_int32_(name, default_val, doc) \
|
||||
namespace testing { \
|
||||
GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GMOCK_DEFINE_string_(name, default_val, doc) \
|
||||
namespace testing { \
|
||||
GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
|
||||
// Macros for declaring flags.
|
||||
#define GMOCK_DECLARE_bool_(name) \
|
||||
|
|
@ -86,27 +131,9 @@
|
|||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
|
||||
// Macros for defining flags.
|
||||
#define GMOCK_DEFINE_bool_(name, default_val, doc) \
|
||||
namespace testing { \
|
||||
GTEST_API_ bool GMOCK_FLAG(name) = (default_val); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GMOCK_DEFINE_int32_(name, default_val, doc) \
|
||||
namespace testing { \
|
||||
GTEST_API_ int32_t GMOCK_FLAG(name) = (default_val); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GMOCK_DEFINE_string_(name, default_val, doc) \
|
||||
namespace testing { \
|
||||
GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#endif // !defined(GMOCK_DECLARE_bool_)
|
||||
|
||||
#if !defined(GMOCK_FLAG_GET)
|
||||
#define GMOCK_FLAG_GET(name) ::testing::GMOCK_FLAG(name)
|
||||
#define GMOCK_FLAG_SET(name, value) (void)(::testing::GMOCK_FLAG(name) = value)
|
||||
#endif // !defined(GMOCK_FLAG_GET)
|
||||
|
||||
#endif // GTEST_HAS_ABSL
|
||||
|
||||
#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
|
||||
|
|
|
|||
|
|
@ -86,7 +86,8 @@ class BetweenCardinalityImpl : public CardinalityInterface {
|
|||
const int min_;
|
||||
const int max_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(BetweenCardinalityImpl);
|
||||
BetweenCardinalityImpl(const BetweenCardinalityImpl&) = delete;
|
||||
BetweenCardinalityImpl& operator=(const BetweenCardinalityImpl&) = delete;
|
||||
};
|
||||
|
||||
// Formats "n times" in a human-friendly way.
|
||||
|
|
|
|||
|
|
@ -234,7 +234,7 @@ bool Base64Unescape(const std::string& encoded, std::string* decoded) {
|
|||
return false;
|
||||
}
|
||||
if (bit_pos == 0) {
|
||||
dst |= src_bin << 2;
|
||||
dst |= static_cast<char>(src_bin << 2);
|
||||
bit_pos = 6;
|
||||
} else {
|
||||
dst |= static_cast<char>(src_bin >> (bit_pos - 2));
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@
|
|||
#include <memory>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
|
|
@ -369,136 +370,6 @@ const char* UntypedFunctionMockerBase::Name() const
|
|||
return name;
|
||||
}
|
||||
|
||||
// Calculates the result of invoking this mock function with the given
|
||||
// arguments, prints it, and returns it. The caller is responsible
|
||||
// for deleting the result.
|
||||
UntypedActionResultHolderBase* UntypedFunctionMockerBase::UntypedInvokeWith(
|
||||
void* const untyped_args) GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
|
||||
// See the definition of untyped_expectations_ for why access to it
|
||||
// is unprotected here.
|
||||
if (untyped_expectations_.size() == 0) {
|
||||
// No expectation is set on this mock method - we have an
|
||||
// uninteresting call.
|
||||
|
||||
// We must get Google Mock's reaction on uninteresting calls
|
||||
// made on this mock object BEFORE performing the action,
|
||||
// because the action may DELETE the mock object and make the
|
||||
// following expression meaningless.
|
||||
const CallReaction reaction =
|
||||
Mock::GetReactionOnUninterestingCalls(MockObject());
|
||||
|
||||
// True if and only if we need to print this call's arguments and return
|
||||
// value. This definition must be kept in sync with
|
||||
// the behavior of ReportUninterestingCall().
|
||||
const bool need_to_report_uninteresting_call =
|
||||
// If the user allows this uninteresting call, we print it
|
||||
// only when they want informational messages.
|
||||
reaction == kAllow ? LogIsVisible(kInfo) :
|
||||
// If the user wants this to be a warning, we print
|
||||
// it only 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.
|
||||
true;
|
||||
|
||||
if (!need_to_report_uninteresting_call) {
|
||||
// Perform the action without printing the call information.
|
||||
return this->UntypedPerformDefaultAction(
|
||||
untyped_args, "Function call: " + std::string(Name()));
|
||||
}
|
||||
|
||||
// Warns about the uninteresting call.
|
||||
::std::stringstream ss;
|
||||
this->UntypedDescribeUninterestingCall(untyped_args, &ss);
|
||||
|
||||
// Calculates the function result.
|
||||
UntypedActionResultHolderBase* const result =
|
||||
this->UntypedPerformDefaultAction(untyped_args, ss.str());
|
||||
|
||||
// Prints the function result.
|
||||
if (result != nullptr) result->PrintAsActionResult(&ss);
|
||||
|
||||
ReportUninterestingCall(reaction, ss.str());
|
||||
return result;
|
||||
}
|
||||
|
||||
bool is_excessive = false;
|
||||
::std::stringstream ss;
|
||||
::std::stringstream why;
|
||||
::std::stringstream loc;
|
||||
const void* untyped_action = nullptr;
|
||||
|
||||
// The UntypedFindMatchingExpectation() function acquires and
|
||||
// releases g_gmock_mutex.
|
||||
|
||||
const ExpectationBase* const untyped_expectation =
|
||||
this->UntypedFindMatchingExpectation(untyped_args, &untyped_action,
|
||||
&is_excessive, &ss, &why);
|
||||
const bool found = untyped_expectation != nullptr;
|
||||
|
||||
// True if and only if we need to print the call's arguments
|
||||
// and return value.
|
||||
// This definition must be kept in sync with the uses of Expect()
|
||||
// and Log() in this function.
|
||||
const bool need_to_report_call =
|
||||
!found || is_excessive || LogIsVisible(kInfo);
|
||||
if (!need_to_report_call) {
|
||||
// Perform the action without printing the call information.
|
||||
return untyped_action == nullptr
|
||||
? this->UntypedPerformDefaultAction(untyped_args, "")
|
||||
: this->UntypedPerformAction(untyped_action, untyped_args);
|
||||
}
|
||||
|
||||
ss << " Function call: " << Name();
|
||||
this->UntypedPrintArgs(untyped_args, &ss);
|
||||
|
||||
// In case the action deletes a piece of the expectation, we
|
||||
// generate the message beforehand.
|
||||
if (found && !is_excessive) {
|
||||
untyped_expectation->DescribeLocationTo(&loc);
|
||||
}
|
||||
|
||||
UntypedActionResultHolderBase* result = nullptr;
|
||||
|
||||
auto perform_action = [&] {
|
||||
return untyped_action == nullptr
|
||||
? this->UntypedPerformDefaultAction(untyped_args, ss.str())
|
||||
: this->UntypedPerformAction(untyped_action, untyped_args);
|
||||
};
|
||||
auto handle_failures = [&] {
|
||||
ss << "\n" << why.str();
|
||||
|
||||
if (!found) {
|
||||
// No expectation matches this call - reports a failure.
|
||||
Expect(false, nullptr, -1, ss.str());
|
||||
} else if (is_excessive) {
|
||||
// We had an upper-bound violation and the failure message is in ss.
|
||||
Expect(false, untyped_expectation->file(), untyped_expectation->line(),
|
||||
ss.str());
|
||||
} else {
|
||||
// We had an expected call and the matching expectation is
|
||||
// described in ss.
|
||||
Log(kInfo, loc.str() + ss.str(), 2);
|
||||
}
|
||||
};
|
||||
#if GTEST_HAS_EXCEPTIONS
|
||||
try {
|
||||
result = perform_action();
|
||||
} catch (...) {
|
||||
handle_failures();
|
||||
throw;
|
||||
}
|
||||
#else
|
||||
result = perform_action();
|
||||
#endif
|
||||
|
||||
if (result != nullptr) result->PrintAsActionResult(&ss);
|
||||
handle_failures();
|
||||
return result;
|
||||
}
|
||||
|
||||
// Returns an Expectation object that references and co-owns exp,
|
||||
// which must be an expectation on this mock function.
|
||||
Expectation UntypedFunctionMockerBase::GetHandleOf(ExpectationBase* exp) {
|
||||
|
|
@ -564,7 +435,7 @@ bool UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked()
|
|||
return expectations_met;
|
||||
}
|
||||
|
||||
CallReaction intToCallReaction(int mock_behavior) {
|
||||
static CallReaction intToCallReaction(int mock_behavior) {
|
||||
if (mock_behavior >= kAllow && mock_behavior <= kFail) {
|
||||
return static_cast<internal::CallReaction>(mock_behavior);
|
||||
}
|
||||
|
|
@ -664,46 +535,50 @@ MockObjectRegistry g_mock_object_registry;
|
|||
|
||||
// Maps a mock object to the reaction Google Mock should have when an
|
||||
// uninteresting method is called. Protected by g_gmock_mutex.
|
||||
std::map<const void*, internal::CallReaction> g_uninteresting_call_reaction;
|
||||
std::unordered_map<uintptr_t, internal::CallReaction>&
|
||||
UninterestingCallReactionMap() {
|
||||
static auto* map = new std::unordered_map<uintptr_t, internal::CallReaction>;
|
||||
return *map;
|
||||
}
|
||||
|
||||
// Sets the reaction Google Mock should have when an uninteresting
|
||||
// method of the given mock object is called.
|
||||
void SetReactionOnUninterestingCalls(const void* mock_obj,
|
||||
void SetReactionOnUninterestingCalls(uintptr_t mock_obj,
|
||||
internal::CallReaction reaction)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
|
||||
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||
g_uninteresting_call_reaction[mock_obj] = reaction;
|
||||
UninterestingCallReactionMap()[mock_obj] = reaction;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
// Tells Google Mock to allow uninteresting calls on the given mock
|
||||
// object.
|
||||
void Mock::AllowUninterestingCalls(const void* mock_obj)
|
||||
void Mock::AllowUninterestingCalls(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
|
||||
SetReactionOnUninterestingCalls(mock_obj, internal::kAllow);
|
||||
}
|
||||
|
||||
// Tells Google Mock to warn the user about uninteresting calls on the
|
||||
// given mock object.
|
||||
void Mock::WarnUninterestingCalls(const void* mock_obj)
|
||||
void Mock::WarnUninterestingCalls(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
|
||||
SetReactionOnUninterestingCalls(mock_obj, internal::kWarn);
|
||||
}
|
||||
|
||||
// Tells Google Mock to fail uninteresting calls on the given mock
|
||||
// object.
|
||||
void Mock::FailUninterestingCalls(const void* mock_obj)
|
||||
void Mock::FailUninterestingCalls(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
|
||||
SetReactionOnUninterestingCalls(mock_obj, internal::kFail);
|
||||
}
|
||||
|
||||
// Tells Google Mock the given mock object is being destroyed and its
|
||||
// entry in the call-reaction table should be removed.
|
||||
void Mock::UnregisterCallReaction(const void* mock_obj)
|
||||
void Mock::UnregisterCallReaction(uintptr_t mock_obj)
|
||||
GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
|
||||
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||
g_uninteresting_call_reaction.erase(mock_obj);
|
||||
UninterestingCallReactionMap().erase(static_cast<uintptr_t>(mock_obj));
|
||||
}
|
||||
|
||||
// Returns the reaction Google Mock will have on uninteresting calls
|
||||
|
|
@ -711,10 +586,12 @@ void Mock::UnregisterCallReaction(const void* mock_obj)
|
|||
internal::CallReaction Mock::GetReactionOnUninterestingCalls(
|
||||
const void* mock_obj) GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
|
||||
internal::MutexLock l(&internal::g_gmock_mutex);
|
||||
return (g_uninteresting_call_reaction.count(mock_obj) == 0)
|
||||
return (UninterestingCallReactionMap().count(
|
||||
reinterpret_cast<uintptr_t>(mock_obj)) == 0)
|
||||
? internal::intToCallReaction(
|
||||
GMOCK_FLAG_GET(default_mock_behavior))
|
||||
: g_uninteresting_call_reaction[mock_obj];
|
||||
: UninterestingCallReactionMap()[reinterpret_cast<uintptr_t>(
|
||||
mock_obj)];
|
||||
}
|
||||
|
||||
// Tells Google Mock to ignore mock_obj when checking for leaked mock
|
||||
|
|
|
|||
|
|
@ -25,7 +25,7 @@ When building GoogleTest as a standalone project, the typical workflow starts
|
|||
with
|
||||
|
||||
```
|
||||
git clone https://github.com/google/googletest.git -b release-1.11.0
|
||||
git clone https://github.com/google/googletest.git -b release-1.12.0
|
||||
cd googletest # Main directory of the cloned repository.
|
||||
mkdir build # Create a directory to hold the build output.
|
||||
cd build
|
||||
|
|
@ -94,7 +94,7 @@ include(FetchContent)
|
|||
FetchContent_Declare(
|
||||
googletest
|
||||
# Specify the commit you depend on and update it regularly.
|
||||
URL https://github.com/google/googletest/archive/e2239ee6043f73722e7aa812a459f54a28552929.zip
|
||||
URL https://github.com/google/googletest/archive/5376968f6948923e2411081fd9372e71a59d8e77.zip
|
||||
)
|
||||
# For Windows: Prevent overriding the parent project's compiler/linker settings
|
||||
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
|
||||
|
|
|
|||
|
|
@ -46,6 +46,9 @@
|
|||
#include "gtest/gtest-message.h"
|
||||
#include "gtest/internal/gtest-port.h"
|
||||
|
||||
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
|
||||
/* class A needs to have dll-interface to be used by clients of class B */)
|
||||
|
||||
namespace testing {
|
||||
|
||||
// A class for indicating whether an assertion was successful. When
|
||||
|
|
@ -229,4 +232,6 @@ GTEST_API_ AssertionResult AssertionFailure(const Message& msg);
|
|||
|
||||
} // namespace testing
|
||||
|
||||
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
|
||||
|
||||
#endif // GOOGLETEST_INCLUDE_GTEST_GTEST_ASSERTION_RESULT_H_
|
||||
|
|
|
|||
|
|
@ -102,7 +102,8 @@ class MatchResultListener {
|
|||
private:
|
||||
::std::ostream* const stream_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(MatchResultListener);
|
||||
MatchResultListener(const MatchResultListener&) = delete;
|
||||
MatchResultListener& operator=(const MatchResultListener&) = delete;
|
||||
};
|
||||
|
||||
inline MatchResultListener::~MatchResultListener() {}
|
||||
|
|
@ -220,7 +221,8 @@ class DummyMatchResultListener : public MatchResultListener {
|
|||
DummyMatchResultListener() : MatchResultListener(nullptr) {}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DummyMatchResultListener);
|
||||
DummyMatchResultListener(const DummyMatchResultListener&) = delete;
|
||||
DummyMatchResultListener& operator=(const DummyMatchResultListener&) = delete;
|
||||
};
|
||||
|
||||
// A match result listener that forwards the explanation to a given
|
||||
|
|
@ -232,7 +234,9 @@ class StreamMatchResultListener : public MatchResultListener {
|
|||
: MatchResultListener(os) {}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamMatchResultListener);
|
||||
StreamMatchResultListener(const StreamMatchResultListener&) = delete;
|
||||
StreamMatchResultListener& operator=(const StreamMatchResultListener&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
struct SharedPayloadBase {
|
||||
|
|
|
|||
|
|
@ -429,8 +429,11 @@ internal::CartesianProductHolder<Generator...> Combine(const Generator&... g) {
|
|||
return 0; \
|
||||
} \
|
||||
static int gtest_registering_dummy_ GTEST_ATTRIBUTE_UNUSED_; \
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name)); \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
|
||||
(const GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &) = delete; \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=( \
|
||||
const GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name) &) = delete; /* NOLINT */ \
|
||||
}; \
|
||||
int GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name)::gtest_registering_dummy_ = \
|
||||
|
|
|
|||
|
|
@ -85,7 +85,10 @@ class GTEST_API_ ScopedFakeTestPartResultReporter
|
|||
TestPartResultReporterInterface* old_reporter_;
|
||||
TestPartResultArray* const result_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter);
|
||||
ScopedFakeTestPartResultReporter(const ScopedFakeTestPartResultReporter&) =
|
||||
delete;
|
||||
ScopedFakeTestPartResultReporter& operator=(
|
||||
const ScopedFakeTestPartResultReporter&) = delete;
|
||||
};
|
||||
|
||||
namespace internal {
|
||||
|
|
@ -107,7 +110,8 @@ class GTEST_API_ SingleFailureChecker {
|
|||
const TestPartResult::Type type_;
|
||||
const std::string substr_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker);
|
||||
SingleFailureChecker(const SingleFailureChecker&) = delete;
|
||||
SingleFailureChecker& operator=(const SingleFailureChecker&) = delete;
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
|
@ -117,7 +121,8 @@ class GTEST_API_ SingleFailureChecker {
|
|||
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
|
||||
|
||||
// A set of macros for testing Google Test assertions or code that's expected
|
||||
// to generate Google Test fatal failures. It verifies that the given
|
||||
// to generate Google Test fatal failures (e.g. a failure from an ASSERT_EQ, but
|
||||
// not a non-fatal failure, as from EXPECT_EQ). It verifies that the given
|
||||
// statement will cause exactly one fatal Google Test failure with 'substr'
|
||||
// being part of the failure message.
|
||||
//
|
||||
|
|
@ -175,9 +180,10 @@ GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
|
|||
} while (::testing::internal::AlwaysFalse())
|
||||
|
||||
// A macro for testing Google Test assertions or code that's expected to
|
||||
// generate Google Test non-fatal failures. It asserts that the given
|
||||
// statement will cause exactly one non-fatal Google Test failure with 'substr'
|
||||
// being part of the failure message.
|
||||
// generate Google Test non-fatal failures (e.g. a failure from an EXPECT_EQ,
|
||||
// but not from an ASSERT_EQ). It asserts that the given statement will cause
|
||||
// exactly one non-fatal Google Test failure with 'substr' being part of the
|
||||
// failure message.
|
||||
//
|
||||
// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only
|
||||
// affects and considers failures generated in the current thread and
|
||||
|
|
|
|||
|
|
@ -145,7 +145,8 @@ class GTEST_API_ TestPartResultArray {
|
|||
private:
|
||||
std::vector<TestPartResult> array_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray);
|
||||
TestPartResultArray(const TestPartResultArray&) = delete;
|
||||
TestPartResultArray& operator=(const TestPartResultArray&) = delete;
|
||||
};
|
||||
|
||||
// This interface knows how to report a test part result.
|
||||
|
|
@ -176,7 +177,8 @@ class GTEST_API_ HasNewFatalFailureHelper
|
|||
bool has_new_fatal_failure_;
|
||||
TestPartResultReporterInterface* original_reporter_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper);
|
||||
HasNewFatalFailureHelper(const HasNewFatalFailureHelper&) = delete;
|
||||
HasNewFatalFailureHelper& operator=(const HasNewFatalFailureHelper&) = delete;
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
|
|
|||
|
|
@ -341,7 +341,8 @@ class GTEST_API_ Test {
|
|||
virtual Setup_should_be_spelled_SetUp* Setup() { return nullptr; }
|
||||
|
||||
// We disallow copying Tests.
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(Test);
|
||||
Test(const Test&) = delete;
|
||||
Test& operator=(const Test&) = delete;
|
||||
};
|
||||
|
||||
typedef internal::TimeInMillis TimeInMillis;
|
||||
|
|
@ -499,7 +500,8 @@ class GTEST_API_ TestResult {
|
|||
TimeInMillis elapsed_time_;
|
||||
|
||||
// We disallow copying TestResult.
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult);
|
||||
TestResult(const TestResult&) = delete;
|
||||
TestResult& operator=(const TestResult&) = delete;
|
||||
}; // class TestResult
|
||||
|
||||
// A TestInfo object stores the following information about a test:
|
||||
|
|
@ -645,7 +647,8 @@ class GTEST_API_ TestInfo {
|
|||
// test for the second time.
|
||||
TestResult result_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo);
|
||||
TestInfo(const TestInfo&) = delete;
|
||||
TestInfo& operator=(const TestInfo&) = delete;
|
||||
};
|
||||
|
||||
// A test suite, which consists of a vector of TestInfos.
|
||||
|
|
@ -854,7 +857,8 @@ class GTEST_API_ TestSuite {
|
|||
TestResult ad_hoc_test_result_;
|
||||
|
||||
// We disallow copying TestSuites.
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestSuite);
|
||||
TestSuite(const TestSuite&) = delete;
|
||||
TestSuite& operator=(const TestSuite&) = delete;
|
||||
};
|
||||
|
||||
// An Environment object is capable of setting up and tearing down an
|
||||
|
|
@ -1074,7 +1078,8 @@ class GTEST_API_ TestEventListeners {
|
|||
TestEventListener* default_xml_generator_;
|
||||
|
||||
// We disallow copying TestEventListeners.
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners);
|
||||
TestEventListeners(const TestEventListeners&) = delete;
|
||||
TestEventListeners& operator=(const TestEventListeners&) = delete;
|
||||
};
|
||||
|
||||
// A UnitTest consists of a vector of TestSuites.
|
||||
|
|
@ -1281,7 +1286,8 @@ class GTEST_API_ UnitTest {
|
|||
internal::UnitTestImpl* impl_;
|
||||
|
||||
// We disallow copying UnitTest.
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest);
|
||||
UnitTest(const UnitTest&) = delete;
|
||||
UnitTest& operator=(const UnitTest&) = delete;
|
||||
};
|
||||
|
||||
// A convenient wrapper for adding an environment for the test
|
||||
|
|
@ -1599,12 +1605,14 @@ class GTEST_API_ AssertHelper {
|
|||
std::string const message;
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData);
|
||||
AssertHelperData(const AssertHelperData&) = delete;
|
||||
AssertHelperData& operator=(const AssertHelperData&) = delete;
|
||||
};
|
||||
|
||||
AssertHelperData* const data_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper);
|
||||
AssertHelper(const AssertHelper&) = delete;
|
||||
AssertHelper& operator=(const AssertHelper&) = delete;
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
|
@ -2055,7 +2063,8 @@ class GTEST_API_ ScopedTrace {
|
|||
private:
|
||||
void PushTrace(const char* file, int line, std::string message);
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace);
|
||||
ScopedTrace(const ScopedTrace&) = delete;
|
||||
ScopedTrace& operator=(const ScopedTrace&) = delete;
|
||||
} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its
|
||||
// c'tor and d'tor. Therefore it doesn't
|
||||
// need to be used otherwise.
|
||||
|
|
|
|||
|
|
@ -97,7 +97,8 @@ class GTEST_API_ DeathTest {
|
|||
|
||||
private:
|
||||
DeathTest* const test_;
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel);
|
||||
ReturnSentinel(const ReturnSentinel&) = delete;
|
||||
ReturnSentinel& operator=(const ReturnSentinel&) = delete;
|
||||
} GTEST_ATTRIBUTE_UNUSED_;
|
||||
|
||||
// An enumeration of possible roles that may be taken when a death
|
||||
|
|
@ -142,7 +143,8 @@ class GTEST_API_ DeathTest {
|
|||
// A string containing a description of the outcome of the last death test.
|
||||
static std::string last_death_test_message_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest);
|
||||
DeathTest(const DeathTest&) = delete;
|
||||
DeathTest& operator=(const DeathTest&) = delete;
|
||||
};
|
||||
|
||||
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
|
||||
|
|
@ -287,7 +289,8 @@ class InternalRunDeathTestFlag {
|
|||
int index_;
|
||||
int write_fd_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag);
|
||||
InternalRunDeathTestFlag(const InternalRunDeathTestFlag&) = delete;
|
||||
InternalRunDeathTestFlag& operator=(const InternalRunDeathTestFlag&) = delete;
|
||||
};
|
||||
|
||||
// Returns a newly created InternalRunDeathTestFlag object with fields
|
||||
|
|
|
|||
|
|
@ -57,6 +57,7 @@
|
|||
#include <string.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <functional>
|
||||
#include <iomanip>
|
||||
#include <limits>
|
||||
#include <map>
|
||||
|
|
@ -185,14 +186,6 @@ GTEST_API_ std::string CreateUnifiedDiff(const std::vector<std::string>& left,
|
|||
|
||||
} // namespace edit_distance
|
||||
|
||||
// Calculate the diff between 'left' and 'right' and return it in unified diff
|
||||
// format.
|
||||
// If not null, stores in 'total_line_count' the total number of lines found
|
||||
// in left + right.
|
||||
GTEST_API_ std::string DiffStrings(const std::string& left,
|
||||
const std::string& right,
|
||||
size_t* total_line_count);
|
||||
|
||||
// Constructs and returns the message for an equality assertion
|
||||
// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure.
|
||||
//
|
||||
|
|
@ -465,7 +458,8 @@ class TestFactoryBase {
|
|||
TestFactoryBase() {}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
|
||||
TestFactoryBase(const TestFactoryBase&) = delete;
|
||||
TestFactoryBase& operator=(const TestFactoryBase&) = delete;
|
||||
};
|
||||
|
||||
// This class provides implementation of TeastFactoryBase interface.
|
||||
|
|
@ -638,7 +632,7 @@ class GTEST_API_ TypedTestSuitePState {
|
|||
const char* registered_tests);
|
||||
|
||||
private:
|
||||
typedef ::std::map<std::string, CodeLocation> RegisteredTestsMap;
|
||||
typedef ::std::map<std::string, CodeLocation, std::less<>> RegisteredTestsMap;
|
||||
|
||||
bool registered_;
|
||||
RegisteredTestsMap registered_tests_;
|
||||
|
|
@ -886,7 +880,8 @@ class GTEST_API_ Random {
|
|||
|
||||
private:
|
||||
uint32_t state_;
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(Random);
|
||||
Random(const Random&) = delete;
|
||||
Random& operator=(const Random&) = delete;
|
||||
};
|
||||
|
||||
// Turns const U&, U&, const U, and U all into U.
|
||||
|
|
@ -1534,37 +1529,43 @@ class NeverThrown {
|
|||
test_suite_name##_##test_name##_Test
|
||||
|
||||
// Helper macro for defining tests.
|
||||
#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id) \
|
||||
static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1, \
|
||||
"test_suite_name must not be empty"); \
|
||||
static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1, \
|
||||
"test_name must not be empty"); \
|
||||
class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
|
||||
: public parent_class { \
|
||||
public: \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default; \
|
||||
~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name)); \
|
||||
GTEST_DISALLOW_MOVE_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name)); \
|
||||
\
|
||||
private: \
|
||||
void TestBody() override; \
|
||||
static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_; \
|
||||
}; \
|
||||
\
|
||||
::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name)::test_info_ = \
|
||||
::testing::internal::MakeAndRegisterTestInfo( \
|
||||
#test_suite_name, #test_name, nullptr, nullptr, \
|
||||
::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
|
||||
::testing::internal::SuiteApiResolver< \
|
||||
parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__), \
|
||||
::testing::internal::SuiteApiResolver< \
|
||||
parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__), \
|
||||
new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_( \
|
||||
test_suite_name, test_name)>); \
|
||||
#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id) \
|
||||
static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1, \
|
||||
"test_suite_name must not be empty"); \
|
||||
static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1, \
|
||||
"test_name must not be empty"); \
|
||||
class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
|
||||
: public parent_class { \
|
||||
public: \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default; \
|
||||
~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default; \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
|
||||
(const GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &) = delete; \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=( \
|
||||
const GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name) &) = delete; /* NOLINT */ \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
|
||||
(GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &&) noexcept = delete; \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=( \
|
||||
GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name) &&) noexcept = delete; /* NOLINT */ \
|
||||
\
|
||||
private: \
|
||||
void TestBody() override; \
|
||||
static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_; \
|
||||
}; \
|
||||
\
|
||||
::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name, \
|
||||
test_name)::test_info_ = \
|
||||
::testing::internal::MakeAndRegisterTestInfo( \
|
||||
#test_suite_name, #test_name, nullptr, nullptr, \
|
||||
::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id), \
|
||||
::testing::internal::SuiteApiResolver< \
|
||||
parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__), \
|
||||
::testing::internal::SuiteApiResolver< \
|
||||
parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__), \
|
||||
new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_( \
|
||||
test_suite_name, test_name)>); \
|
||||
void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()
|
||||
|
||||
#endif // GOOGLETEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_
|
||||
|
|
|
|||
|
|
@ -406,7 +406,8 @@ class ParameterizedTestFactory : public TestFactoryBase {
|
|||
private:
|
||||
const ParamType parameter_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory);
|
||||
ParameterizedTestFactory(const ParameterizedTestFactory&) = delete;
|
||||
ParameterizedTestFactory& operator=(const ParameterizedTestFactory&) = delete;
|
||||
};
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
|
|
@ -442,7 +443,8 @@ class TestMetaFactory
|
|||
}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory);
|
||||
TestMetaFactory(const TestMetaFactory&) = delete;
|
||||
TestMetaFactory& operator=(const TestMetaFactory&) = delete;
|
||||
};
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
|
|
@ -473,7 +475,10 @@ class ParameterizedTestSuiteInfoBase {
|
|||
ParameterizedTestSuiteInfoBase() {}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfoBase);
|
||||
ParameterizedTestSuiteInfoBase(const ParameterizedTestSuiteInfoBase&) =
|
||||
delete;
|
||||
ParameterizedTestSuiteInfoBase& operator=(
|
||||
const ParameterizedTestSuiteInfoBase&) = delete;
|
||||
};
|
||||
|
||||
// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
|
||||
|
|
@ -664,7 +669,9 @@ class ParameterizedTestSuiteInfo : public ParameterizedTestSuiteInfoBase {
|
|||
TestInfoContainer tests_;
|
||||
InstantiationContainer instantiations_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteInfo);
|
||||
ParameterizedTestSuiteInfo(const ParameterizedTestSuiteInfo&) = delete;
|
||||
ParameterizedTestSuiteInfo& operator=(const ParameterizedTestSuiteInfo&) =
|
||||
delete;
|
||||
}; // class ParameterizedTestSuiteInfo
|
||||
|
||||
// Legacy API is deprecated but still available
|
||||
|
|
@ -739,7 +746,10 @@ class ParameterizedTestSuiteRegistry {
|
|||
|
||||
TestSuiteInfoContainer test_suite_infos_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestSuiteRegistry);
|
||||
ParameterizedTestSuiteRegistry(const ParameterizedTestSuiteRegistry&) =
|
||||
delete;
|
||||
ParameterizedTestSuiteRegistry& operator=(
|
||||
const ParameterizedTestSuiteRegistry&) = delete;
|
||||
};
|
||||
|
||||
// Keep track of what type-parameterized test suite are defined and
|
||||
|
|
|
|||
|
|
@ -170,6 +170,7 @@
|
|||
// GTEST_HAS_TYPED_TEST - typed tests
|
||||
// GTEST_HAS_TYPED_TEST_P - type-parameterized tests
|
||||
// GTEST_IS_THREADSAFE - Google Test is thread-safe.
|
||||
// GTEST_USES_RE2 - the RE2 regular expression library is used
|
||||
// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with
|
||||
// GTEST_HAS_POSIX_RE (see above) which users can
|
||||
// define themselves.
|
||||
|
|
@ -192,8 +193,6 @@
|
|||
// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning.
|
||||
// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a
|
||||
// variable don't have to be used.
|
||||
// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=.
|
||||
// GTEST_DISALLOW_MOVE_AND_ASSIGN_ - disables move ctor and operator=.
|
||||
// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used.
|
||||
// GTEST_INTENTIONAL_CONST_COND_PUSH_ - start code section where MSVC C4127 is
|
||||
// suppressed (constant conditional).
|
||||
|
|
@ -217,10 +216,13 @@
|
|||
// - synchronization primitives.
|
||||
//
|
||||
// Regular expressions:
|
||||
// RE - a simple regular expression class using the POSIX
|
||||
// Extended Regular Expression syntax on UNIX-like platforms
|
||||
// or a reduced regular exception syntax on other
|
||||
// platforms, including Windows.
|
||||
// RE - a simple regular expression class using
|
||||
// 1) the RE2 syntax on all platforms when built with RE2
|
||||
// and Abseil as dependencies
|
||||
// 2) the POSIX Extended Regular Expression syntax on
|
||||
// UNIX-like platforms,
|
||||
// 3) A reduced regular exception syntax on other platforms,
|
||||
// including Windows.
|
||||
// Logging:
|
||||
// GTEST_LOG_() - logs messages at the specified severity level.
|
||||
// LogToStderr() - directs all log messages to stderr.
|
||||
|
|
@ -240,8 +242,6 @@
|
|||
// BiggestInt - the biggest signed integer type.
|
||||
//
|
||||
// Command-line utilities:
|
||||
// GTEST_DECLARE_*() - declares a flag.
|
||||
// GTEST_DEFINE_*() - defines a flag.
|
||||
// GetInjectableArgvs() - returns the command line as a vector of strings.
|
||||
//
|
||||
// Environment variable utilities:
|
||||
|
|
@ -287,6 +287,12 @@
|
|||
#include "gtest/internal/custom/gtest-port.h"
|
||||
#include "gtest/internal/gtest-port-arch.h"
|
||||
|
||||
#if GTEST_HAS_ABSL
|
||||
#include "absl/flags/declare.h"
|
||||
#include "absl/flags/flag.h"
|
||||
#include "absl/flags/reflection.h"
|
||||
#endif
|
||||
|
||||
#if !defined(GTEST_DEV_EMAIL_)
|
||||
#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com"
|
||||
#define GTEST_FLAG_PREFIX_ "gtest_"
|
||||
|
|
@ -383,32 +389,19 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
|
|||
#endif
|
||||
#endif
|
||||
|
||||
#if GTEST_USES_PCRE
|
||||
// The appropriate headers have already been included.
|
||||
|
||||
// Select the regular expression implementation.
|
||||
#if GTEST_HAS_ABSL
|
||||
// When using Abseil, RE2 is required.
|
||||
#include "absl/strings/string_view.h"
|
||||
#include "re2/re2.h"
|
||||
#define GTEST_USES_RE2 1
|
||||
#elif GTEST_HAS_POSIX_RE
|
||||
|
||||
// On some platforms, <regex.h> needs someone to define size_t, and
|
||||
// won't compile otherwise. We can #include it here as we already
|
||||
// included <stdlib.h>, which is guaranteed to define size_t through
|
||||
// <stddef.h>.
|
||||
#include <regex.h> // NOLINT
|
||||
|
||||
#define GTEST_USES_POSIX_RE 1
|
||||
|
||||
#elif GTEST_OS_WINDOWS
|
||||
|
||||
// <regex.h> is not available on Windows. Use our own simple regex
|
||||
// implementation instead.
|
||||
#define GTEST_USES_SIMPLE_RE 1
|
||||
|
||||
#else
|
||||
|
||||
// <regex.h> may not be available on this platform. Use our own
|
||||
// simple regex implementation instead.
|
||||
// Use our own simple regex implementation.
|
||||
#define GTEST_USES_SIMPLE_RE 1
|
||||
|
||||
#endif // GTEST_USES_PCRE
|
||||
#endif
|
||||
|
||||
#ifndef GTEST_HAS_EXCEPTIONS
|
||||
// The user didn't tell us whether exceptions are enabled, so we need
|
||||
|
|
@ -685,20 +678,6 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
|
|||
#define GTEST_ATTRIBUTE_PRINTF_(string_index, first_to_check)
|
||||
#endif
|
||||
|
||||
// A macro to disallow copy constructor and operator=
|
||||
// This should be used in the private: declarations for a class.
|
||||
// NOLINT is for modernize-use-trailing-return-type in macro uses.
|
||||
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
|
||||
type(type const&) = delete; \
|
||||
type& operator=(type const&) = delete /* NOLINT */
|
||||
|
||||
// A macro to disallow move constructor and operator=
|
||||
// This should be used in the private: declarations for a class.
|
||||
// NOLINT is for modernize-use-trailing-return-type in macro uses.
|
||||
#define GTEST_DISALLOW_MOVE_AND_ASSIGN_(type) \
|
||||
type(type&&) noexcept = delete; \
|
||||
type& operator=(type&&) noexcept = delete /* NOLINT */
|
||||
|
||||
// Tell the compiler to warn about unused return values for functions declared
|
||||
// with this macro. The macro should be used on function declarations
|
||||
// following the argument list:
|
||||
|
|
@ -874,25 +853,37 @@ namespace internal {
|
|||
// Secret object, which is what we want.
|
||||
class Secret;
|
||||
|
||||
// The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
|
||||
// time expression is true (in new code, use static_assert instead). For
|
||||
// example, you could use it to verify the size of a static array:
|
||||
//
|
||||
// GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
|
||||
// names_incorrect_size);
|
||||
//
|
||||
// The second argument to the macro must be a valid C++ identifier. If the
|
||||
// expression is false, compiler will issue an error containing this identifier.
|
||||
#define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
|
||||
|
||||
// A helper for suppressing warnings on constant condition. It just
|
||||
// returns 'condition'.
|
||||
GTEST_API_ bool IsTrue(bool condition);
|
||||
|
||||
// Defines RE.
|
||||
|
||||
#if GTEST_USES_PCRE
|
||||
// if used, PCRE is injected by custom/gtest-port.h
|
||||
#if GTEST_USES_RE2
|
||||
|
||||
// This is almost `using RE = ::RE2`, except it is copy-constructible, and it
|
||||
// needs to disambiguate the `std::string`, `absl::string_view`, and `const
|
||||
// char*` constructors.
|
||||
class GTEST_API_ RE {
|
||||
public:
|
||||
RE(absl::string_view regex) : regex_(regex) {} // NOLINT
|
||||
RE(const char* regex) : RE(absl::string_view(regex)) {} // NOLINT
|
||||
RE(const std::string& regex) : RE(absl::string_view(regex)) {} // NOLINT
|
||||
RE(const RE& other) : RE(other.pattern()) {}
|
||||
|
||||
const std::string& pattern() const { return regex_.pattern(); }
|
||||
|
||||
static bool FullMatch(absl::string_view str, const RE& re) {
|
||||
return RE2::FullMatch(str, re.regex_);
|
||||
}
|
||||
static bool PartialMatch(absl::string_view str, const RE& re) {
|
||||
return RE2::PartialMatch(str, re.regex_);
|
||||
}
|
||||
|
||||
private:
|
||||
RE2 regex_;
|
||||
};
|
||||
|
||||
#elif GTEST_USES_POSIX_RE || GTEST_USES_SIMPLE_RE
|
||||
|
||||
// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended
|
||||
|
|
@ -943,7 +934,7 @@ class GTEST_API_ RE {
|
|||
#endif
|
||||
};
|
||||
|
||||
#endif // GTEST_USES_PCRE
|
||||
#endif // ::testing::internal::RE implementation
|
||||
|
||||
// Formats a source file path and a line number as they would appear
|
||||
// in an error message from the compiler used to compile this code.
|
||||
|
|
@ -978,7 +969,8 @@ class GTEST_API_ GTestLog {
|
|||
private:
|
||||
const GTestLogSeverity severity_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog);
|
||||
GTestLog(const GTestLog&) = delete;
|
||||
GTestLog& operator=(const GTestLog&) = delete;
|
||||
};
|
||||
|
||||
#if !defined(GTEST_LOG_)
|
||||
|
|
@ -1198,7 +1190,8 @@ class GTEST_API_ AutoHandle {
|
|||
|
||||
Handle handle_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle);
|
||||
AutoHandle(const AutoHandle&) = delete;
|
||||
AutoHandle& operator=(const AutoHandle&) = delete;
|
||||
};
|
||||
#endif
|
||||
|
||||
|
|
@ -1207,6 +1200,9 @@ class GTEST_API_ AutoHandle {
|
|||
// Nothing to do here.
|
||||
|
||||
#else
|
||||
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4251 \
|
||||
/* class A needs to have dll-interface to be used by clients of class B */)
|
||||
|
||||
// Allows a controller thread to pause execution of newly created
|
||||
// threads until notified. Instances of this class must be created
|
||||
// and destroyed in the controller thread.
|
||||
|
|
@ -1240,6 +1236,7 @@ class GTEST_API_ Notification {
|
|||
std::condition_variable cv_;
|
||||
bool notified_;
|
||||
};
|
||||
GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251
|
||||
#endif // GTEST_HAS_NOTIFICATION_
|
||||
|
||||
// On MinGW, we can have both GTEST_OS_WINDOWS and GTEST_HAS_PTHREAD
|
||||
|
|
@ -1321,7 +1318,8 @@ class ThreadWithParam : public ThreadWithParamBase {
|
|||
// finished.
|
||||
pthread_t thread_; // The native thread object.
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
|
||||
ThreadWithParam(const ThreadWithParam&) = delete;
|
||||
ThreadWithParam& operator=(const ThreadWithParam&) = delete;
|
||||
};
|
||||
#endif // !GTEST_OS_WINDOWS && GTEST_HAS_PTHREAD ||
|
||||
// GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
|
||||
|
|
@ -1384,7 +1382,8 @@ class GTEST_API_ Mutex {
|
|||
long critical_section_init_phase_; // NOLINT
|
||||
GTEST_CRITICAL_SECTION* critical_section_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
|
||||
Mutex(const Mutex&) = delete;
|
||||
Mutex& operator=(const Mutex&) = delete;
|
||||
};
|
||||
|
||||
#define GTEST_DECLARE_STATIC_MUTEX_(mutex) \
|
||||
|
|
@ -1407,7 +1406,8 @@ class GTestMutexLock {
|
|||
private:
|
||||
Mutex* const mutex_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
|
||||
GTestMutexLock(const GTestMutexLock&) = delete;
|
||||
GTestMutexLock& operator=(const GTestMutexLock&) = delete;
|
||||
};
|
||||
|
||||
typedef GTestMutexLock MutexLock;
|
||||
|
|
@ -1434,7 +1434,8 @@ class ThreadLocalBase {
|
|||
virtual ~ThreadLocalBase() {}
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocalBase);
|
||||
ThreadLocalBase(const ThreadLocalBase&) = delete;
|
||||
ThreadLocalBase& operator=(const ThreadLocalBase&) = delete;
|
||||
};
|
||||
|
||||
// Maps a thread to a set of ThreadLocals that have values instantiated on that
|
||||
|
|
@ -1491,10 +1492,12 @@ class ThreadWithParam : public ThreadWithParamBase {
|
|||
UserThreadFunc* const func_;
|
||||
const T param_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(RunnableImpl);
|
||||
RunnableImpl(const RunnableImpl&) = delete;
|
||||
RunnableImpl& operator=(const RunnableImpl&) = delete;
|
||||
};
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam);
|
||||
ThreadWithParam(const ThreadWithParam&) = delete;
|
||||
ThreadWithParam& operator=(const ThreadWithParam&) = delete;
|
||||
};
|
||||
|
||||
// Implements thread-local storage on Windows systems.
|
||||
|
|
@ -1531,7 +1534,7 @@ class ThreadLocal : public ThreadLocalBase {
|
|||
explicit ThreadLocal(const T& value)
|
||||
: default_factory_(new InstanceValueHolderFactory(value)) {}
|
||||
|
||||
~ThreadLocal() { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
|
||||
~ThreadLocal() override { ThreadLocalRegistry::OnThreadLocalDestroyed(this); }
|
||||
|
||||
T* pointer() { return GetOrCreateValue(); }
|
||||
const T* pointer() const { return GetOrCreateValue(); }
|
||||
|
|
@ -1550,7 +1553,8 @@ class ThreadLocal : public ThreadLocalBase {
|
|||
|
||||
private:
|
||||
T value_;
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
|
||||
ValueHolder(const ValueHolder&) = delete;
|
||||
ValueHolder& operator=(const ValueHolder&) = delete;
|
||||
};
|
||||
|
||||
T* GetOrCreateValue() const {
|
||||
|
|
@ -1559,7 +1563,7 @@ class ThreadLocal : public ThreadLocalBase {
|
|||
->pointer();
|
||||
}
|
||||
|
||||
virtual ThreadLocalValueHolderBase* NewValueForCurrentThread() const {
|
||||
ThreadLocalValueHolderBase* NewValueForCurrentThread() const override {
|
||||
return default_factory_->MakeNewHolder();
|
||||
}
|
||||
|
||||
|
|
@ -1570,7 +1574,8 @@ class ThreadLocal : public ThreadLocalBase {
|
|||
virtual ValueHolder* MakeNewHolder() const = 0;
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
|
||||
ValueHolderFactory(const ValueHolderFactory&) = delete;
|
||||
ValueHolderFactory& operator=(const ValueHolderFactory&) = delete;
|
||||
};
|
||||
|
||||
class DefaultValueHolderFactory : public ValueHolderFactory {
|
||||
|
|
@ -1579,7 +1584,9 @@ class ThreadLocal : public ThreadLocalBase {
|
|||
ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
|
||||
DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete;
|
||||
DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
class InstanceValueHolderFactory : public ValueHolderFactory {
|
||||
|
|
@ -1592,12 +1599,15 @@ class ThreadLocal : public ThreadLocalBase {
|
|||
private:
|
||||
const T value_; // The value for each thread.
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
|
||||
InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete;
|
||||
InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
std::unique_ptr<ValueHolderFactory> default_factory_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
|
||||
ThreadLocal(const ThreadLocal&) = delete;
|
||||
ThreadLocal& operator=(const ThreadLocal&) = delete;
|
||||
};
|
||||
|
||||
#elif GTEST_HAS_PTHREAD
|
||||
|
|
@ -1670,7 +1680,8 @@ class Mutex : public MutexBase {
|
|||
~Mutex() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); }
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex);
|
||||
Mutex(const Mutex&) = delete;
|
||||
Mutex& operator=(const Mutex&) = delete;
|
||||
};
|
||||
|
||||
// We cannot name this class MutexLock because the ctor declaration would
|
||||
|
|
@ -1687,7 +1698,8 @@ class GTestMutexLock {
|
|||
private:
|
||||
MutexBase* const mutex_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock);
|
||||
GTestMutexLock(const GTestMutexLock&) = delete;
|
||||
GTestMutexLock& operator=(const GTestMutexLock&) = delete;
|
||||
};
|
||||
|
||||
typedef GTestMutexLock MutexLock;
|
||||
|
|
@ -1744,7 +1756,8 @@ class GTEST_API_ ThreadLocal {
|
|||
|
||||
private:
|
||||
T value_;
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder);
|
||||
ValueHolder(const ValueHolder&) = delete;
|
||||
ValueHolder& operator=(const ValueHolder&) = delete;
|
||||
};
|
||||
|
||||
static pthread_key_t CreateKey() {
|
||||
|
|
@ -1776,7 +1789,8 @@ class GTEST_API_ ThreadLocal {
|
|||
virtual ValueHolder* MakeNewHolder() const = 0;
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolderFactory);
|
||||
ValueHolderFactory(const ValueHolderFactory&) = delete;
|
||||
ValueHolderFactory& operator=(const ValueHolderFactory&) = delete;
|
||||
};
|
||||
|
||||
class DefaultValueHolderFactory : public ValueHolderFactory {
|
||||
|
|
@ -1785,7 +1799,9 @@ class GTEST_API_ ThreadLocal {
|
|||
ValueHolder* MakeNewHolder() const override { return new ValueHolder(); }
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultValueHolderFactory);
|
||||
DefaultValueHolderFactory(const DefaultValueHolderFactory&) = delete;
|
||||
DefaultValueHolderFactory& operator=(const DefaultValueHolderFactory&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
class InstanceValueHolderFactory : public ValueHolderFactory {
|
||||
|
|
@ -1798,14 +1814,17 @@ class GTEST_API_ ThreadLocal {
|
|||
private:
|
||||
const T value_; // The value for each thread.
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(InstanceValueHolderFactory);
|
||||
InstanceValueHolderFactory(const InstanceValueHolderFactory&) = delete;
|
||||
InstanceValueHolderFactory& operator=(const InstanceValueHolderFactory&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
// A key pthreads uses for looking up per-thread values.
|
||||
const pthread_key_t key_;
|
||||
std::unique_ptr<ValueHolderFactory> default_factory_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal);
|
||||
ThreadLocal(const ThreadLocal&) = delete;
|
||||
ThreadLocal& operator=(const ThreadLocal&) = delete;
|
||||
};
|
||||
|
||||
#endif // GTEST_HAS_MUTEX_AND_THREAD_LOCAL_
|
||||
|
|
@ -1950,7 +1969,8 @@ inline int StrCaseCmp(const char* s1, const char* s2) {
|
|||
}
|
||||
inline char* StrDup(const char* src) { return strdup(src); }
|
||||
#else // !__BORLANDC__
|
||||
#if GTEST_OS_WINDOWS_MOBILE
|
||||
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
|
||||
GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
|
||||
inline int DoIsATTY(int /* fd */) { return 0; }
|
||||
#else
|
||||
inline int DoIsATTY(int fd) { return _isatty(fd); }
|
||||
|
|
@ -2157,32 +2177,37 @@ using TimeInMillis = int64_t; // Represents time in milliseconds.
|
|||
|
||||
// Macro for referencing flags.
|
||||
#if !defined(GTEST_FLAG)
|
||||
#define GTEST_FLAG_NAME_(name) gtest_##name
|
||||
#define GTEST_FLAG(name) FLAGS_gtest_##name
|
||||
#endif // !defined(GTEST_FLAG)
|
||||
|
||||
#if !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
|
||||
#define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
|
||||
#endif // !defined(GTEST_USE_OWN_FLAGFILE_FLAG_)
|
||||
// Pick a command line flags implementation.
|
||||
#if GTEST_HAS_ABSL
|
||||
|
||||
#if !defined(GTEST_DECLARE_bool_)
|
||||
#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
|
||||
// Macros for defining flags.
|
||||
#define GTEST_DEFINE_bool_(name, default_val, doc) \
|
||||
ABSL_FLAG(bool, GTEST_FLAG_NAME_(name), default_val, doc)
|
||||
#define GTEST_DEFINE_int32_(name, default_val, doc) \
|
||||
ABSL_FLAG(int32_t, GTEST_FLAG_NAME_(name), default_val, doc)
|
||||
#define GTEST_DEFINE_string_(name, default_val, doc) \
|
||||
ABSL_FLAG(std::string, GTEST_FLAG_NAME_(name), default_val, doc)
|
||||
|
||||
// Macros for declaring flags.
|
||||
#define GTEST_DECLARE_bool_(name) \
|
||||
namespace testing { \
|
||||
GTEST_API_ extern bool GTEST_FLAG(name); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GTEST_DECLARE_int32_(name) \
|
||||
namespace testing { \
|
||||
GTEST_API_ extern std::int32_t GTEST_FLAG(name); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GTEST_DECLARE_string_(name) \
|
||||
namespace testing { \
|
||||
GTEST_API_ extern ::std::string GTEST_FLAG(name); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GTEST_DECLARE_bool_(name) \
|
||||
ABSL_DECLARE_FLAG(bool, GTEST_FLAG_NAME_(name))
|
||||
#define GTEST_DECLARE_int32_(name) \
|
||||
ABSL_DECLARE_FLAG(int32_t, GTEST_FLAG_NAME_(name))
|
||||
#define GTEST_DECLARE_string_(name) \
|
||||
ABSL_DECLARE_FLAG(std::string, GTEST_FLAG_NAME_(name))
|
||||
|
||||
#define GTEST_FLAG_SAVER_ ::absl::FlagSaver
|
||||
|
||||
#define GTEST_FLAG_GET(name) ::absl::GetFlag(GTEST_FLAG(name))
|
||||
#define GTEST_FLAG_SET(name, value) \
|
||||
(void)(::absl::SetFlag(>EST_FLAG(name), value))
|
||||
#define GTEST_USE_OWN_FLAGFILE_FLAG_ 0
|
||||
|
||||
#else // GTEST_HAS_ABSL
|
||||
|
||||
// Macros for defining flags.
|
||||
#define GTEST_DEFINE_bool_(name, default_val, doc) \
|
||||
|
|
@ -2201,12 +2226,30 @@ using TimeInMillis = int64_t; // Represents time in milliseconds.
|
|||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
|
||||
#endif // !defined(GTEST_DECLARE_bool_)
|
||||
// Macros for declaring flags.
|
||||
#define GTEST_DECLARE_bool_(name) \
|
||||
namespace testing { \
|
||||
GTEST_API_ extern bool GTEST_FLAG(name); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GTEST_DECLARE_int32_(name) \
|
||||
namespace testing { \
|
||||
GTEST_API_ extern std::int32_t GTEST_FLAG(name); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
#define GTEST_DECLARE_string_(name) \
|
||||
namespace testing { \
|
||||
GTEST_API_ extern ::std::string GTEST_FLAG(name); \
|
||||
} \
|
||||
static_assert(true, "no-op to require trailing semicolon")
|
||||
|
||||
#define GTEST_FLAG_SAVER_ ::testing::internal::GTestFlagSaver
|
||||
|
||||
#if !defined(GTEST_FLAG_GET)
|
||||
#define GTEST_FLAG_GET(name) ::testing::GTEST_FLAG(name)
|
||||
#define GTEST_FLAG_SET(name, value) (void)(::testing::GTEST_FLAG(name) = value)
|
||||
#endif // !defined(GTEST_FLAG_GET)
|
||||
#define GTEST_USE_OWN_FLAGFILE_FLAG_ 1
|
||||
|
||||
#endif // GTEST_HAS_ABSL
|
||||
|
||||
// Thread annotations
|
||||
#if !defined(GTEST_EXCLUSIVE_LOCK_REQUIRED_)
|
||||
|
|
@ -2362,8 +2405,7 @@ template <typename... T>
|
|||
using Variant = ::std::variant<T...>;
|
||||
} // namespace internal
|
||||
} // namespace testing
|
||||
// The case where absl is configured NOT to alias std::variant is not
|
||||
// supported.
|
||||
// The case where absl is configured NOT to alias std::variant is not supported.
|
||||
#endif // __has_include(<variant>) && __cplusplus >= 201703L
|
||||
#endif // __has_include
|
||||
#endif // GTEST_HAS_ABSL
|
||||
|
|
|
|||
|
|
@ -424,7 +424,9 @@ class OsStackTraceGetterInterface {
|
|||
static const char* const kElidedFramesMarker;
|
||||
|
||||
private:
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface);
|
||||
OsStackTraceGetterInterface(const OsStackTraceGetterInterface&) = delete;
|
||||
OsStackTraceGetterInterface& operator=(const OsStackTraceGetterInterface&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
// A working implementation of the OsStackTraceGetterInterface interface.
|
||||
|
|
@ -446,7 +448,8 @@ class OsStackTraceGetter : public OsStackTraceGetterInterface {
|
|||
void* caller_frame_ = nullptr;
|
||||
#endif // GTEST_HAS_ABSL
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter);
|
||||
OsStackTraceGetter(const OsStackTraceGetter&) = delete;
|
||||
OsStackTraceGetter& operator=(const OsStackTraceGetter&) = delete;
|
||||
};
|
||||
|
||||
// Information about a Google Test trace point.
|
||||
|
|
@ -469,7 +472,10 @@ class DefaultGlobalTestPartResultReporter
|
|||
private:
|
||||
UnitTestImpl* const unit_test_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter);
|
||||
DefaultGlobalTestPartResultReporter(
|
||||
const DefaultGlobalTestPartResultReporter&) = delete;
|
||||
DefaultGlobalTestPartResultReporter& operator=(
|
||||
const DefaultGlobalTestPartResultReporter&) = delete;
|
||||
};
|
||||
|
||||
// This is the default per thread test part result reporter used in
|
||||
|
|
@ -485,7 +491,10 @@ class DefaultPerThreadTestPartResultReporter
|
|||
private:
|
||||
UnitTestImpl* const unit_test_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter);
|
||||
DefaultPerThreadTestPartResultReporter(
|
||||
const DefaultPerThreadTestPartResultReporter&) = delete;
|
||||
DefaultPerThreadTestPartResultReporter& operator=(
|
||||
const DefaultPerThreadTestPartResultReporter&) = delete;
|
||||
};
|
||||
|
||||
// The private implementation of the UnitTest class. We don't protect
|
||||
|
|
@ -942,7 +951,8 @@ class GTEST_API_ UnitTestImpl {
|
|||
// starts.
|
||||
bool catch_exceptions_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl);
|
||||
UnitTestImpl(const UnitTestImpl&) = delete;
|
||||
UnitTestImpl& operator=(const UnitTestImpl&) = delete;
|
||||
}; // class UnitTestImpl
|
||||
|
||||
// Convenience function for accessing the global UnitTest
|
||||
|
|
@ -1101,7 +1111,8 @@ class StreamingListener : public EmptyTestEventListener {
|
|||
const std::string host_name_;
|
||||
const std::string port_num_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter);
|
||||
SocketWriter(const SocketWriter&) = delete;
|
||||
SocketWriter& operator=(const SocketWriter&) = delete;
|
||||
}; // class SocketWriter
|
||||
|
||||
// Escapes '=', '&', '%', and '\n' characters in str as "%xx".
|
||||
|
|
@ -1187,7 +1198,8 @@ class StreamingListener : public EmptyTestEventListener {
|
|||
|
||||
const std::unique_ptr<AbstractSocketWriter> socket_writer_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener);
|
||||
StreamingListener(const StreamingListener&) = delete;
|
||||
StreamingListener& operator=(const StreamingListener&) = delete;
|
||||
}; // class StreamingListener
|
||||
|
||||
#endif // GTEST_CAN_STREAM_RESULTS_
|
||||
|
|
|
|||
|
|
@ -90,15 +90,6 @@
|
|||
namespace testing {
|
||||
namespace internal {
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
|
||||
const int kStdOutFileno = 1;
|
||||
const int kStdErrFileno = 2;
|
||||
#else
|
||||
const int kStdOutFileno = STDOUT_FILENO;
|
||||
const int kStdErrFileno = STDERR_FILENO;
|
||||
#endif // _MSC_VER
|
||||
|
||||
#if GTEST_OS_LINUX || GTEST_OS_GNU_HURD
|
||||
|
||||
namespace {
|
||||
|
|
@ -374,7 +365,8 @@ class MemoryIsNotDeallocated {
|
|||
private:
|
||||
int old_crtdbg_flag_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(MemoryIsNotDeallocated);
|
||||
MemoryIsNotDeallocated(const MemoryIsNotDeallocated&) = delete;
|
||||
MemoryIsNotDeallocated& operator=(const MemoryIsNotDeallocated&) = delete;
|
||||
};
|
||||
#endif // _MSC_VER
|
||||
|
||||
|
|
@ -469,7 +461,8 @@ class ThreadWithParamSupport : public ThreadWithParamBase {
|
|||
// Prohibit instantiation.
|
||||
ThreadWithParamSupport();
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParamSupport);
|
||||
ThreadWithParamSupport(const ThreadWithParamSupport&) = delete;
|
||||
ThreadWithParamSupport& operator=(const ThreadWithParamSupport&) = delete;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
|
@ -1146,7 +1139,8 @@ class CapturedStream {
|
|||
// Name of the temporary file holding the stderr output.
|
||||
::std::string filename_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream);
|
||||
CapturedStream(const CapturedStream&) = delete;
|
||||
CapturedStream& operator=(const CapturedStream&) = delete;
|
||||
};
|
||||
|
||||
GTEST_DISABLE_MSC_DEPRECATED_POP_()
|
||||
|
|
@ -1174,6 +1168,15 @@ static std::string GetCapturedStream(CapturedStream** captured_stream) {
|
|||
return content;
|
||||
}
|
||||
|
||||
#if defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
// MSVC and C++Builder do not provide a definition of STDERR_FILENO.
|
||||
const int kStdOutFileno = 1;
|
||||
const int kStdErrFileno = 2;
|
||||
#else
|
||||
const int kStdOutFileno = STDOUT_FILENO;
|
||||
const int kStdErrFileno = STDERR_FILENO;
|
||||
#endif // defined(_MSC_VER) || defined(__BORLANDC__)
|
||||
|
||||
// Starts capturing stdout.
|
||||
void CaptureStdout() {
|
||||
CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout);
|
||||
|
|
|
|||
|
|
@ -44,6 +44,7 @@
|
|||
#include <chrono> // NOLINT
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <initializer_list>
|
||||
#include <iomanip>
|
||||
#include <iterator>
|
||||
#include <limits>
|
||||
|
|
@ -136,7 +137,10 @@
|
|||
#include "absl/debugging/failure_signal_handler.h"
|
||||
#include "absl/debugging/stacktrace.h"
|
||||
#include "absl/debugging/symbolize.h"
|
||||
#include "absl/flags/parse.h"
|
||||
#include "absl/flags/usage.h"
|
||||
#include "absl/strings/str_cat.h"
|
||||
#include "absl/strings/str_replace.h"
|
||||
#endif // GTEST_HAS_ABSL
|
||||
|
||||
namespace testing {
|
||||
|
|
@ -3274,14 +3278,9 @@ static void ColoredPrintf(GTestColor color, const char* fmt, ...) {
|
|||
va_list args;
|
||||
va_start(args, fmt);
|
||||
|
||||
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS || GTEST_OS_IOS || \
|
||||
GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT || defined(ESP_PLATFORM)
|
||||
const bool use_color = AlwaysFalse();
|
||||
#else
|
||||
static const bool in_color_mode =
|
||||
ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
|
||||
const bool use_color = in_color_mode && (color != GTestColor::kDefault);
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_ZOS
|
||||
|
||||
if (!use_color) {
|
||||
vprintf(fmt, args);
|
||||
|
|
@ -3797,7 +3796,8 @@ class TestEventRepeater : public TestEventListener {
|
|||
// The list of listeners that receive events.
|
||||
std::vector<TestEventListener*> listeners_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater);
|
||||
TestEventRepeater(const TestEventRepeater&) = delete;
|
||||
TestEventRepeater& operator=(const TestEventRepeater&) = delete;
|
||||
};
|
||||
|
||||
TestEventRepeater::~TestEventRepeater() {
|
||||
|
|
@ -3975,7 +3975,8 @@ class XmlUnitTestResultPrinter : public EmptyTestEventListener {
|
|||
// The output file.
|
||||
const std::string output_file_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter);
|
||||
XmlUnitTestResultPrinter(const XmlUnitTestResultPrinter&) = delete;
|
||||
XmlUnitTestResultPrinter& operator=(const XmlUnitTestResultPrinter&) = delete;
|
||||
};
|
||||
|
||||
// Creates a new XmlUnitTestResultPrinter.
|
||||
|
|
@ -4488,7 +4489,9 @@ class JsonUnitTestResultPrinter : public EmptyTestEventListener {
|
|||
// The output file.
|
||||
const std::string output_file_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(JsonUnitTestResultPrinter);
|
||||
JsonUnitTestResultPrinter(const JsonUnitTestResultPrinter&) = delete;
|
||||
JsonUnitTestResultPrinter& operator=(const JsonUnitTestResultPrinter&) =
|
||||
delete;
|
||||
};
|
||||
|
||||
// Creates a new JsonUnitTestResultPrinter.
|
||||
|
|
@ -5038,7 +5041,8 @@ class ScopedPrematureExitFile {
|
|||
private:
|
||||
const std::string premature_exit_filepath_;
|
||||
|
||||
GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile);
|
||||
ScopedPrematureExitFile(const ScopedPrematureExitFile&) = delete;
|
||||
ScopedPrematureExitFile& operator=(const ScopedPrematureExitFile&) = delete;
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
|
@ -6590,9 +6594,7 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
|
|||
LoadFlagsFromFile(flagfile_value);
|
||||
remove_flag = true;
|
||||
#endif // GTEST_USE_OWN_FLAGFILE_FLAG_
|
||||
} else if (arg_string == "--help" || arg_string == "-h" ||
|
||||
arg_string == "-?" || arg_string == "/?" ||
|
||||
HasGoogleTestFlagPrefix(arg)) {
|
||||
} else if (arg_string == "--help" || HasGoogleTestFlagPrefix(arg)) {
|
||||
// Both help flag and unrecognized Google Test flags (excluding
|
||||
// internal ones) trigger help display.
|
||||
g_help_flag = true;
|
||||
|
|
@ -6627,7 +6629,27 @@ void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
|
|||
// Parses the command line for Google Test flags, without initializing
|
||||
// other parts of Google Test.
|
||||
void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
|
||||
#if GTEST_HAS_ABSL
|
||||
if (*argc > 0) {
|
||||
// absl::ParseCommandLine() requires *argc > 0.
|
||||
auto positional_args = absl::flags_internal::ParseCommandLineImpl(
|
||||
*argc, argv, absl::flags_internal::ArgvListAction::kRemoveParsedArgs,
|
||||
absl::flags_internal::UsageFlagsAction::kHandleUsage,
|
||||
absl::flags_internal::OnUndefinedFlag::kReportUndefined);
|
||||
// Any command-line positional arguments not part of any command-line flag
|
||||
// (or arguments to a flag) are copied back out to argv, with the program
|
||||
// invocation name at position 0, and argc is resized. This includes
|
||||
// positional arguments after the flag-terminating delimiter '--'.
|
||||
// See https://abseil.io/docs/cpp/guides/flags.
|
||||
std::copy(positional_args.begin(), positional_args.end(), argv);
|
||||
if (static_cast<int>(positional_args.size()) < *argc) {
|
||||
argv[positional_args.size()] = nullptr;
|
||||
*argc = static_cast<int>(positional_args.size());
|
||||
}
|
||||
}
|
||||
#else
|
||||
ParseGoogleTestFlagsOnlyImpl(argc, argv);
|
||||
#endif
|
||||
|
||||
// Fix the value of *_NSGetArgc() on macOS, but if and only if
|
||||
// *_NSGetArgv() == argv
|
||||
|
|
@ -6662,6 +6684,12 @@ void InitGoogleTestImpl(int* argc, CharType** argv) {
|
|||
|
||||
#if GTEST_HAS_ABSL
|
||||
absl::InitializeSymbolizer(g_argvs[0].c_str());
|
||||
|
||||
// When using the Abseil Flags library, set the program usage message to the
|
||||
// help message, but remove the color-encoding from the message first.
|
||||
absl::SetProgramUsageMessage(absl::StrReplaceAll(
|
||||
kColorEncodedHelpMessage,
|
||||
{{"@D", ""}, {"@R", ""}, {"@G", ""}, {"@Y", ""}, {"@@", "@"}}));
|
||||
#endif // GTEST_HAS_ABSL
|
||||
|
||||
ParseGoogleTestFlagsOnly(argc, argv);
|
||||
|
|
@ -6713,37 +6741,37 @@ void InitGoogleTest() {
|
|||
#endif // defined(GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_)
|
||||
}
|
||||
|
||||
#if !defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
|
||||
// Return value of first environment variable that is set and contains
|
||||
// a non-empty string. If there are none, return the "fallback" string.
|
||||
// Since we like the temporary directory to have a directory separator suffix,
|
||||
// add it if not provided in the environment variable value.
|
||||
static std::string GetTempDirFromEnv(
|
||||
std::initializer_list<const char*> environment_variables,
|
||||
const char* fallback, char separator) {
|
||||
for (const char* variable_name : environment_variables) {
|
||||
const char* value = internal::posix::GetEnv(variable_name);
|
||||
if (value != nullptr && value[0] != '\0') {
|
||||
if (value[strlen(value) - 1] != separator) {
|
||||
return std::string(value).append(1, separator);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
}
|
||||
return fallback;
|
||||
}
|
||||
#endif
|
||||
|
||||
std::string TempDir() {
|
||||
#if defined(GTEST_CUSTOM_TEMPDIR_FUNCTION_)
|
||||
return GTEST_CUSTOM_TEMPDIR_FUNCTION_();
|
||||
#elif GTEST_OS_WINDOWS_MOBILE
|
||||
return "\\temp\\";
|
||||
#elif GTEST_OS_WINDOWS
|
||||
const char* temp_dir = internal::posix::GetEnv("TEMP");
|
||||
if (temp_dir == nullptr || temp_dir[0] == '\0') {
|
||||
return "\\temp\\";
|
||||
} else if (temp_dir[strlen(temp_dir) - 1] == '\\') {
|
||||
return temp_dir;
|
||||
} else {
|
||||
return std::string(temp_dir) + "\\";
|
||||
}
|
||||
#elif GTEST_OS_WINDOWS || GTEST_OS_WINDOWS_MOBILE
|
||||
return GetTempDirFromEnv({"TEST_TMPDIR", "TEMP"}, "\\temp\\", '\\');
|
||||
#elif GTEST_OS_LINUX_ANDROID
|
||||
const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
|
||||
if (temp_dir == nullptr || temp_dir[0] == '\0') {
|
||||
return "/data/local/tmp/";
|
||||
} else {
|
||||
return temp_dir;
|
||||
}
|
||||
#elif GTEST_OS_LINUX
|
||||
const char* temp_dir = internal::posix::GetEnv("TEST_TMPDIR");
|
||||
if (temp_dir == nullptr || temp_dir[0] == '\0') {
|
||||
return "/tmp/";
|
||||
} else {
|
||||
return temp_dir;
|
||||
}
|
||||
return GetTempDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/data/local/tmp/", '/');
|
||||
#else
|
||||
return "/tmp/";
|
||||
#endif // GTEST_OS_WINDOWS_MOBILE
|
||||
return GetTempDirFromEnv({"TEST_TMPDIR", "TMPDIR"}, "/tmp/", '/');
|
||||
#endif
|
||||
}
|
||||
|
||||
// Class ScopedTrace
|
||||
|
|
|
|||
|
|
@ -1,26 +0,0 @@
|
|||
diff --git a/googletest/include/gtest/gtest-matchers.h b/googletest/include/gtest/gtest-matchers.h
|
||||
index 75836605..3d3bea31 100644
|
||||
--- a/googletest/include/gtest/gtest-matchers.h
|
||||
+++ b/googletest/include/gtest/gtest-matchers.h
|
||||
@@ -299,17 +299,18 @@ class MatcherBase : private MatcherDescriberInterface {
|
||||
}
|
||||
|
||||
protected:
|
||||
- MatcherBase() : vtable_(nullptr) {}
|
||||
+ MatcherBase() : vtable_(nullptr), buffer_() {}
|
||||
|
||||
// Constructs a matcher from its implementation.
|
||||
template <typename U>
|
||||
- explicit MatcherBase(const MatcherInterface<U>* impl) {
|
||||
+ explicit MatcherBase(const MatcherInterface<U>* impl)
|
||||
+ : vtable_(nullptr), buffer_() {
|
||||
Init(impl);
|
||||
}
|
||||
|
||||
template <typename M, typename = typename std::remove_reference<
|
||||
M>::type::is_gtest_matcher>
|
||||
- MatcherBase(M&& m) { // NOLINT
|
||||
+ MatcherBase(M&& m) : vtable_(nullptr), buffer_() { // NOLINT
|
||||
Init(std::forward<M>(m));
|
||||
}
|
||||
|
||||
|
|
@ -10,9 +10,9 @@ origin:
|
|||
|
||||
url: https://google.github.io/googletest/
|
||||
|
||||
release: commit af29db7ec28d6df1c7f0f745186884091e602e07 (2022-03-23T22:08:26Z).
|
||||
release: e009c3d3dcb522c21ea83984dac6064a6399d3f6 (2022-07-07T16:18:52Z).
|
||||
|
||||
revision: af29db7ec28d6df1c7f0f745186884091e602e07
|
||||
revision: e009c3d3dcb522c21ea83984dac6064a6399d3f6
|
||||
|
||||
license: BSD-3-Clause
|
||||
license-file: LICENSE
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче