Skip to content

GitLab

Commit 997c36c1 authored by Abseil Team's avatar Abseil Team Committed by CJ Johnson
Browse files

Googletest export 

Stop using pump for generating internal/custom/gmock-generated-actions.h

PiperOrigin-RevId: 352660735
parent 4898cdac
Hide whitespace changes
Inline Side-by-side
Showing with 1 addition and 560 deletions
googlemock/include/gmock/internal/custom/gmock-generated-actions.h
View file @ 997c36c1
// GOOGLETEST_CM0002 DO NOT DELETE
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
#include "gmock/internal/gmock-port.h"
#if GTEST_GOOGLE3_MODE_
#include <memory>
#include <type_traits>
#include "base/callback.h"
#include "gmock/gmock-actions.h"
namespace testing {
namespace internal {
// Implements the Invoke(callback) action.
template <typename CallbackType, typename Signature>
class InvokeCallbackAction;
template <typename CallbackType, typename R, typename... Args>
class InvokeCallbackAction<CallbackType, R(Args...)> {
public:
// The c'tor takes ownership of the callback.
explicit InvokeCallbackAction(CallbackType* callback) : callback_(callback) {
callback->CheckIsRepeatable(); // Makes sure the callback is permanent.
}
R operator()(Args... args) const {
return callback_->Run(std::forward<Args>(args)...);
}
private:
const std::shared_ptr<CallbackType> callback_;
};
// Implements the InvokeWithoutArgs(callback) action.
template <typename CallbackType>
class InvokeCallbackWithoutArgsAction {
const std::shared_ptr<CallbackType> callback_;
public:
// The c'tor takes ownership of the callback.
explicit InvokeCallbackWithoutArgsAction(CallbackType* callback)
: callback_(callback) {
callback->CheckIsRepeatable(); // Makes sure the callback is permanent.
}
template <typename... Args>
auto operator()(const Args&...) -> decltype(this->callback_->Run()) {
return callback_->Run();
}
};
template <typename T>
struct TypeIdentity {
using type = T;
};
inline TypeIdentity<void()> CallbackSignatureImpl(Closure*);
template <typename R>
TypeIdentity<R()> CallbackSignatureImpl(ResultCallback<R>*);
template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback1<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback1<R, Args...>*);
template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback2<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback2<R, Args...>*);
template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback3<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback3<R, Args...>*);
template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback4<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback4<R, Args...>*);
template <typename... Args>
TypeIdentity<void(Args...)> CallbackSignatureImpl(Callback5<Args...>*);
template <typename R, typename... Args>
TypeIdentity<R(Args...)> CallbackSignatureImpl(ResultCallback5<R, Args...>*);
template <typename T>
using CallbackSignature = typename decltype(
internal::CallbackSignatureImpl(std::declval<T*>()))::type;
// Specialization for protocol buffers.
// We support setting a proto2::Message, which doesn't have an assignment
// operator.
template <size_t N, typename A>
struct SetArgumentPointeeAction<
N, A,
typename std::enable_if<std::is_base_of<proto2::Message, A>::value>::type> {
A value;
template <typename... Args>
void operator()(const Args&... args) const {
::std::get<N>(std::tie(args...))->CopyFrom(value);
}
};
// Add Invoke overloads for google3 Callback types.
template <typename C, typename... Args,
typename = internal::CallbackSignature<C>>
auto InvokeArgument(C* cb, Args... args) -> decltype(cb->Run(args...)) {
return cb->Run(args...);
}
} // namespace internal
// Add Invoke overloads for google3 Callback types.
// Creates an action that invokes the given callback with the mock
// function's arguments. The action takes ownership of the callback
// and verifies that it's permanent.
//
// google3 doesn't support callbacks with more than 5
// arguments yet, so we only support invoking callbacks with up to
// 5 arguments.
template <typename Callback>
internal::InvokeCallbackAction<Callback, internal::CallbackSignature<Callback>>
Invoke(Callback* callback) {
return internal::InvokeCallbackAction<Callback,
internal::CallbackSignature<Callback>>(
callback);
}
// Creates an action that invokes the given callback with no argument.
// The action takes ownership of the callback and verifies that it's
// permanent.
template <typename Callback, typename = internal::CallbackSignature<Callback>>
internal::InvokeCallbackWithoutArgsAction<Callback> InvokeWithoutArgs(
Callback* callback) {
return internal::InvokeCallbackWithoutArgsAction<Callback>(callback);
}
} // namespace testing
#endif // GTEST_GOOGLE3_MODE_
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump deleted 100644 → 0
View file @ 4898cdac
$$ -*- mode: c++; -*-
$$ This is a Pump source file. Please use Pump to convert
$$ it to callback-actions.h.
$$
$var max_callback_arity = 5
$$}} This meta comment fixes auto-indentation in editors.
// GOOGLETEST_CM0002 DO NOT DELETE
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_
googlemock/include/gmock/internal/custom/gmock-matchers.h
View file @ 997c36c1
......@@ -33,39 +33,4 @@
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
#include <memory>
#include "gmock/internal/gmock-port.h"
#if GTEST_GOOGLE3_MODE_
#include "base/callback.h"
// Realistically this file should be included from gmock-matchers.h
#include "gmock/gmock-matchers.h"
namespace testing {
namespace internal {
// Specialization for permanent callbacks.
template <typename ArgType, typename ResType>
struct CallableTraits<ResultCallback1<ResType, ArgType>*> {
typedef ResType ResultType;
using StorageType = std::shared_ptr<ResultCallback1<ResType, ArgType>>;
typedef ResultCallback1<ResType, ArgType> Callback;
static void CheckIsValid(const StorageType& callback) {
GTEST_CHECK_(callback != nullptr)
<< "NULL callback is passed into ResultOf().";
callback->CheckIsRepeatable();
}
template <typename T>
static ResType Invoke(const StorageType& callback, T arg) {
return callback->Run(arg);
}
};
} // namespace internal
} // namespace testing
#endif // GTEST_GOOGLE3_MODE_
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_
googlemock/include/gmock/internal/custom/gmock-port.h
View file @ 997c36c1
......@@ -36,29 +36,4 @@
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
#include "gtest/internal/gtest-port.h"
#if GTEST_GOOGLE3_MODE_
// Defines this iff Google Mock can use google3 callbacks. This is
// internal as a user shouldn't rely on Google Mock to tell him
// whether he can use google3 callbacks.
# include "base/callback.h"
# define GMOCK_HAS_GOOGLE3_CALLBACK_ 1
// Macros for declaring flags.
# define GMOCK_DECLARE_bool_(name) DECLARE_bool(gmock_##name)
# define GMOCK_DECLARE_int32_(name) DECLARE_int32(gmock_##name)
# define GMOCK_DECLARE_string_(name) DECLARE_string(gmock_##name)
// Macros for defining flags.
# define GMOCK_DEFINE_bool_(name, default_val, doc) \
DEFINE_bool(gmock_##name, default_val, doc)
# define GMOCK_DEFINE_int32_(name, default_val, doc) \
DEFINE_int32(gmock_##name, default_val, doc)
# define GMOCK_DEFINE_string_(name, default_val, doc) \
DEFINE_string(gmock_##name, default_val, doc)
#endif // GTEST_GOOGLE3_MODE_
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
googletest/include/gtest/internal/custom/gtest-port.h
View file @ 997c36c1
......@@ -33,170 +33,5 @@
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
#include "gtest/internal/gtest-port-arch.h"
#include <string>
// NOTE:
// GUNIT_NO_GOOGLE3 - Only used when compiled on Linux. Define it
// to remove dependency on google3 - some features
// are unavailable in this mode.
#define GTEST_FOR_GOOGLE_ 1 // Defined to 1 iff compiled inside Google.
// We define these even in non-google3 mode.
#define GTEST_FLAG(name) FLAGS_gunit_##name
#define GTEST_DEV_EMAIL_ "opensource-gtest@@google.com"
#define GTEST_FLAG_PREFIX_ "gunit_"
#define GTEST_FLAG_PREFIX_DASH_ "gunit-"
#define GTEST_FLAG_PREFIX_UPPER_ "GUNIT_"
#define GTEST_NAME_ "Google Test"
#define GTEST_PROJECT_URL_ "http://go/gunit/"
#define GTEST_DEFAULT_DEATH_TEST_STYLE "threadsafe"
// OS_MACOSX is defined by Blaze, when cross-compiling (on Linux) to
// Mac OS X.
// See also testing/base/public/BUILD for notes about GTEST_INTERNAL_PG3_MODE.
#if !defined(GUNIT_NO_GOOGLE3) && (GTEST_OS_CYGWIN || GTEST_OS_LINUX || \
defined(OS_MACOSX))
# define GTEST_GOOGLE3_MODE_ 1
#endif
#if GTEST_GOOGLE3_MODE_
#define GTEST_HAS_ABSL 1
#define GTEST_INIT_GOOGLE_TEST_NAME_ "InitGoogle"
// Tell Google Test that hash_map/hash_set are available.
// Only used for testing.
#define GTEST_HAS_HASH_MAP_ 1
#define GTEST_HAS_HASH_SET_ 1
// base/commandlineoptions.h has its own --flagfile flag.
# define GTEST_USE_OWN_FLAGFILE_FLAG_ 0
// base/commandlineflags.h provides its own GetArgvs()
# define GTEST_CUSTOM_GET_ARGVS_() ::GetArgvs()
#include "base/callback.h"
#include "base/logging_extensions.h"
#include "base/synchronization.h"
#include "thread/thread.h"
// Provide the PCRE regex library.
#include "util/regexp/re2/re2.h"
# define GTEST_USES_PCRE 1
namespace testing {
namespace internal {
// This is almost 'using RE = ::RE2', except that it disambiguates
// RE::RE(std::string). It cannot be merged into the RE implementation below,
// since this version will support embedded NUL characters.
class RE {
public:
RE(absl::string_view regex) : regex_(new RE2(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()) {}
// Returns the string representation of the regex.
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:
std::unique_ptr<RE2> regex_;
};
} // namespace internal
} // namespace testing
// For flags.
# include "base/commandlineflags.h"
#define GTEST_FLAG_SAVER_ absl::FlagSaver
// Macros for declaring flags.
# define GTEST_DECLARE_bool_(name) DECLARE_bool(gunit_##name)
# define GTEST_DECLARE_int32_(name) DECLARE_int32(gunit_##name)
# define GTEST_DECLARE_string_(name) DECLARE_string(gunit_##name)
// Macros for defining flags.
# define GTEST_DEFINE_bool_(name, default_val, doc) \
DEFINE_bool(gunit_##name, default_val, doc)
# define GTEST_DEFINE_int32_(name, default_val, doc) \
DEFINE_int32(gunit_##name, default_val, doc)
# define GTEST_DEFINE_string_(name, default_val, doc) \
DEFINE_string(gunit_##name, default_val, doc)
# define GTEST_GET_BOOL_FROM_ENV_(flag, default_val) \
::BoolFromEnv(FlagToEnvVar(flag).c_str(), default_val)
# define GTEST_GET_INT32_FROM_ENV_(flag, default_val) \
::Int32FromEnv(FlagToEnvVar(flag).c_str(), default_val)
# define GTEST_GET_STRING_FROM_ENV_(flag, default_val) \
::StringFromEnv(FlagToEnvVar(flag).c_str(), default_val)
// For logging.
# include "third_party/absl/base/log_severity.h"
# include "base/logging.h"
# define GTEST_LOG_(severity) LOG(severity)
namespace testing {
namespace internal {
using ::LogToStderr;
inline void FlushInfoLog() { FlushLogFiles(base_logging::INFO); }
} // namespace internal
} // namespace testing
# define GTEST_CHECK_(condition) CHECK(condition)
// For CheckedDowncastToActualType
# include "base/casts.h"
# define GTEST_HAS_DOWNCAST_ 1
# define GTEST_HAS_NOTIFICATION_ 1
#include "absl/synchronization/notification.h"
namespace testing {
namespace internal {
using ::absl::Notification;
} // namespace internal
} // namespace testing
# define GTEST_HAS_MUTEX_AND_THREAD_LOCAL_ 1
# include "base/mutex.h"
# include "thread/threadlocal.h"
namespace testing {
namespace internal {
using absl::Mutex;
using absl::MutexLock;
using ::ThreadLocal;
// Forward-declares a static mutex.
# define GTEST_DECLARE_STATIC_MUTEX_(mutex) extern absl::Mutex mutex
// Defines and statically initializes a static mutex.
# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \
absl::Mutex mutex(absl::kConstInit)
} // namespace internal
} // namespace testing
// For thread annotations.
# include "third_party/absl/base/thread_annotations.h"
# define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) \
ABSL_EXCLUSIVE_LOCKS_REQUIRED(locks)
# define GTEST_LOCK_EXCLUDED_(locks) ABSL_LOCKS_EXCLUDED(locks)
#endif // GTEST_GOOGLE3_MODE_
// Pre-r11 Android NDK releases for x86 and x86_64 do not have abi libraries.
# if GTEST_OS_LINUX_ANDROID && (defined(__i386__) || defined(__x86_64__))
# define GTEST_HAS_CXXABI_H_ 0
# endif
#endif // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PORT_H_
googletest/include/gtest/internal/custom/gtest-printers.h
View file @ 997c36c1
......@@ -38,83 +38,5 @@
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
// absl:google3-begin(Custom Implementation)
#include "gtest/gtest-printers.h"
#if GTEST_GOOGLE3_MODE_
#include "absl/status/statusor.h"
#include "absl/strings/cord.h"
#include "util/task/codes.pb.h"
#include "util/task/codes.proto.h"
#include "util/task/status.h"
namespace testing {
namespace internal {
// Specializations for types related to util::Status. We define these
// printers here to avoid widening the //util/task API.
template <>
class UniversalPrinter< ::util::ErrorSpace> {
public:
static void Print(const ::util::ErrorSpace& space, ::std::ostream* os) {
*os << space.SpaceName();
}
};
template <>
class UniversalPrinter< ::util::error::Code> {
public:
static void Print(::util::error::Code code, ::std::ostream* os) {
if (::util::error::Code_IsValid(code)) {
*os << ::util::error::Code_Name(code);
} else {
*os << static_cast<int>(code);
}
}
};
template <typename T>
class UniversalPrinter<absl::StatusOr<T> > {
public:
static void Print(const absl::StatusOr<T>& status_or, ::std::ostream* os) {
*os << status_or.status();
if (status_or.ok()) {
*os << ": ";
UniversalPrint(status_or.value(), os);
}
}
};
class FormatForComparisonAsStringImpl {
public:
static ::std::string Format(const char* value) {
return ::testing::PrintToString(value);
}
};
// If a C string is compared with a absl::string_view or Cord, we know it's
// meant to point to a NUL-terminated string, and thus can print it as a string.
template <>
class FormatForComparison<char*, absl::string_view>
: public FormatForComparisonAsStringImpl {};
template <>
class FormatForComparison<const char*, absl::string_view>
: public FormatForComparisonAsStringImpl {};
template <>
class FormatForComparison<char*, absl::Cord>
: public FormatForComparisonAsStringImpl {};
template <>
class FormatForComparison<const char*, absl::Cord>
: public FormatForComparisonAsStringImpl {};
} // namespace internal
} // namespace testing
#endif // GTEST_GOOGLE3_MODE_
// absl:google3-end
#endif // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_
googletest/include/gtest/internal/custom/gtest.h
View file @ 997c36c1
......@@ -34,105 +34,4 @@
#ifndef GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
#define GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
#include "gtest/gtest.h"
#include "third_party/googletest/googletest/src/gtest-internal-inl.h"
#if GTEST_GOOGLE3_MODE_
#define GTEST_REMOVE_LEGACY_TEST_CASEAPI_ 1
#include <string>
#include <vector>
namespace testing {
namespace internal {
// In google3 we use ::InitGoogle instead.
#define GTEST_CUSTOM_INIT_GOOGLE_TEST_FUNCTION_ \
::testing::internal::InitGoogleTestForGoogle3
void InitGoogleTestForGoogle3(int* argc, char** argv);
void InitGoogleTestForGoogle3(int* argc, wchar_t** argv);
#define GTEST_OS_STACK_TRACE_GETTER_ \
::testing::internal::Google3OsStackTraceGetter
// Google3 implementation of the stack trace getter.
class Google3OsStackTraceGetter : public OsStackTraceGetterInterface {
public:
Google3OsStackTraceGetter() : caller_frame_(nullptr) {}
std::string CurrentStackTrace(int max_depth, int skip_count) override
GTEST_LOCK_EXCLUDED_(mutex_);
void UponLeavingGTest() override GTEST_LOCK_EXCLUDED_(mutex_);
private:
Mutex mutex_; // protects all internal state
// We save the stack frame below the frame that calls user code.
// We do this because the address of the frame immediately below
// the user code changes between the call to UponLeavingGTest()
// and any calls to CurrentStackTrace() from within the user code.
void* caller_frame_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(Google3OsStackTraceGetter);
};
#define GTEST_CUSTOM_TEST_EVENT_LISTENER_ \
::testing::internal::GoogleProcessStateListener
// Report process state changes to Google3 base, after the unit test
// has been initialized, and before it is torn down, as well as at
// the start and end of each test case and test.
class GoogleProcessStateListener : public EmptyTestEventListener {
public:
GoogleProcessStateListener() {}
~GoogleProcessStateListener() override;
void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) override;
void OnEnvironmentsTearDownStart(const UnitTest& unit_test) override;
void OnTestSuiteStart(const TestSuite& test_case) override;
void OnTestSuiteEnd(const TestSuite& test_case) override;
void OnTestStart(const TestInfo& test_info) override;
void OnTestEnd(const TestInfo& test_info) override;
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(GoogleProcessStateListener);
}; // class GoogleProcessStateListener
// For KilledBySignal.
bool KilledBySignalOverride(int signum, int exit_status, bool* result);
#define GTEST_KILLED_BY_SIGNAL_OVERRIDE_ \
::testing::internal::KilledBySignalOverride
// Override --debugger_command (if any) with an empty one:
// we don't want the child to have a debugger automagically attaching
// to it when it (expectedly) dies.
// Also, enable --logtostderr.
::std::vector<std::string> GetGoogle3DeathTestCommandLineArgs();
#define GTEST_EXTRA_DEATH_TEST_COMMAND_LINE_ARGS_() \
::testing::internal::GetGoogle3DeathTestCommandLineArgs()
// For b/11021341, disable (slow) AddressToLineNumberDecorator.
void Google3DeathTestChildSetup();
#define GTEST_EXTRA_DEATH_TEST_CHILD_SETUP_() \
::testing::internal::Google3DeathTestChildSetup()
// returns temp directory for test in Google3 manner
std::string GetGoogle3TestTempDir();
// In google3 we use ::testing:GetTestTmpdir() instead.
#define GTEST_CUSTOM_TEMPDIR_FUNCTION_ \
::testing::internal::GetGoogle3TestTempDir
} // namespace internal
} // namespace testing
#endif // GTEST_GOOGLE3_MODE_
#endif // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_H_
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment