eson/googletest
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Googletest export

Browse Source 
Unifdef c++11-related macros from googletest now that it requires C++11.

PiperOrigin-RevId: 225905601
This commit is contained in:
Abseil Team 2018-12-17 18:59:00 -05:00 committed by Mark Barolak
parent 9ab640ce5e
commit e26a3fa13c
17 changed files with 30 additions and 654 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
.gitignore vendored
View File

@ -1,56 +0,0 @@
# Ignore CI build directory
build/
xcuserdata
cmake-build-debug/
.idea/
bazel-bin
bazel-genfiles
bazel-googletest
bazel-out
bazel-testlogs
# python
*.pyc
# Visual Studio files
*.sdf
*.opensdf
*.VC.opendb
*.suo
*.user
_ReSharper.Caches/
Win32-Debug/
Win32-Release/
x64-Debug/
x64-Release/
# Ignore autoconf / automake files
Makefile.in
aclocal.m4
configure
build-aux/
autom4te.cache/
googletest/m4/libtool.m4
googletest/m4/ltoptions.m4
googletest/m4/ltsugar.m4
googletest/m4/ltversion.m4
googletest/m4/lt~obsolete.m4
# Ignore generated directories.
googlemock/fused-src/
googletest/fused-src/
# macOS files
.DS_Store
googletest/.DS_Store
googletest/xcode/.DS_Store
# Ignore cmake generated directories and files.
CMakeFiles
CTestTestfile.cmake
Makefile
cmake_install.cmake
googlemock/CMakeFiles
googlemock/CTestTestfile.cmake
googlemock/Makefile
googlemock/cmake_install.cmake
googlemock/gtest

50
googlemock/include/gmock/gmock-actions.h
View File

@ -42,18 +42,15 @@
#endif #endif
#include <algorithm> #include <algorithm>
#include <functional>
#include <memory> #include <memory>
#include <string> #include <string>
#include <type_traits>
#include <utility> #include <utility>
#include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-internal-utils.h"
#include "gmock/internal/gmock-port.h" #include "gmock/internal/gmock-port.h"
#if GTEST_LANG_CXX11 // Defined by gtest-port.h via gmock-port.h.
#include <functional>
#include <type_traits>
#endif // GTEST_LANG_CXX11
#ifdef _MSC_VER #ifdef _MSC_VER
# pragma warning(push) # pragma warning(push)
# pragma warning(disable:4100) # pragma warning(disable:4100)
@ -105,7 +102,6 @@ struct BuiltInDefaultValueGetter<T, false> {
template <typename T> template <typename T>
class BuiltInDefaultValue { class BuiltInDefaultValue {
public: public:
#if GTEST_LANG_CXX11
// This function returns true iff type T has a built-in default value. // This function returns true iff type T has a built-in default value.
static bool Exists() { static bool Exists() {
return ::std::is_default_constructible<T>::value; return ::std::is_default_constructible<T>::value;
@ -115,18 +111,6 @@ class BuiltInDefaultValue {
return BuiltInDefaultValueGetter< return BuiltInDefaultValueGetter<
T, ::std::is_default_constructible<T>::value>::Get(); T, ::std::is_default_constructible<T>::value>::Get();
} }
#else // GTEST_LANG_CXX11
// This function returns true iff type T has a built-in default value.
static bool Exists() {
return false;
}
static T Get() {
return BuiltInDefaultValueGetter<T, false>::Get();
}
#endif // GTEST_LANG_CXX11
}; };
// This partial specialization says that we use the same built-in // This partial specialization says that we use the same built-in
@ -366,7 +350,6 @@ class Action {
// STL containers. // STL containers.
Action() {} Action() {}
#if GTEST_LANG_CXX11
// Construct an Action from a specified callable. // Construct an Action from a specified callable.
// This cannot take std::function directly, because then Action would not be // This cannot take std::function directly, because then Action would not be
// directly constructible from lambda (it would require two conversions). // directly constructible from lambda (it would require two conversions).
@ -374,7 +357,6 @@ class Action {
typename = typename ::std::enable_if< typename = typename ::std::enable_if<
::std::is_constructible<::std::function<F>, G>::value>::type> ::std::is_constructible<::std::function<F>, G>::value>::type>
Action(G&& fun) : fun_(::std::forward<G>(fun)) {} // NOLINT Action(G&& fun) : fun_(::std::forward<G>(fun)) {} // NOLINT
#endif
// Constructs an Action from its implementation. // Constructs an Action from its implementation.
explicit Action(ActionInterface<F>* impl) : impl_(impl) {} explicit Action(ActionInterface<F>* impl) : impl_(impl) {}
@ -388,11 +370,7 @@ class Action {
// Returns true iff this is the DoDefault() action. // Returns true iff this is the DoDefault() action.
bool IsDoDefault() const { bool IsDoDefault() const {
#if GTEST_LANG_CXX11
return impl_ == nullptr && fun_ == nullptr; return impl_ == nullptr && fun_ == nullptr;
#else
return impl_ == NULL;
#endif
} }
// Performs the action. Note that this method is const even though // Performs the action. Note that this method is const even though
@ -405,11 +383,9 @@ class Action {
if (IsDoDefault()) { if (IsDoDefault()) {
internal::IllegalDoDefault(__FILE__, __LINE__); internal::IllegalDoDefault(__FILE__, __LINE__);
} }
#if GTEST_LANG_CXX11
if (fun_ != nullptr) { if (fun_ != nullptr) {
return internal::Apply(fun_, ::std::move(args)); return internal::Apply(fun_, ::std::move(args));
} }
#endif
return impl_->Perform(args); return impl_->Perform(args);
} }
@ -420,16 +396,12 @@ class Action {
template <typename G> template <typename G>
friend class Action; friend class Action;
// In C++11, Action can be implemented either as a generic functor (through // Action can be implemented either as a generic functor (via std::function),
// std::function), or legacy ActionInterface. In C++98, only ActionInterface // or legacy ActionInterface. The invariant is that at most one of fun_ and
// is available. The invariants are as follows: // impl_ may be nonnull; both are null iff this is the default action.
// * in C++98, impl_ is null iff this is the default action // FIXME: Fold the ActionInterface into std::function.
// * in C++11, at most one of fun_ & impl_ may be nonnull; both are null iff
// this is the default action
#if GTEST_LANG_CXX11
::std::function<F> fun_; ::std::function<F> fun_;
#endif ::std::shared_ptr<ActionInterface<F>> impl_;
std::shared_ptr<ActionInterface<F>> impl_;
}; };
// The PolymorphicAction class template makes it easy to implement a // The PolymorphicAction class template makes it easy to implement a
@ -662,13 +634,7 @@ class ReturnNullAction {
// pointer type on compile time. // pointer type on compile time.
template <typename Result, typename ArgumentTuple> template <typename Result, typename ArgumentTuple>
static Result Perform(const ArgumentTuple&) { static Result Perform(const ArgumentTuple&) {
#if GTEST_LANG_CXX11
return nullptr; return nullptr;
#else
GTEST_COMPILE_ASSERT_(internal::is_pointer<Result>::value,
ReturnNull_can_be_used_to_return_a_pointer_only);
return NULL;
#endif // GTEST_LANG_CXX11
} }
}; };
@ -1108,9 +1074,7 @@ template <typename To>
template <typename From> template <typename From>
Action<To>::Action(const Action<From>& from) Action<To>::Action(const Action<From>& from)
: :
#if GTEST_LANG_CXX11
fun_(from.fun_), fun_(from.fun_),
#endif
impl_(from.impl_ == nullptr impl_(from.impl_ == nullptr
? nullptr ? nullptr
: new internal::ActionAdaptor<To, From>(from)) { : new internal::ActionAdaptor<To, From>(from)) {

5
googlemock/include/gmock/gmock-generated-function-mockers.h
View File

@ -41,15 +41,12 @@
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
#include <functional>
#include <utility> #include <utility>
#include "gmock/gmock-spec-builders.h" #include "gmock/gmock-spec-builders.h"
#include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-internal-utils.h"
#if GTEST_HAS_STD_FUNCTION_
# include <functional>
#endif
namespace testing { namespace testing {
namespace internal { namespace internal {
// Removes the given pointer; this is a helper for the expectation setter method // Removes the given pointer; this is a helper for the expectation setter method

5
googlemock/include/gmock/gmock-generated-function-mockers.h.pump
View File

@ -42,15 +42,12 @@ $var n = 10 $$ The maximum arity we support.
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ #ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ #define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_
#include <functional>
#include <utility> #include <utility>
#include "gmock/gmock-spec-builders.h" #include "gmock/gmock-spec-builders.h"
#include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-internal-utils.h"
#if GTEST_HAS_STD_FUNCTION_
# include <functional>
#endif
namespace testing { namespace testing {
namespace internal { namespace internal {

240
googlemock/include/gmock/gmock-generated-nice-strict.h
View File

@ -80,7 +80,6 @@ class NiceMock : public MockClass {
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#if GTEST_LANG_CXX11
// Ideally, we would inherit base class's constructors through a using // Ideally, we would inherit base class's constructors through a using
// declaration, which would preserve their visibility. However, many existing // declaration, which would preserve their visibility. However, many existing
// tests rely on the fact that current implementation reexports protected // tests rely on the fact that current implementation reexports protected
@ -101,85 +100,6 @@ class NiceMock : public MockClass {
::testing::Mock::AllowUninterestingCalls( ::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#else
// C++98 doesn't have variadic templates, so we have to define one
// for each arity.
template <typename A1>
explicit NiceMock(const A1& a1) : MockClass(a1) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2>
NiceMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3>
NiceMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4>
NiceMock(const A1& a1, const A2& a2, const A3& a3,
const A4& a4) : MockClass(a1, a2, a3, a4) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
a6, a7) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
a2, a3, a4, a5, a6, a7, a8) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8,
const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9, typename A10>
NiceMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
::testing::Mock::AllowUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
#endif // GTEST_LANG_CXX11
~NiceMock() { // NOLINT ~NiceMock() { // NOLINT
::testing::Mock::UnregisterCallReaction( ::testing::Mock::UnregisterCallReaction(
@ -198,7 +118,6 @@ class NaggyMock : public MockClass {
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#if GTEST_LANG_CXX11
// Ideally, we would inherit base class's constructors through a using // Ideally, we would inherit base class's constructors through a using
// declaration, which would preserve their visibility. However, many existing // declaration, which would preserve their visibility. However, many existing
// tests rely on the fact that current implementation reexports protected // tests rely on the fact that current implementation reexports protected
@ -219,85 +138,6 @@ class NaggyMock : public MockClass {
::testing::Mock::WarnUninterestingCalls( ::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#else
// C++98 doesn't have variadic templates, so we have to define one
// for each arity.
template <typename A1>
explicit NaggyMock(const A1& a1) : MockClass(a1) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2>
NaggyMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3>
NaggyMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4>
NaggyMock(const A1& a1, const A2& a2, const A3& a3,
const A4& a4) : MockClass(a1, a2, a3, a4) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5>
NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6>
NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7>
NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
a6, a7) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8>
NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
a2, a3, a4, a5, a6, a7, a8) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9>
NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8,
const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9, typename A10>
NaggyMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
::testing::Mock::WarnUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
#endif // GTEST_LANG_CXX11
~NaggyMock() { // NOLINT ~NaggyMock() { // NOLINT
::testing::Mock::UnregisterCallReaction( ::testing::Mock::UnregisterCallReaction(
@ -316,7 +156,6 @@ class StrictMock : public MockClass {
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#if GTEST_LANG_CXX11
// Ideally, we would inherit base class's constructors through a using // Ideally, we would inherit base class's constructors through a using
// declaration, which would preserve their visibility. However, many existing // declaration, which would preserve their visibility. However, many existing
// tests rely on the fact that current implementation reexports protected // tests rely on the fact that current implementation reexports protected
@ -337,85 +176,6 @@ class StrictMock : public MockClass {
::testing::Mock::FailUninterestingCalls( ::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#else
// C++98 doesn't have variadic templates, so we have to define one
// for each arity.
template <typename A1>
explicit StrictMock(const A1& a1) : MockClass(a1) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2>
StrictMock(const A1& a1, const A2& a2) : MockClass(a1, a2) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3>
StrictMock(const A1& a1, const A2& a2, const A3& a3) : MockClass(a1, a2, a3) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4>
StrictMock(const A1& a1, const A2& a2, const A3& a3,
const A4& a4) : MockClass(a1, a2, a3, a4) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5) : MockClass(a1, a2, a3, a4, a5) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6) : MockClass(a1, a2, a3, a4, a5, a6) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7) : MockClass(a1, a2, a3, a4, a5,
a6, a7) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8) : MockClass(a1,
a2, a3, a4, a5, a6, a7, a8) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8,
const A9& a9) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9, typename A10>
StrictMock(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9,
const A10& a10) : MockClass(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {
::testing::Mock::FailUninterestingCalls(
internal::ImplicitCast_<MockClass*>(this));
}
#endif // GTEST_LANG_CXX11
~StrictMock() { // NOLINT ~StrictMock() { // NOLINT
::testing::Mock::UnregisterCallReaction( ::testing::Mock::UnregisterCallReaction(

22
googlemock/include/gmock/gmock-generated-nice-strict.h.pump
View File

@ -92,7 +92,6 @@ class $clazz : public MockClass {
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#if GTEST_LANG_CXX11
// Ideally, we would inherit base class's constructors through a using // Ideally, we would inherit base class's constructors through a using
// declaration, which would preserve their visibility. However, many existing // declaration, which would preserve their visibility. However, many existing
// tests rely on the fact that current implementation reexports protected // tests rely on the fact that current implementation reexports protected
@ -113,27 +112,6 @@ class $clazz : public MockClass {
::testing::Mock::$method( ::testing::Mock::$method(
internal::ImplicitCast_<MockClass*>(this)); internal::ImplicitCast_<MockClass*>(this));
} }
#else
// C++98 doesn't have variadic templates, so we have to define one
// for each arity.
template <typename A1>
explicit $clazz(const A1& a1) : MockClass(a1) {
::testing::Mock::$method(
internal::ImplicitCast_<MockClass*>(this));
}
$range i 2..n
$for i [[
$range j 1..i
template <$for j, [[typename A$j]]>
$clazz($for j, [[const A$j& a$j]]) : MockClass($for j, [[a$j]]) {
::testing::Mock::$method(
internal::ImplicitCast_<MockClass*>(this));
}
]]
#endif // GTEST_LANG_CXX11
~$clazz() { // NOLINT ~$clazz() { // NOLINT
::testing::Mock::UnregisterCallReaction( ::testing::Mock::UnregisterCallReaction(

63
googlemock/include/gmock/gmock-matchers.h
View File

@ -44,6 +44,7 @@
#include <math.h> #include <math.h>
#include <algorithm> #include <algorithm>
#include <initializer_list>
#include <iterator> #include <iterator>
#include <limits> #include <limits>
#include <memory> #include <memory>
@ -57,10 +58,6 @@
#include "gmock/internal/gmock-port.h" #include "gmock/internal/gmock-port.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#if GTEST_HAS_STD_INITIALIZER_LIST_
# include <initializer_list> // NOLINT -- must be after gtest.h
#endif
GTEST_DISABLE_MSC_WARNINGS_PUSH_( GTEST_DISABLE_MSC_WARNINGS_PUSH_(
4251 5046 /* class A needs to have dll-interface to be used by clients of 4251 5046 /* class A needs to have dll-interface to be used by clients of
class B */ class B */
@ -194,7 +191,6 @@ class MatcherCastImpl<T, Matcher<U> > {
// We delegate the matching logic to the source matcher. // We delegate the matching logic to the source matcher.
bool MatchAndExplain(T x, MatchResultListener* listener) const override { bool MatchAndExplain(T x, MatchResultListener* listener) const override {
#if GTEST_LANG_CXX11
using FromType = typename std::remove_cv<typename std::remove_pointer< using FromType = typename std::remove_cv<typename std::remove_pointer<
typename std::remove_reference<T>::type>::type>::type; typename std::remove_reference<T>::type>::type>::type;
using ToType = typename std::remove_cv<typename std::remove_pointer< using ToType = typename std::remove_cv<typename std::remove_pointer<
@ -208,7 +204,6 @@ class MatcherCastImpl<T, Matcher<U> > {
std::is_same<FromType, ToType>::value || std::is_same<FromType, ToType>::value ||
!std::is_base_of<FromType, ToType>::value, !std::is_base_of<FromType, ToType>::value,
"Can't implicitly convert from <base> to <derived>"); "Can't implicitly convert from <base> to <derived>");
#endif // GTEST_LANG_CXX11
return source_matcher_.MatchAndExplain(static_cast<U>(x), listener); return source_matcher_.MatchAndExplain(static_cast<U>(x), listener);
} }
@ -524,11 +519,7 @@ class IsNullMatcher {
template <typename Pointer> template <typename Pointer>
bool MatchAndExplain(const Pointer& p, bool MatchAndExplain(const Pointer& p,
MatchResultListener* /* listener */) const { MatchResultListener* /* listener */) const {
#if GTEST_LANG_CXX11
return p == nullptr; return p == nullptr;
#else // GTEST_LANG_CXX11
return GetRawPointer(p) == NULL;
#endif // GTEST_LANG_CXX11
} }
void DescribeTo(::std::ostream* os) const { *os << "is NULL"; } void DescribeTo(::std::ostream* os) const { *os << "is NULL"; }
@ -544,11 +535,7 @@ class NotNullMatcher {
template <typename Pointer> template <typename Pointer>
bool MatchAndExplain(const Pointer& p, bool MatchAndExplain(const Pointer& p,
MatchResultListener* /* listener */) const { MatchResultListener* /* listener */) const {
#if GTEST_LANG_CXX11
return p != nullptr; return p != nullptr;
#else // GTEST_LANG_CXX11
return GetRawPointer(p) != NULL;
#endif // GTEST_LANG_CXX11
} }
void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; } void DescribeTo(::std::ostream* os) const { *os << "isn't NULL"; }
@ -1845,14 +1832,8 @@ struct CallableTraits {
static void CheckIsValid(Functor /* functor */) {} static void CheckIsValid(Functor /* functor */) {}
#if GTEST_LANG_CXX11
template <typename T> template <typename T>
static auto Invoke(Functor f, T arg) -> decltype(f(arg)) { return f(arg); } static auto Invoke(Functor f, T arg) -> decltype(f(arg)) { return f(arg); }
#else
typedef typename Functor::result_type ResultType;
template <typename T>
static ResultType Invoke(Functor f, T arg) { return f(arg); }
#endif
}; };
// Specialization for function pointers. // Specialization for function pointers.
@ -1891,12 +1872,8 @@ class ResultOfMatcher {
template <typename T> template <typename T>
class Impl : public MatcherInterface<T> { class Impl : public MatcherInterface<T> {
#if GTEST_LANG_CXX11
using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>( using ResultType = decltype(CallableTraits<Callable>::template Invoke<T>(
std::declval<CallableStorageType>(), std::declval<T>())); std::declval<CallableStorageType>(), std::declval<T>()));
#else
typedef typename CallableTraits<Callable>::ResultType ResultType;
#endif
public: public:
template <typename M> template <typename M>
@ -2027,13 +2004,9 @@ class BeginEndDistanceIsMatcher {
bool MatchAndExplain(Container container, bool MatchAndExplain(Container container,
MatchResultListener* listener) const override { MatchResultListener* listener) const override {
#if GTEST_HAS_STD_BEGIN_AND_END_
using std::begin; using std::begin;
using std::end; using std::end;
DistanceType distance = std::distance(begin(container), end(container)); DistanceType distance = std::distance(begin(container), end(container));
#else
DistanceType distance = std::distance(container.begin(), container.end());
#endif
StringMatchResultListener distance_listener; StringMatchResultListener distance_listener;
const bool result = const bool result =
distance_matcher_.MatchAndExplain(distance, &distance_listener); distance_matcher_.MatchAndExplain(distance, &distance_listener);
@ -2497,7 +2470,6 @@ struct Rank1 {};
struct Rank0 : Rank1 {}; struct Rank0 : Rank1 {};
namespace pair_getters { namespace pair_getters {
#if GTEST_LANG_CXX11
using std::get; using std::get;
template <typename T> template <typename T>
auto First(T& x, Rank1) -> decltype(get<0>(x)) { // NOLINT auto First(T& x, Rank1) -> decltype(get<0>(x)) { // NOLINT
@ -2516,25 +2488,6 @@ template <typename T>
auto Second(T& x, Rank0) -> decltype((x.second)) { // NOLINT auto Second(T& x, Rank0) -> decltype((x.second)) { // NOLINT
return x.second; return x.second;
} }
#else
template <typename T>
typename T::first_type& First(T& x, Rank0) { // NOLINT
return x.first;
}
template <typename T>
const typename T::first_type& First(const T& x, Rank0) {
return x.first;
}
template <typename T>
typename T::second_type& Second(T& x, Rank0) { // NOLINT
return x.second;
}
template <typename T>
const typename T::second_type& Second(const T& x, Rank0) {
return x.second;
}
#endif // GTEST_LANG_CXX11
} // namespace pair_getters } // namespace pair_getters
// Implements Key(inner_matcher) for the given argument pair type. // Implements Key(inner_matcher) for the given argument pair type.
@ -3547,13 +3500,11 @@ ElementsAreArray(const Container& container) {
return ElementsAreArray(container.begin(), container.end()); return ElementsAreArray(container.begin(), container.end());
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
template <typename T> template <typename T>
inline internal::ElementsAreArrayMatcher<T> inline internal::ElementsAreArrayMatcher<T>
ElementsAreArray(::std::initializer_list<T> xs) { ElementsAreArray(::std::initializer_list<T> xs) {
return ElementsAreArray(xs.begin(), xs.end()); return ElementsAreArray(xs.begin(), xs.end());
} }
#endif
// UnorderedElementsAreArray(iterator_first, iterator_last) // UnorderedElementsAreArray(iterator_first, iterator_last)
// UnorderedElementsAreArray(pointer, count) // UnorderedElementsAreArray(pointer, count)
@ -3596,13 +3547,11 @@ UnorderedElementsAreArray(const Container& container) {
return UnorderedElementsAreArray(container.begin(), container.end()); return UnorderedElementsAreArray(container.begin(), container.end());
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
template <typename T> template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T> inline internal::UnorderedElementsAreArrayMatcher<T>
UnorderedElementsAreArray(::std::initializer_list<T> xs) { UnorderedElementsAreArray(::std::initializer_list<T> xs) {
return UnorderedElementsAreArray(xs.begin(), xs.end()); return UnorderedElementsAreArray(xs.begin(), xs.end());
} }
#endif
// _ is a matcher that matches anything of any type. // _ is a matcher that matches anything of any type.
// //
@ -3790,7 +3739,6 @@ Property(const std::string& property_name,
property_name, property, MatcherCast<const PropertyType&>(matcher))); property_name, property, MatcherCast<const PropertyType&>(matcher)));
} }
#if GTEST_LANG_CXX11
// The same as above but for reference-qualified member functions. // The same as above but for reference-qualified member functions.
template <typename Class, typename PropertyType, typename PropertyMatcher> template <typename Class, typename PropertyType, typename PropertyMatcher>
inline PolymorphicMatcher<internal::PropertyMatcher< inline PolymorphicMatcher<internal::PropertyMatcher<
@ -3815,7 +3763,6 @@ Property(const std::string& property_name,
PropertyType (Class::*)() const&>( PropertyType (Class::*)() const&>(
property_name, property, MatcherCast<const PropertyType&>(matcher))); property_name, property, MatcherCast<const PropertyType&>(matcher)));
} }
#endif
// Creates a matcher that matches an object iff the result of applying // Creates a matcher that matches an object iff the result of applying
// a callable to x matches 'matcher'. // a callable to x matches 'matcher'.
@ -4107,7 +4054,6 @@ Pointwise(const TupleMatcher& tuple_matcher, const Container& rhs) {
tuple_matcher, rhs); tuple_matcher, rhs);
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
// Supports the Pointwise(m, {a, b, c}) syntax. // Supports the Pointwise(m, {a, b, c}) syntax.
template <typename TupleMatcher, typename T> template <typename TupleMatcher, typename T>
@ -4116,7 +4062,6 @@ inline internal::PointwiseMatcher<TupleMatcher, std::vector<T> > Pointwise(
return Pointwise(tuple_matcher, std::vector<T>(rhs)); return Pointwise(tuple_matcher, std::vector<T>(rhs));
} }
#endif // GTEST_HAS_STD_INITIALIZER_LIST_
// UnorderedPointwise(pair_matcher, rhs) matches an STL-style // UnorderedPointwise(pair_matcher, rhs) matches an STL-style
// container or a native array that contains the same number of // container or a native array that contains the same number of
@ -4161,7 +4106,6 @@ UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
return UnorderedElementsAreArray(matchers); return UnorderedElementsAreArray(matchers);
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
// Supports the UnorderedPointwise(m, {a, b, c}) syntax. // Supports the UnorderedPointwise(m, {a, b, c}) syntax.
template <typename Tuple2Matcher, typename T> template <typename Tuple2Matcher, typename T>
@ -4172,7 +4116,6 @@ UnorderedPointwise(const Tuple2Matcher& tuple2_matcher,
return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs)); return UnorderedPointwise(tuple2_matcher, std::vector<T>(rhs));
} }
#endif // GTEST_HAS_STD_INITIALIZER_LIST_
// Matches an STL-style container or a native array that contains at // Matches an STL-style container or a native array that contains at
// least one element matching the given value or matcher. // least one element matching the given value or matcher.
@ -4252,13 +4195,11 @@ IsSupersetOf(const Container& container) {
return IsSupersetOf(container.begin(), container.end()); return IsSupersetOf(container.begin(), container.end());
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
template <typename T> template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf( inline internal::UnorderedElementsAreArrayMatcher<T> IsSupersetOf(
::std::initializer_list<T> xs) { ::std::initializer_list<T> xs) {
return IsSupersetOf(xs.begin(), xs.end()); return IsSupersetOf(xs.begin(), xs.end());
} }
#endif
// IsSubsetOf(iterator_first, iterator_last) // IsSubsetOf(iterator_first, iterator_last)
// IsSubsetOf(pointer, count) // IsSubsetOf(pointer, count)
@ -4311,13 +4252,11 @@ IsSubsetOf(const Container& container) {
return IsSubsetOf(container.begin(), container.end()); return IsSubsetOf(container.begin(), container.end());
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
template <typename T> template <typename T>
inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf( inline internal::UnorderedElementsAreArrayMatcher<T> IsSubsetOf(
::std::initializer_list<T> xs) { ::std::initializer_list<T> xs) {
return IsSubsetOf(xs.begin(), xs.end()); return IsSubsetOf(xs.begin(), xs.end());
} }
#endif
// Matches an STL-style container or a native array that contains only // Matches an STL-style container or a native array that contains only
// elements matching the given value or matcher. // elements matching the given value or matcher.

2
googlemock/include/gmock/internal/gmock-internal-utils.h
View File

@ -528,7 +528,6 @@ struct BooleanConstant {};
// reduce code size. // reduce code size.
GTEST_API_ void IllegalDoDefault(const char* file, int line); GTEST_API_ void IllegalDoDefault(const char* file, int line);
#if GTEST_LANG_CXX11
// Helper types for Apply() below. // Helper types for Apply() below.
template <size_t... Is> struct int_pack { typedef int_pack type; }; template <size_t... Is> struct int_pack { typedef int_pack type; };
@ -554,7 +553,6 @@ auto Apply(F&& f, Tuple&& args)
return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args), return ApplyImpl(std::forward<F>(f), std::forward<Tuple>(args),
make_int_pack<std::tuple_size<Tuple>::value>()); make_int_pack<std::tuple_size<Tuple>::value>());
} }
#endif
#ifdef _MSC_VER #ifdef _MSC_VER

12
googlemock/test/gmock-actions_test.cc
View File

@ -220,7 +220,6 @@ class MyNonDefaultConstructible {
int value_; int value_;
}; };
#if GTEST_LANG_CXX11
TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) { TEST(BuiltInDefaultValueTest, ExistsForDefaultConstructibleType) {
EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists()); EXPECT_TRUE(BuiltInDefaultValue<MyDefaultConstructible>::Exists());
@ -230,7 +229,6 @@ TEST(BuiltInDefaultValueTest, IsDefaultConstructedForDefaultConstructibleType) {
EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value()); EXPECT_EQ(42, BuiltInDefaultValue<MyDefaultConstructible>::Get().value());
} }
#endif // GTEST_LANG_CXX11
TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) { TEST(BuiltInDefaultValueTest, DoesNotExistForNonDefaultConstructibleType) {
EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists()); EXPECT_FALSE(BuiltInDefaultValue<MyNonDefaultConstructible>::Exists());
@ -300,7 +298,6 @@ TEST(DefaultValueDeathTest, GetReturnsBuiltInDefaultValueWhenUnset) {
}, ""); }, "");
} }
#if GTEST_HAS_STD_UNIQUE_PTR_
TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) { TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists()); EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Exists());
EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr); EXPECT_TRUE(DefaultValue<std::unique_ptr<int>>::Get() == nullptr);
@ -311,7 +308,6 @@ TEST(DefaultValueTest, GetWorksForMoveOnlyIfSet) {
std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get(); std::unique_ptr<int> i = DefaultValue<std::unique_ptr<int>>::Get();
EXPECT_EQ(42, *i); EXPECT_EQ(42, *i);
} }
#endif // GTEST_HAS_STD_UNIQUE_PTR_
// Tests that DefaultValue<void>::Get() returns void. // Tests that DefaultValue<void>::Get() returns void.
TEST(DefaultValueTest, GetWorksForVoid) { TEST(DefaultValueTest, GetWorksForVoid) {
@ -643,7 +639,6 @@ TEST(ReturnNullTest, WorksInPointerReturningFunction) {
EXPECT_TRUE(a2.Perform(std::make_tuple(true)) == nullptr); EXPECT_TRUE(a2.Perform(std::make_tuple(true)) == nullptr);
} }
#if GTEST_HAS_STD_UNIQUE_PTR_
// Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning // Tests that ReturnNull() returns NULL for shared_ptr and unique_ptr returning
// functions. // functions.
TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) { TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
@ -653,7 +648,6 @@ TEST(ReturnNullTest, WorksInSmartPointerReturningFunction) {
const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull(); const Action<std::shared_ptr<int>(std::string)> a2 = ReturnNull();
EXPECT_TRUE(a2.Perform(std::make_tuple("foo")) == nullptr); EXPECT_TRUE(a2.Perform(std::make_tuple("foo")) == nullptr);
} }
#endif // GTEST_HAS_STD_UNIQUE_PTR_
// Tests that ReturnRef(v) works for reference types. // Tests that ReturnRef(v) works for reference types.
TEST(ReturnRefTest, WorksForReference) { TEST(ReturnRefTest, WorksForReference) {
@ -706,14 +700,12 @@ class MockClass {
MOCK_METHOD1(IntFunc, int(bool flag)); // NOLINT MOCK_METHOD1(IntFunc, int(bool flag)); // NOLINT
MOCK_METHOD0(Foo, MyNonDefaultConstructible()); MOCK_METHOD0(Foo, MyNonDefaultConstructible());
#if GTEST_HAS_STD_UNIQUE_PTR_
MOCK_METHOD0(MakeUnique, std::unique_ptr<int>()); MOCK_METHOD0(MakeUnique, std::unique_ptr<int>());
MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>()); MOCK_METHOD0(MakeUniqueBase, std::unique_ptr<Base>());
MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>()); MOCK_METHOD0(MakeVectorUnique, std::vector<std::unique_ptr<int>>());
MOCK_METHOD1(TakeUnique, int(std::unique_ptr<int>)); MOCK_METHOD1(TakeUnique, int(std::unique_ptr<int>));
MOCK_METHOD2(TakeUnique, MOCK_METHOD2(TakeUnique,
int(const std::unique_ptr<int>&, std::unique_ptr<int>)); int(const std::unique_ptr<int>&, std::unique_ptr<int>));
#endif
private: private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass); GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
@ -1265,7 +1257,6 @@ TEST(ByRefTest, PrintsCorrectly) {
EXPECT_EQ(expected.str(), actual.str()); EXPECT_EQ(expected.str(), actual.str());
} }
#if GTEST_HAS_STD_UNIQUE_PTR_
std::unique_ptr<int> UniquePtrSource() { std::unique_ptr<int> UniquePtrSource() {
return std::unique_ptr<int>(new int(19)); return std::unique_ptr<int>(new int(19));
@ -1378,9 +1369,7 @@ TEST(MockMethodTest, CanTakeMoveOnlyValue) {
EXPECT_EQ(42, *saved); EXPECT_EQ(42, *saved);
} }
#endif // GTEST_HAS_STD_UNIQUE_PTR_
#if GTEST_LANG_CXX11
// Tests for std::function based action. // Tests for std::function based action.
int Add(int val, int& ref, int* ptr) { // NOLINT int Add(int val, int& ref, int* ptr) { // NOLINT
@ -1476,7 +1465,6 @@ TEST(MoveOnlyArgumentsTest, ReturningActions) {
EXPECT_EQ(x, 3); EXPECT_EQ(x, 3);
} }
#endif // GTEST_LANG_CXX11
} // Unnamed namespace } // Unnamed namespace

2
googlemock/test/gmock-function-mocker_test.cc
View File

@ -598,7 +598,6 @@ TEST(MockMethodMockFunctionTest, WorksFor10Arguments) {
EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false)); EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false));
} }
#if GTEST_HAS_STD_FUNCTION_
TEST(MockMethodMockFunctionTest, AsStdFunction) { TEST(MockMethodMockFunctionTest, AsStdFunction) {
MockFunction<int(int)> foo; MockFunction<int(int)> foo;
auto call = [](const std::function<int(int)> &f, int i) { auto call = [](const std::function<int(int)> &f, int i) {
@ -630,7 +629,6 @@ TEST(MockMethodMockFunctionTest, AsStdFunctionWithReferenceParameter) {
EXPECT_EQ(-1, call(foo.AsStdFunction(), i)); EXPECT_EQ(-1, call(foo.AsStdFunction(), i));
} }
#endif // GTEST_HAS_STD_FUNCTION_
struct MockMethodSizes0 { struct MockMethodSizes0 {
MOCK_METHOD(void, func, ()); MOCK_METHOD(void, func, ());

2
googlemock/test/gmock-generated-function-mockers_test.cc
View File

@ -582,7 +582,6 @@ TEST(MockFunctionTest, WorksFor10Arguments) {
EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false)); EXPECT_EQ(2, foo.Call(true, 'a', 0, 0, 0, 0, 0, 'b', 1, false));
} }
#if GTEST_HAS_STD_FUNCTION_
TEST(MockFunctionTest, AsStdFunction) { TEST(MockFunctionTest, AsStdFunction) {
MockFunction<int(int)> foo; MockFunction<int(int)> foo;
auto call = [](const std::function<int(int)> &f, int i) { auto call = [](const std::function<int(int)> &f, int i) {
@ -614,7 +613,6 @@ TEST(MockFunctionTest, AsStdFunctionWithReferenceParameter) {
EXPECT_EQ(-1, call(foo.AsStdFunction(), i)); EXPECT_EQ(-1, call(foo.AsStdFunction(), i));
} }
#endif // GTEST_HAS_STD_FUNCTION_
struct MockMethodSizes0 { struct MockMethodSizes0 {
MOCK_METHOD0(func, void()); MOCK_METHOD0(func, void());

4
googlemock/test/gmock-generated-matchers_test.cc
View File

@ -489,7 +489,6 @@ TEST(ElementsAreArrayTest, CanBeCreatedWithVector) {
EXPECT_THAT(test_vector, Not(ElementsAreArray(expected))); EXPECT_THAT(test_vector, Not(ElementsAreArray(expected)));
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(ElementsAreArrayTest, TakesInitializerList) { TEST(ElementsAreArrayTest, TakesInitializerList) {
const int a[5] = { 1, 2, 3, 4, 5 }; const int a[5] = { 1, 2, 3, 4, 5 };
@ -525,7 +524,6 @@ TEST(ElementsAreArrayTest,
{ Eq(1), Ne(-2), Ge(3), Le(4), Eq(6) }))); { Eq(1), Ne(-2), Ge(3), Le(4), Eq(6) })));
} }
#endif // GTEST_HAS_STD_INITIALIZER_LIST_
TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) { TEST(ElementsAreArrayTest, CanBeCreatedWithMatcherVector) {
const int a[] = { 1, 2, 3 }; const int a[] = { 1, 2, 3 };
@ -1139,7 +1137,6 @@ TEST(AnyOfTest, DoesNotCallAnyOfUnqualified) {
} // namespace adl_test } // namespace adl_test
#if GTEST_LANG_CXX11
TEST(AllOfTest, WorksOnMoveOnlyType) { TEST(AllOfTest, WorksOnMoveOnlyType) {
std::unique_ptr<int> p(new int(3)); std::unique_ptr<int> p(new int(3));
@ -1177,7 +1174,6 @@ TEST(MatcherPMacroTest, WorksOnMoveOnlyType) {
EXPECT_THAT(p, Not(UniquePointee(2))); EXPECT_THAT(p, Not(UniquePointee(2)));
} }
#endif // GTEST_LASNG_CXX11
} // namespace } // namespace

8
googlemock/test/gmock-internal-utils_test.cc
View File

@ -123,13 +123,9 @@ TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) {
} }
TEST(PointeeOfTest, WorksForSmartPointers) { TEST(PointeeOfTest, WorksForSmartPointers) {
#if GTEST_HAS_STD_UNIQUE_PTR_
CompileAssertTypesEqual<int, PointeeOf<std::unique_ptr<int> >::type>(); CompileAssertTypesEqual<int, PointeeOf<std::unique_ptr<int> >::type>();
#endif // GTEST_HAS_STD_UNIQUE_PTR_
#if GTEST_HAS_STD_SHARED_PTR_
CompileAssertTypesEqual<std::string, CompileAssertTypesEqual<std::string,
PointeeOf<std::shared_ptr<std::string> >::type>(); PointeeOf<std::shared_ptr<std::string> >::type>();
#endif // GTEST_HAS_STD_SHARED_PTR_
} }
TEST(PointeeOfTest, WorksForRawPointers) { TEST(PointeeOfTest, WorksForRawPointers) {
@ -139,16 +135,12 @@ TEST(PointeeOfTest, WorksForRawPointers) {
} }
TEST(GetRawPointerTest, WorksForSmartPointers) { TEST(GetRawPointerTest, WorksForSmartPointers) {
#if GTEST_HAS_STD_UNIQUE_PTR_
const char* const raw_p1 = new const char('a'); // NOLINT const char* const raw_p1 = new const char('a'); // NOLINT
const std::unique_ptr<const char> p1(raw_p1); const std::unique_ptr<const char> p1(raw_p1);
EXPECT_EQ(raw_p1, GetRawPointer(p1)); EXPECT_EQ(raw_p1, GetRawPointer(p1));
#endif // GTEST_HAS_STD_UNIQUE_PTR_
#if GTEST_HAS_STD_SHARED_PTR_
double* const raw_p2 = new double(2.5); // NOLINT double* const raw_p2 = new double(2.5); // NOLINT
const std::shared_ptr<double> p2(raw_p2); const std::shared_ptr<double> p2(raw_p2);
EXPECT_EQ(raw_p2, GetRawPointer(p2)); EXPECT_EQ(raw_p2, GetRawPointer(p2));
#endif // GTEST_HAS_STD_SHARED_PTR_
} }
TEST(GetRawPointerTest, WorksForRawPointers) { TEST(GetRawPointerTest, WorksForRawPointers) {

44
googlemock/test/gmock-matchers_test.cc
View File

@ -46,6 +46,7 @@
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <deque> #include <deque>
#include <forward_list>
#include <functional> #include <functional>
#include <iostream> #include <iostream>
#include <iterator> #include <iterator>
@ -56,20 +57,13 @@
#include <set> #include <set>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <type_traits>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include "gtest/gtest-spi.h" #include "gtest/gtest-spi.h"
#if GTEST_HAS_STD_FORWARD_LIST_
# include <forward_list> // NOLINT
#endif
#if GTEST_LANG_CXX11
# include <type_traits>
#endif
namespace testing { namespace testing {
namespace gmock_matchers_test { namespace gmock_matchers_test {
namespace { namespace {
@ -1189,14 +1183,12 @@ TEST(IsNullTest, MatchesNullPointer) {
#endif #endif
} }
#if GTEST_LANG_CXX11
TEST(IsNullTest, StdFunction) { TEST(IsNullTest, StdFunction) {
const Matcher<std::function<void()>> m = IsNull(); const Matcher<std::function<void()>> m = IsNull();
EXPECT_TRUE(m.Matches(std::function<void()>())); EXPECT_TRUE(m.Matches(std::function<void()>()));
EXPECT_FALSE(m.Matches([]{})); EXPECT_FALSE(m.Matches([]{}));
} }
#endif // GTEST_LANG_CXX11
// Tests that IsNull() describes itself properly. // Tests that IsNull() describes itself properly.
TEST(IsNullTest, CanDescribeSelf) { TEST(IsNullTest, CanDescribeSelf) {
@ -1237,14 +1229,12 @@ TEST(NotNullTest, ReferenceToConstLinkedPtr) {
EXPECT_TRUE(m.Matches(non_null_p)); EXPECT_TRUE(m.Matches(non_null_p));
} }
#if GTEST_LANG_CXX11
TEST(NotNullTest, StdFunction) { TEST(NotNullTest, StdFunction) {
const Matcher<std::function<void()>> m = NotNull(); const Matcher<std::function<void()>> m = NotNull();
EXPECT_TRUE(m.Matches([]{})); EXPECT_TRUE(m.Matches([]{}));
EXPECT_FALSE(m.Matches(std::function<void()>())); EXPECT_FALSE(m.Matches(std::function<void()>()));
} }
#endif // GTEST_LANG_CXX11
// Tests that NotNull() describes itself properly. // Tests that NotNull() describes itself properly.
TEST(NotNullTest, CanDescribeSelf) { TEST(NotNullTest, CanDescribeSelf) {
@ -1527,7 +1517,6 @@ TEST(KeyTest, MatchesCorrectly) {
EXPECT_THAT(p, Not(Key(Lt(25)))); EXPECT_THAT(p, Not(Key(Lt(25))));
} }
#if GTEST_LANG_CXX11
template <size_t I> template <size_t I>
struct Tag {}; struct Tag {};
@ -1554,7 +1543,6 @@ TEST(PairTest, MatchesPairWithGetCorrectly) {
std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}}; std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
EXPECT_THAT(v, Contains(Key(29))); EXPECT_THAT(v, Contains(Key(29)));
} }
#endif // GTEST_LANG_CXX11
TEST(KeyTest, SafelyCastsInnerMatcher) { TEST(KeyTest, SafelyCastsInnerMatcher) {
Matcher<int> is_positive = Gt(0); Matcher<int> is_positive = Gt(0);
@ -1699,7 +1687,6 @@ TEST(ContainsTest, WorksWithMoveOnly) {
helper.Call(MakeUniquePtrs({1, 2})); helper.Call(MakeUniquePtrs({1, 2}));
} }
#if GTEST_LANG_CXX11
TEST(PairTest, UseGetInsteadOfMembers) { TEST(PairTest, UseGetInsteadOfMembers) {
PairWithGet pair{7, "ABC"}; PairWithGet pair{7, "ABC"};
EXPECT_THAT(pair, Pair(7, "ABC")); EXPECT_THAT(pair, Pair(7, "ABC"));
@ -1709,7 +1696,6 @@ TEST(PairTest, UseGetInsteadOfMembers) {
std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}}; std::vector<PairWithGet> v = {{11, "Foo"}, {29, "gMockIsBestMock"}};
EXPECT_THAT(v, ElementsAre(Pair(11, string("Foo")), Pair(Ge(10), Not("")))); EXPECT_THAT(v, ElementsAre(Pair(11, string("Foo")), Pair(Ge(10), Not(""))));
} }
#endif // GTEST_LANG_CXX11
// Tests StartsWith(s). // Tests StartsWith(s).
@ -2680,7 +2666,6 @@ static void AnyOfMatches(int num, const Matcher<int>& m) {
EXPECT_FALSE(m.Matches(num + 1)); EXPECT_FALSE(m.Matches(num + 1));
} }
#if GTEST_LANG_CXX11
static void AnyOfStringMatches(int num, const Matcher<std::string>& m) { static void AnyOfStringMatches(int num, const Matcher<std::string>& m) {
SCOPED_TRACE(Describe(m)); SCOPED_TRACE(Describe(m));
EXPECT_FALSE(m.Matches(std::to_string(0))); EXPECT_FALSE(m.Matches(std::to_string(0)));
@ -2690,7 +2675,6 @@ static void AnyOfStringMatches(int num, const Matcher<std::string>& m) {
} }
EXPECT_FALSE(m.Matches(std::to_string(num + 1))); EXPECT_FALSE(m.Matches(std::to_string(num + 1)));
} }
#endif
// Tests that AnyOf(m1, ..., mn) matches any value that matches at // Tests that AnyOf(m1, ..., mn) matches any value that matches at
// least one of the given matchers. // least one of the given matchers.
@ -2735,7 +2719,6 @@ TEST(AnyOfTest, MatchesWhenAnyMatches) {
AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); AnyOfMatches(10, AnyOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
} }
#if GTEST_LANG_CXX11
// Tests the variadic version of the AnyOfMatcher. // Tests the variadic version of the AnyOfMatcher.
TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) { TEST(AnyOfTest, VariadicMatchesWhenAnyMatches) {
// Also make sure AnyOf is defined in the right namespace and does not depend // Also make sure AnyOf is defined in the right namespace and does not depend
@ -2784,7 +2767,6 @@ TEST(ElementsAreTest, HugeMatcherUnordered) {
Eq(3), Eq(9), Eq(12), Eq(11), Ne(122))); Eq(3), Eq(9), Eq(12), Eq(11), Ne(122)));
} }
#endif // GTEST_LANG_CXX11
// Tests that AnyOf(m1, ..., mn) describes itself properly. // Tests that AnyOf(m1, ..., mn) describes itself properly.
TEST(AnyOfTest, CanDescribeSelf) { TEST(AnyOfTest, CanDescribeSelf) {
@ -4155,9 +4137,7 @@ class AClass {
// A getter that returns a reference to const. // A getter that returns a reference to const.
const std::string& s() const { return s_; } const std::string& s() const { return s_; }
#if GTEST_LANG_CXX11
const std::string& s_ref() const & { return s_; } const std::string& s_ref() const & { return s_; }
#endif
void set_s(const std::string& new_s) { s_ = new_s; } void set_s(const std::string& new_s) { s_ = new_s; }
@ -4214,7 +4194,6 @@ TEST(PropertyTest, WorksForReferenceToConstProperty) {
EXPECT_FALSE(m_with_name.Matches(a)); EXPECT_FALSE(m_with_name.Matches(a));
} }
#if GTEST_LANG_CXX11
// Tests that Property(&Foo::property, ...) works when property() is // Tests that Property(&Foo::property, ...) works when property() is
// ref-qualified. // ref-qualified.
TEST(PropertyTest, WorksForRefQualifiedProperty) { TEST(PropertyTest, WorksForRefQualifiedProperty) {
@ -4231,7 +4210,6 @@ TEST(PropertyTest, WorksForRefQualifiedProperty) {
EXPECT_FALSE(m.Matches(a)); EXPECT_FALSE(m.Matches(a));
EXPECT_FALSE(m_with_name.Matches(a)); EXPECT_FALSE(m_with_name.Matches(a));
} }
#endif
// Tests that Property(&Foo::property, ...) works when property() // Tests that Property(&Foo::property, ...) works when property()
// returns a reference to non-const. // returns a reference to non-const.
@ -4594,7 +4572,6 @@ TEST(ResultOfTest, WorksForPolymorphicFunctors) {
EXPECT_FALSE(matcher_string.Matches("shrt")); EXPECT_FALSE(matcher_string.Matches("shrt"));
} }
#if GTEST_LANG_CXX11
TEST(ResultOfTest, WorksForPolymorphicFunctorsIgnoringResultType) { TEST(ResultOfTest, WorksForPolymorphicFunctorsIgnoringResultType) {
Matcher<int*> matcher = ResultOf(PolymorphicFunctor(), "good ptr"); Matcher<int*> matcher = ResultOf(PolymorphicFunctor(), "good ptr");
@ -4609,7 +4586,6 @@ TEST(ResultOfTest, WorksForLambdas) {
EXPECT_TRUE(matcher.Matches(3)); EXPECT_TRUE(matcher.Matches(3));
EXPECT_FALSE(matcher.Matches(1)); EXPECT_FALSE(matcher.Matches(1));
} }
#endif
const int* ReferencingFunction(const int& n) { return &n; } const int* ReferencingFunction(const int& n) { return &n; }
@ -4800,7 +4776,6 @@ TEST(IsTrueTest, IsTrueIsFalse) {
EXPECT_THAT(&a, Not(IsFalse())); EXPECT_THAT(&a, Not(IsFalse()));
EXPECT_THAT(false, Not(IsTrue())); EXPECT_THAT(false, Not(IsTrue()));
EXPECT_THAT(true, Not(IsFalse())); EXPECT_THAT(true, Not(IsFalse()));
#if GTEST_LANG_CXX11
EXPECT_THAT(std::true_type(), IsTrue()); EXPECT_THAT(std::true_type(), IsTrue());
EXPECT_THAT(std::true_type(), Not(IsFalse())); EXPECT_THAT(std::true_type(), Not(IsFalse()));
EXPECT_THAT(std::false_type(), IsFalse()); EXPECT_THAT(std::false_type(), IsFalse());
@ -4813,7 +4788,6 @@ TEST(IsTrueTest, IsTrueIsFalse) {
EXPECT_THAT(null_unique, IsFalse()); EXPECT_THAT(null_unique, IsFalse());
EXPECT_THAT(nonnull_unique, IsTrue()); EXPECT_THAT(nonnull_unique, IsTrue());
EXPECT_THAT(nonnull_unique, Not(IsFalse())); EXPECT_THAT(nonnull_unique, Not(IsFalse()));
#endif // GTEST_LANG_CXX11
} }
TEST(SizeIsTest, ImplementsSizeIs) { TEST(SizeIsTest, ImplementsSizeIs) {
@ -5313,7 +5287,6 @@ TEST(StreamlikeTest, Iteration) {
} }
} }
#if GTEST_HAS_STD_FORWARD_LIST_
TEST(BeginEndDistanceIsTest, WorksWithForwardList) { TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
std::forward_list<int> container; std::forward_list<int> container;
EXPECT_THAT(container, BeginEndDistanceIs(0)); EXPECT_THAT(container, BeginEndDistanceIs(0));
@ -5325,7 +5298,6 @@ TEST(BeginEndDistanceIsTest, WorksWithForwardList) {
EXPECT_THAT(container, Not(BeginEndDistanceIs(0))); EXPECT_THAT(container, Not(BeginEndDistanceIs(0)));
EXPECT_THAT(container, BeginEndDistanceIs(2)); EXPECT_THAT(container, BeginEndDistanceIs(2));
} }
#endif // GTEST_HAS_STD_FORWARD_LIST_
TEST(BeginEndDistanceIsTest, WorksWithNonStdList) { TEST(BeginEndDistanceIsTest, WorksWithNonStdList) {
const int a[5] = {1, 2, 3, 4, 5}; const int a[5] = {1, 2, 3, 4, 5};
@ -5507,13 +5479,11 @@ TEST(IsSupersetOfTest, MatchAndExplain) {
" - element #2 is matched by matcher #0")); " - element #2 is matched by matcher #0"));
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(IsSupersetOfTest, WorksForRhsInitializerList) { TEST(IsSupersetOfTest, WorksForRhsInitializerList) {
const int numbers[] = {1, 3, 6, 2, 4, 5}; const int numbers[] = {1, 3, 6, 2, 4, 5};
EXPECT_THAT(numbers, IsSupersetOf({1, 2})); EXPECT_THAT(numbers, IsSupersetOf({1, 2}));
EXPECT_THAT(numbers, Not(IsSupersetOf({3, 0}))); EXPECT_THAT(numbers, Not(IsSupersetOf({3, 0})));
} }
#endif
TEST(IsSupersetOfTest, WorksWithMoveOnly) { TEST(IsSupersetOfTest, WorksWithMoveOnly) {
ContainerHelper helper; ContainerHelper helper;
@ -5637,13 +5607,11 @@ TEST(IsSubsetOfTest, MatchAndExplain) {
" - element #1 is matched by matcher #2")); " - element #1 is matched by matcher #2"));
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(IsSubsetOfTest, WorksForRhsInitializerList) { TEST(IsSubsetOfTest, WorksForRhsInitializerList) {
const int numbers[] = {1, 2, 3}; const int numbers[] = {1, 2, 3};
EXPECT_THAT(numbers, IsSubsetOf({1, 2, 3, 4})); EXPECT_THAT(numbers, IsSubsetOf({1, 2, 3, 4}));
EXPECT_THAT(numbers, Not(IsSubsetOf({1, 2}))); EXPECT_THAT(numbers, Not(IsSubsetOf({1, 2})));
} }
#endif
TEST(IsSubsetOfTest, WorksWithMoveOnly) { TEST(IsSubsetOfTest, WorksWithMoveOnly) {
ContainerHelper helper; ContainerHelper helper;
@ -5762,7 +5730,6 @@ TEST(UnorderedElementsAreArrayTest, TakesStlContainer) {
EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected))); EXPECT_THAT(actual, Not(UnorderedElementsAreArray(expected)));
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(UnorderedElementsAreArrayTest, TakesInitializerList) { TEST(UnorderedElementsAreArrayTest, TakesInitializerList) {
const int a[5] = {2, 1, 4, 5, 3}; const int a[5] = {2, 1, 4, 5, 3};
@ -5796,7 +5763,6 @@ TEST(UnorderedElementsAreArrayTest,
{Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)}))); {Eq(1), Ne(-2), Ge(3), Le(4), Eq(6)})));
} }
#endif // GTEST_HAS_STD_INITIALIZER_LIST_
TEST(UnorderedElementsAreArrayTest, WorksWithMoveOnly) { TEST(UnorderedElementsAreArrayTest, WorksWithMoveOnly) {
ContainerHelper helper; ContainerHelper helper;
@ -6501,7 +6467,6 @@ TEST(PointwiseTest, WorksForVectorOfBool) {
EXPECT_THAT(lhs, Not(Pointwise(Eq(), rhs))); EXPECT_THAT(lhs, Not(Pointwise(Eq(), rhs)));
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(PointwiseTest, WorksForRhsInitializerList) { TEST(PointwiseTest, WorksForRhsInitializerList) {
const vector<int> lhs{2, 4, 6}; const vector<int> lhs{2, 4, 6};
@ -6509,7 +6474,6 @@ TEST(PointwiseTest, WorksForRhsInitializerList) {
EXPECT_THAT(lhs, Not(Pointwise(Lt(), {3, 3, 7}))); EXPECT_THAT(lhs, Not(Pointwise(Lt(), {3, 3, 7})));
} }
#endif // GTEST_HAS_STD_INITIALIZER_LIST_
TEST(PointwiseTest, RejectsWrongSize) { TEST(PointwiseTest, RejectsWrongSize) {
const double lhs[2] = {1, 2}; const double lhs[2] = {1, 2};
@ -6623,7 +6587,6 @@ TEST(UnorderedPointwiseTest, WorksForRhsNativeArray) {
EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs))); EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), rhs)));
} }
#if GTEST_HAS_STD_INITIALIZER_LIST_
TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) { TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
const vector<int> lhs{2, 4, 6}; const vector<int> lhs{2, 4, 6};
@ -6631,7 +6594,6 @@ TEST(UnorderedPointwiseTest, WorksForRhsInitializerList) {
EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), {1, 1, 7}))); EXPECT_THAT(lhs, Not(UnorderedPointwise(Lt(), {1, 1, 7})));
} }
#endif // GTEST_HAS_STD_INITIALIZER_LIST_
TEST(UnorderedPointwiseTest, RejectsWrongSize) { TEST(UnorderedPointwiseTest, RejectsWrongSize) {
const double lhs[2] = {1, 2}; const double lhs[2] = {1, 2};
@ -6824,7 +6786,6 @@ TEST(AnyWithTest, TestBadCastType) {
EXPECT_FALSE(m.Matches(SampleAnyType(1))); EXPECT_FALSE(m.Matches(SampleAnyType(1)));
} }
#if GTEST_LANG_CXX11
TEST(AnyWithTest, TestUseInContainers) { TEST(AnyWithTest, TestUseInContainers) {
std::vector<SampleAnyType> a; std::vector<SampleAnyType> a;
a.emplace_back(1); a.emplace_back(1);
@ -6841,7 +6802,6 @@ TEST(AnyWithTest, TestUseInContainers) {
AnyWith<std::string>("merhaba"), AnyWith<std::string>("merhaba"),
AnyWith<std::string>("salut")})); AnyWith<std::string>("salut")}));
} }
#endif // GTEST_LANG_CXX11
TEST(AnyWithTest, TestCompare) { TEST(AnyWithTest, TestCompare) {
EXPECT_THAT(SampleAnyType(1), AnyWith<int>(Gt(0))); EXPECT_THAT(SampleAnyType(1), AnyWith<int>(Gt(0)));
} }

27
googlemock/test/gmock-nice-strict_test.cc
View File

@ -114,23 +114,22 @@ class MockBar {
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar); GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar);
}; };
#if GTEST_GTEST_LANG_CXX11
class MockBaz { class MockBaz {
public: public:
class MoveOnly { class MoveOnly {
public:
MoveOnly() = default; MoveOnly() = default;
MoveOnly(const MoveOnly&) = delete; MoveOnly(const MoveOnly&) = delete;
operator=(const MoveOnly&) = delete; MoveOnly& operator=(const MoveOnly&) = delete;
MoveOnly(MoveOnly&&) = default; MoveOnly(MoveOnly&&) = default;
operator=(MoveOnly&&) = default; MoveOnly& operator=(MoveOnly&&) = default;
}; };
MockBaz(MoveOnly) {} MockBaz(MoveOnly) {}
} };
#endif // GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_
#if GTEST_HAS_STREAM_REDIRECTION #if GTEST_HAS_STREAM_REDIRECTION
@ -292,14 +291,10 @@ TEST(NiceMockTest, AllowLeak) {
leaked->DoThis(); leaked->DoThis();
} }
#if GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_
TEST(NiceMockTest, MoveOnlyConstructor) { TEST(NiceMockTest, MoveOnlyConstructor) {
NiceMock<MockBaz> nice_baz(MockBaz::MoveOnly()); NiceMock<MockBaz> nice_baz(MockBaz::MoveOnly{});
} }
#endif // GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE #if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
// Tests that NiceMock<Mock> compiles where Mock is a user-defined // Tests that NiceMock<Mock> compiles where Mock is a user-defined
// class (as opposed to ::testing::Mock). We had to work around an // class (as opposed to ::testing::Mock). We had to work around an
@ -407,14 +402,10 @@ TEST(NaggyMockTest, AllowLeak) {
leaked->DoThis(); leaked->DoThis();
} }
#if GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_
TEST(NaggyMockTest, MoveOnlyConstructor) { TEST(NaggyMockTest, MoveOnlyConstructor) {
NaggyMock<MockBaz> naggy_baz(MockBaz::MoveOnly()); NaggyMock<MockBaz> naggy_baz(MockBaz::MoveOnly{});
} }
#endif // GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE #if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
// Tests that NaggyMock<Mock> compiles where Mock is a user-defined // Tests that NaggyMock<Mock> compiles where Mock is a user-defined
// class (as opposed to ::testing::Mock). We had to work around an // class (as opposed to ::testing::Mock). We had to work around an
@ -503,14 +494,10 @@ TEST(StrictMockTest, AllowLeak) {
leaked->DoThis(); leaked->DoThis();
} }
#if GTEST_GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_
TEST(StrictMockTest, MoveOnlyConstructor) { TEST(StrictMockTest, MoveOnlyConstructor) {
StrictMock<MockBaz> strict_baz(MockBaz::MoveOnly()); StrictMock<MockBaz> strict_baz(MockBaz::MoveOnly{});
} }
#endif // GTEST_LANG_CXX11 && GTEST_HAS_STD_MOVE_
#if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE #if !GTEST_OS_SYMBIAN && !GTEST_OS_WINDOWS_MOBILE
// Tests that StrictMock<Mock> compiles where Mock is a user-defined // Tests that StrictMock<Mock> compiles where Mock is a user-defined
// class (as opposed to ::testing::Mock). We had to work around an // class (as opposed to ::testing::Mock). We had to work around an

121
googletest/include/gtest/internal/gtest-port.h
View File

@ -92,8 +92,6 @@
// - Define it to 1/0 to indicate whether the // - Define it to 1/0 to indicate whether the
// platform supports I/O stream redirection using // platform supports I/O stream redirection using
// dup() and dup2(). // dup() and dup2().
// GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google Test
// is building in C++11/C++98 mode.
// GTEST_LINKED_AS_SHARED_LIBRARY // GTEST_LINKED_AS_SHARED_LIBRARY
// - Define to 1 when compiling tests that use // - Define to 1 when compiling tests that use
// Google Test as a shared library (known as // Google Test as a shared library (known as
@ -332,44 +330,6 @@
GTEST_DISABLE_MSC_WARNINGS_POP_() GTEST_DISABLE_MSC_WARNINGS_POP_()
#endif #endif
#define GTEST_LANG_CXX11 1
// Distinct from C++11 language support, some environments don't provide
// proper C++11 library support. Notably, it's possible to build in
// C++11 mode when targeting Mac OS X 10.6, which has an old libstdc++
// with no C++11 support.
//
// libstdc++ has sufficient C++11 support as of GCC 4.6.0, __GLIBCXX__
// 20110325, but maintenance releases in the 4.4 and 4.5 series followed
// this date, so check for those versions by their date stamps.
// https://gcc.gnu.org/onlinedocs/libstdc++/manual/abi.html#abi.versioning
#if GTEST_LANG_CXX11 && \
(!defined(__GLIBCXX__) || ( \
__GLIBCXX__ >= 20110325ul && /* GCC >= 4.6.0 */ \
/* Blacklist of patch releases of older branches: */ \
__GLIBCXX__ != 20110416ul && /* GCC 4.4.6 */ \
__GLIBCXX__ != 20120313ul && /* GCC 4.4.7 */ \
__GLIBCXX__ != 20110428ul && /* GCC 4.5.3 */ \
__GLIBCXX__ != 20120702ul)) /* GCC 4.5.4 */
# define GTEST_STDLIB_CXX11 1
#endif
// Only use C++11 library features if the library provides them.
#if GTEST_STDLIB_CXX11
# define GTEST_HAS_STD_BEGIN_AND_END_ 1
# define GTEST_HAS_STD_FORWARD_LIST_ 1
# if !defined(_MSC_VER) || (_MSC_FULL_VER >= 190023824)
// works only with VS2015U2 and better
# define GTEST_HAS_STD_FUNCTION_ 1
# endif
# define GTEST_HAS_STD_INITIALIZER_LIST_ 1
# define GTEST_HAS_STD_MOVE_ 1
# define GTEST_HAS_STD_UNIQUE_PTR_ 1
# define GTEST_HAS_STD_SHARED_PTR_ 1
# define GTEST_HAS_UNORDERED_MAP_ 1
# define GTEST_HAS_UNORDERED_SET_ 1
#endif
// Brings in definitions for functions used in the testing::internal::posix // Brings in definitions for functions used in the testing::internal::posix
// namespace (read, write, close, chdir, isatty, stat). We do not currently // namespace (read, write, close, chdir, isatty, stat). We do not currently
// use them on Windows Mobile. // use them on Windows Mobile.
@ -712,12 +672,6 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
# define GTEST_ATTRIBUTE_UNUSED_ # define GTEST_ATTRIBUTE_UNUSED_
#endif #endif
#if GTEST_LANG_CXX11
# define GTEST_CXX11_EQUALS_DELETE_ = delete
#else // GTEST_LANG_CXX11
# define GTEST_CXX11_EQUALS_DELETE_
#endif // GTEST_LANG_CXX11
// Use this annotation before a function that takes a printf format string. // Use this annotation before a function that takes a printf format string.
#if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC) #if (defined(__GNUC__) || defined(__clang__)) && !defined(COMPILER_ICC)
# if defined(__MINGW_PRINTF_FORMAT) # if defined(__MINGW_PRINTF_FORMAT)
@ -739,12 +693,12 @@ typedef struct _RTL_CRITICAL_SECTION GTEST_CRITICAL_SECTION;
// A macro to disallow operator= // A macro to disallow operator=
// This should be used in the private: declarations for a class. // This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_ASSIGN_(type) \ #define GTEST_DISALLOW_ASSIGN_(type) \
void operator=(type const &) GTEST_CXX11_EQUALS_DELETE_ void operator=(type const &) = delete
// A macro to disallow copy constructor and operator= // A macro to disallow copy constructor and operator=
// This should be used in the private: declarations for a class. // This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \ #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
type(type const &) GTEST_CXX11_EQUALS_DELETE_; \ type(type const &) = delete; \
GTEST_DISALLOW_ASSIGN_(type) GTEST_DISALLOW_ASSIGN_(type)
// Tell the compiler to warn about unused return values for functions declared // Tell the compiler to warn about unused return values for functions declared
@ -893,75 +847,16 @@ namespace internal {
// Secret object, which is what we want. // Secret object, which is what we want.
class Secret; class Secret;
// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time // The GTEST_COMPILE_ASSERT_ is a legacy macro used to verify that a compile
// expression is true. For example, you could use it to verify the // time expression is true (in new code, use static_assert instead). For
// size of a static array: // example, you could use it to verify the size of a static array:
// //
// GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES, // GTEST_COMPILE_ASSERT_(GTEST_ARRAY_SIZE_(names) == NUM_NAMES,
// names_incorrect_size); // names_incorrect_size);
// //
// or to make sure a struct is smaller than a certain 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.
// GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large); #define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
//
// The second argument to the macro is the name of the variable. If
// the expression is false, most compilers will issue a warning/error
// containing the name of the variable.
#if GTEST_LANG_CXX11
# define GTEST_COMPILE_ASSERT_(expr, msg) static_assert(expr, #msg)
#else // !GTEST_LANG_CXX11
template <bool>
struct CompileAssert {
};
# define GTEST_COMPILE_ASSERT_(expr, msg) \
typedef ::testing::internal::CompileAssert<(static_cast<bool>(expr))> \
msg[static_cast<bool>(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_
#endif // !GTEST_LANG_CXX11
// Implementation details of GTEST_COMPILE_ASSERT_:
//
// (In C++11, we simply use static_assert instead of the following)
//
// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1
// elements (and thus is invalid) when the expression is false.
//
// - The simpler definition
//
// #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1]
//
// does not work, as gcc supports variable-length arrays whose sizes
// are determined at run-time (this is gcc's extension and not part
// of the C++ standard). As a result, gcc fails to reject the
// following code with the simple definition:
//
// int foo;
// GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is
// // not a compile-time constant.
//
// - By using the type CompileAssert<(bool(expr))>, we ensures that
// expr is a compile-time constant. (Template arguments must be
// determined at compile-time.)
//
// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written
//
// CompileAssert<bool(expr)>
//
// instead, these compilers will refuse to compile
//
// GTEST_COMPILE_ASSERT_(5 > 0, some_message);
//
// (They seem to think the ">" in "5 > 0" marks the end of the
// template argument list.)
//
// - The array size is (bool(expr) ? 1 : -1), instead of simply
//
// ((expr) ? 1 : -1).
//
// This is to avoid running into a bug in MS VC 7.1, which
// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h. // StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h.
// //

21
googletest/test/googletest-printers-test.cc
View File

@ -37,29 +37,20 @@
#include <string.h> #include <string.h>
#include <algorithm> #include <algorithm>
#include <deque> #include <deque>
#include <forward_list>
#include <list> #include <list>
#include <map> #include <map>
#include <set> #include <set>
#include <sstream> #include <sstream>
#include <string> #include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include "gtest/gtest-printers.h" #include "gtest/gtest-printers.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#if GTEST_HAS_UNORDERED_MAP_
# include <unordered_map> // NOLINT
#endif // GTEST_HAS_UNORDERED_MAP_
#if GTEST_HAS_UNORDERED_SET_
# include <unordered_set> // NOLINT
#endif // GTEST_HAS_UNORDERED_SET_
#if GTEST_HAS_STD_FORWARD_LIST_
# include <forward_list> // NOLINT
#endif // GTEST_HAS_STD_FORWARD_LIST_
// Some user-defined types for testing the universal value printer. // Some user-defined types for testing the universal value printer.
// An anonymous enum type. // An anonymous enum type.
@ -814,7 +805,6 @@ TEST(PrintStlContainerTest, NonEmptyDeque) {
EXPECT_EQ("{ 1, 3 }", Print(non_empty)); EXPECT_EQ("{ 1, 3 }", Print(non_empty));
} }
#if GTEST_HAS_UNORDERED_MAP_
TEST(PrintStlContainerTest, OneElementHashMap) { TEST(PrintStlContainerTest, OneElementHashMap) {
::std::unordered_map<int, char> map1; ::std::unordered_map<int, char> map1;
@ -834,9 +824,7 @@ TEST(PrintStlContainerTest, HashMultiMap) {
<< " where Print(map1) returns \"" << result << "\"."; << " where Print(map1) returns \"" << result << "\".";
} }
#endif // GTEST_HAS_UNORDERED_MAP_
#if GTEST_HAS_UNORDERED_SET_
TEST(PrintStlContainerTest, HashSet) { TEST(PrintStlContainerTest, HashSet) {
::std::unordered_set<int> set1; ::std::unordered_set<int> set1;
@ -873,7 +861,6 @@ TEST(PrintStlContainerTest, HashMultiSet) {
EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin())); EXPECT_TRUE(std::equal(a, a + kSize, numbers.begin()));
} }
#endif // GTEST_HAS_UNORDERED_SET_
TEST(PrintStlContainerTest, List) { TEST(PrintStlContainerTest, List) {
const std::string a[] = {"hello", "world"}; const std::string a[] = {"hello", "world"};
@ -915,14 +902,12 @@ TEST(PrintStlContainerTest, MultiSet) {
EXPECT_EQ("{ 1, 1, 1, 2, 5 }", Print(set1)); EXPECT_EQ("{ 1, 1, 1, 2, 5 }", Print(set1));
} }
#if GTEST_HAS_STD_FORWARD_LIST_
TEST(PrintStlContainerTest, SinglyLinkedList) { TEST(PrintStlContainerTest, SinglyLinkedList) {
int a[] = { 9, 2, 8 }; int a[] = { 9, 2, 8 };
const std::forward_list<int> ints(a, a + 3); const std::forward_list<int> ints(a, a + 3);
EXPECT_EQ("{ 9, 2, 8 }", Print(ints)); EXPECT_EQ("{ 9, 2, 8 }", Print(ints));
} }
#endif // GTEST_HAS_STD_FORWARD_LIST_
TEST(PrintStlContainerTest, Pair) { TEST(PrintStlContainerTest, Pair) {
pair<const bool, int> p(true, 5); pair<const bool, int> p(true, 5);