diff --git a/googletest/CONTRIBUTORS b/CONTRIBUTORS similarity index 64% rename from googletest/CONTRIBUTORS rename to CONTRIBUTORS index 1e4afe21..76db0b40 100644 --- a/googletest/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -5,34 +5,59 @@ Ajay Joshi Balázs Dán +Benoit Sigoure Bharat Mediratta +Bogdan Piloca Chandler Carruth Chris Prince Chris Taylor Dan Egnor +Dave MacLachlan +David Anderson +Dean Sturtevant Eric Roman +Gene Volovich Hady Zalek +Hal Burch Jeffrey Yasskin +Jim Keller +Joe Walnes +Jon Wray Jói Sigurðsson Keir Mierle Keith Ray Kenton Varda +Kostya Serebryany Krystian Kuzniarek +Lev Makhlis Manuel Klimek +Mario Tanev +Mark Paskin Markus Heule +Matthew Simmons Mika Raento +Mike Bland Miklós Fazekas +Neal Norwitz +Nermin Ozkiranartli +Owen Carlsen +Paneendra Ba Pasi Valminen Patrick Hanna Patrick Riley +Paul Menage Peter Kaminski +Piotr Kaminski Preston Jackson Rainer Klaffenboeck Russ Cox Russ Rufer Sean Mcafee Sigurður Ásgeirsson +Sverre Sundsdal +Takeshi Yoshino Tracy Bialik Vadim Berman Vlad Losev +Wolfgang Klier Zhanyong Wan diff --git a/docs/advanced.md b/docs/advanced.md index 4b6ba0e2..95b60d22 100644 --- a/docs/advanced.md +++ b/docs/advanced.md @@ -1,8 +1,8 @@ # Advanced googletest Topics - +go/gunitadvanced - +[TOC] ## Introduction diff --git a/docs/faq.md b/docs/faq.md index d91bd4d0..4c9f2a2a 100644 --- a/docs/faq.md +++ b/docs/faq.md @@ -1,8 +1,8 @@ # Googletest FAQ - +go/gunitfaq - +[TOC] ## Why should test suite names and test names not contain underscore? @@ -350,7 +350,7 @@ You may still want to use `SetUp()/TearDown()` in the following cases: * In the body of a constructor (or destructor), it's not possible to use the `ASSERT_xx` macros. Therefore, if the set-up operation could cause a fatal test failure that should prevent the test from running, it's necessary to - use `abort` and abort the whole test executable, + use `abort` (in google3, use `CHECK`) and abort the whole test executable, or to use `SetUp()` instead of a constructor. * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads diff --git a/docs/gmock_cheat_sheet.md b/docs/gmock_cheat_sheet.md index 0251efcf..63d38da4 100644 --- a/docs/gmock_cheat_sheet.md +++ b/docs/gmock_cheat_sheet.md @@ -1,10 +1,10 @@ # gMock Cheat Sheet - +go/gmockcheat - +[TOC] - + ## Defining a Mock Class @@ -229,7 +229,7 @@ and the default action will be taken each time. ## Matchers {#MatcherList} - +go/matchers A **matcher** matches a *single* argument. You can use it inside `ON_CALL()` or `EXPECT_CALL()`, or use it to validate a value directly using two macros: @@ -424,9 +424,9 @@ messages, you can use: | `WhenDynamicCastTo(m)` | when `argument` is passed through `dynamic_cast()`, it matches matcher `m`. | - + - + ### Multi-argument Matchers {#MultiArgMatchers} @@ -467,7 +467,7 @@ You can make a matcher from one or more other matchers: | `Not(m)` | `argument` doesn't match matcher `m`. | - + ### Adapters for Matchers @@ -612,7 +612,7 @@ value, and `foo` by reference. **Note:** due to technical reasons, `DoDefault()` cannot be used inside a composite action - trying to do so will result in a run-time error. - + ### Composite Actions diff --git a/docs/gmock_cook_book.md b/docs/gmock_cook_book.md index d9e825cc..febab24b 100644 --- a/docs/gmock_cook_book.md +++ b/docs/gmock_cook_book.md @@ -1,6 +1,6 @@ # gMock Cookbook - +go/gmockcook You can find recipes for using gMock here. If you haven't yet, please read [the dummy guide](gmock_for_dummies.md) first to make sure you understand the @@ -11,7 +11,7 @@ recommended to write `using ::testing::Foo;` once in your file before using the name `Foo` defined by gMock. We omit such `using` statements in this section for brevity, but you should do it in your own code. - +[TOC] ## Creating Mock Classes @@ -184,7 +184,7 @@ class MockStack : public StackInterface { ### Mocking Non-virtual Methods {#MockingNonVirtualMethods} gMock can mock non-virtual functions to be used in Hi-perf dependency -injection. +injection.[See this](http://go/tott/33) In this case, instead of sharing a common base class with the real class, your mock class will be *unrelated* to the real class, but contain methods with the @@ -830,7 +830,7 @@ A frequently used matcher is `_`, which matches anything: ```cpp EXPECT_CALL(foo, DoThat(_, NotNull())); ``` - + ### Combining Matchers {#CombiningMatchers} @@ -1161,7 +1161,7 @@ Note that the predicate function / functor doesn't have to return `bool`. It works as long as the return value can be used as the condition in in statement `if (condition) ...`. - + ### Matching Arguments that Are Not Copyable @@ -1478,7 +1478,7 @@ mock object and gMock. ### Knowing When to Expect {#UseOnCall} - +(go/use-on-call) **`ON_CALL`** is likely the *single most under-utilized construct* in gMock. @@ -2171,7 +2171,7 @@ own precedence order distinct from the `ON_CALL` precedence order. If the built-in actions don't suit you, you can use an existing callable (function, `std::function`, method, functor, lambda) as an action. - + ```cpp using ::testing::_; using ::testing::Invoke; @@ -3266,7 +3266,7 @@ If you are interested in the mock call trace but not the stack traces, you can combine `--gmock_verbose=info` with `--gtest_stack_trace_depth=0` on the test command line. - + ### Running Tests in Emacs @@ -4313,4 +4313,4 @@ Although `std::function` supports unlimited number of arguments, `MockFunction` implementation is limited to ten. If you ever hit that limit... well, your callback has bigger problems than being mockable. :-) - + diff --git a/docs/gmock_faq.md b/docs/gmock_faq.md index dc4a11da..0d879b27 100644 --- a/docs/gmock_faq.md +++ b/docs/gmock_faq.md @@ -1,8 +1,8 @@ ## Legacy gMock FAQ {#GMockFaq} - +go/gmockfaq - +[TOC] ### When I call a method on my mock object, the method for the real object is invoked instead. What's the problem? @@ -83,7 +83,7 @@ void Bar(int* p); // Neither p nor *p is const. void Bar(const int* p); // p is not const, but *p is. ``` - + ### I can't figure out why gMock thinks my expectations are not satisfied. What should I do? @@ -128,7 +128,7 @@ using ::testing::_; .Times(0); ``` - + ### I have a failed test where gMock tells me TWICE that a particular expectation is not satisfied. Isn't this redundant? diff --git a/docs/gmock_for_dummies.md b/docs/gmock_for_dummies.md index 56769108..37a5c134 100644 --- a/docs/gmock_for_dummies.md +++ b/docs/gmock_for_dummies.md @@ -1,8 +1,8 @@ # gMock for Dummies {#GMockForDummies} - +go/gmockfordummies - +[TOC] ## What Is gMock? @@ -208,7 +208,7 @@ choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does. - + ## Using Mocks in Tests diff --git a/docs/pkgconfig.md b/docs/pkgconfig.md index aed4ad45..7c3a2979 100644 --- a/docs/pkgconfig.md +++ b/docs/pkgconfig.md @@ -1,6 +1,6 @@ ## Using GoogleTest from various build systems - +[TOC] GoogleTest comes with pkg-config files that can be used to determine all necessary flags for compiling and linking to GoogleTest (and GoogleMock). diff --git a/docs/primer.md b/docs/primer.md index 28c16916..4c17fc78 100644 --- a/docs/primer.md +++ b/docs/primer.md @@ -1,8 +1,8 @@ # Googletest Primer - +go/gunitprimer - +[TOC] ## Introduction: Why googletest? diff --git a/docs/pump_manual.md b/docs/pump_manual.md index 9dbe15bb..bef498d3 100644 --- a/docs/pump_manual.md +++ b/docs/pump_manual.md @@ -1,6 +1,6 @@ Pump is Useful for Meta Programming. - +[TOC] # The Problem diff --git a/googlemock/CONTRIBUTORS b/googlemock/CONTRIBUTORS deleted file mode 100644 index 6e9ae362..00000000 --- a/googlemock/CONTRIBUTORS +++ /dev/null @@ -1,40 +0,0 @@ -# This file contains a list of people who've made non-trivial -# contribution to the Google C++ Mocking Framework project. People -# who commit code to the project are encouraged to add their names -# here. Please keep the list sorted by first names. - -Benoit Sigoure -Bogdan Piloca -Chandler Carruth -Dave MacLachlan -David Anderson -Dean Sturtevant -Gene Volovich -Hal Burch -Jeffrey Yasskin -Jim Keller -Joe Walnes -Jon Wray -Keir Mierle -Keith Ray -Kostya Serebryany -Lev Makhlis -Manuel Klimek -Mario Tanev -Mark Paskin -Markus Heule -Matthew Simmons -Mike Bland -Neal Norwitz -Nermin Ozkiranartli -Owen Carlsen -Paneendra Ba -Paul Menage -Piotr Kaminski -Russ Rufer -Sverre Sundsdal -Takeshi Yoshino -Vadim Berman -Vlad Losev -Wolfgang Klier -Zhanyong Wan diff --git a/googlemock/LICENSE b/googlemock/LICENSE deleted file mode 100644 index 1941a11f..00000000 --- a/googlemock/LICENSE +++ /dev/null @@ -1,28 +0,0 @@ -Copyright 2008, Google Inc. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/googlemock/include/gmock/gmock-generated-actions.h.pump b/googlemock/include/gmock/gmock-generated-actions.h.pump index 982caf9c..7ede66e1 100644 --- a/googlemock/include/gmock/gmock-generated-actions.h.pump +++ b/googlemock/include/gmock/gmock-generated-actions.h.pump @@ -40,8 +40,8 @@ $$}} This meta comment fixes auto-indentation in editors. // GOOGLETEST_CM0002 DO NOT DELETE -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ +#ifndef THIRD_PARTY_GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ +#define THIRD_PARTY_GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ #include #include @@ -387,4 +387,4 @@ InvokeArgument(Params&&... params) { } // namespace testing -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ +#endif // THIRD_PARTY_GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ diff --git a/googlemock/include/gmock/internal/custom/gmock-generated-actions.h b/googlemock/include/gmock/internal/custom/gmock-generated-actions.h index 92d910cf..c655fd01 100644 --- a/googlemock/include/gmock/internal/custom/gmock-generated-actions.h +++ b/googlemock/include/gmock/internal/custom/gmock-generated-actions.h @@ -1,10 +1,149 @@ -// This file was GENERATED by command: -// pump.py gmock-generated-actions.h.pump -// DO NOT EDIT BY HAND!!! - // 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 +#include + +#include "base/callback.h" +#include "gmock/gmock-actions.h" + +namespace testing { +namespace internal { + +// Implements the Invoke(callback) action. +template +class InvokeCallbackAction; + +template +class InvokeCallbackAction { + 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)...); + } + + private: + const std::shared_ptr callback_; +}; + +// Implements the InvokeWithoutArgs(callback) action. +template +class InvokeCallbackWithoutArgsAction { + const std::shared_ptr 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 + auto operator()(const Args&...) -> decltype(this->callback_->Run()) { + return callback_->Run(); + } +}; + +template +struct TypeIdentity { + using type = T; +}; + +inline TypeIdentity CallbackSignatureImpl(Closure*); +template +TypeIdentity CallbackSignatureImpl(ResultCallback*); + +template +TypeIdentity CallbackSignatureImpl(Callback1*); +template +TypeIdentity CallbackSignatureImpl(ResultCallback1*); + +template +TypeIdentity CallbackSignatureImpl(Callback2*); +template +TypeIdentity CallbackSignatureImpl(ResultCallback2*); + +template +TypeIdentity CallbackSignatureImpl(Callback3*); +template +TypeIdentity CallbackSignatureImpl(ResultCallback3*); + +template +TypeIdentity CallbackSignatureImpl(Callback4*); +template +TypeIdentity CallbackSignatureImpl(ResultCallback4*); + +template +TypeIdentity CallbackSignatureImpl(Callback5*); +template +TypeIdentity CallbackSignatureImpl(ResultCallback5*); + +template +using CallbackSignature = typename decltype( + internal::CallbackSignatureImpl(std::declval()))::type; + +// Specialization for protocol buffers. +// We support setting a proto2::Message, which doesn't have an assignment +// operator. +template +struct SetArgumentPointeeAction< + N, A, + typename std::enable_if::value>::type> { + A value; + + template + void operator()(const Args&... args) const { + ::std::get(std::tie(args...))->CopyFrom(value); + } +}; + +// Add Invoke overloads for google3 Callback types. + +template > +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 +internal::InvokeCallbackAction> +Invoke(Callback* callback) { + return internal::InvokeCallbackAction>( + 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 > +internal::InvokeCallbackWithoutArgsAction InvokeWithoutArgs( + Callback* callback) { + return internal::InvokeCallbackWithoutArgsAction(callback); +} + +} // namespace testing + +#endif // GTEST_GOOGLE3_MODE_ + #endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_GENERATED_ACTIONS_H_ diff --git a/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump b/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump deleted file mode 100644 index 67c221f1..00000000 --- a/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump +++ /dev/null @@ -1,12 +0,0 @@ -$$ -*- 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_ diff --git a/googlemock/include/gmock/internal/custom/gmock-matchers.h b/googlemock/include/gmock/internal/custom/gmock-matchers.h index 14aafaab..b60c6b83 100644 --- a/googlemock/include/gmock/internal/custom/gmock-matchers.h +++ b/googlemock/include/gmock/internal/custom/gmock-matchers.h @@ -33,4 +33,39 @@ #ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ #define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_MATCHERS_H_ + +#include + +#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 +struct CallableTraits*> { + typedef ResType ResultType; + using StorageType = std::shared_ptr>; + typedef ResultCallback1 Callback; + + static void CheckIsValid(const StorageType& callback) { + GTEST_CHECK_(callback != nullptr) + << "NULL callback is passed into ResultOf()."; + callback->CheckIsRepeatable(); + } + template + 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_ diff --git a/googlemock/include/gmock/internal/custom/gmock-port.h b/googlemock/include/gmock/internal/custom/gmock-port.h index 0030fe91..a6d1fb87 100644 --- a/googlemock/include/gmock/internal/custom/gmock-port.h +++ b/googlemock/include/gmock/internal/custom/gmock-port.h @@ -36,4 +36,29 @@ #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_ diff --git a/googlemock/test/gmock-generated-actions_nc.cc b/googlemock/test/gmock-generated-actions_nc.cc new file mode 100644 index 00000000..59f47989 --- /dev/null +++ b/googlemock/test/gmock-generated-actions_nc.cc @@ -0,0 +1,170 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +// Google Mock - a framework for writing C++ mock classes. +// +// This file contains negative compilation tests for script-generated +// Google Mock actions. + +#include "gmock/gmock.h" + +using testing::Action; +using testing::Invoke; +using testing::WithArgs; + +int Nullary() { return 0; } +int Binary(int a, int b) { return a + b; } + +#if defined(TEST_NULLARY_WITH_ARGS) + +// Tests that WithArgs(action) doesn't compile. +void Test() { + Action a = WithArgs(Invoke(Nullary)); +} + +#elif defined(TEST_TOO_FEW_ARGS_FOR_WITH_ARGS) + +// Tests that you cannot pass too few arguments to the inner action in +// WithArgs(). +void Test() { + Action a = WithArgs<1>(Invoke(Binary)); +} + +#elif defined(TEST_TOO_MANY_ARGS_FOR_WITH_ARGS) + +// Tests that you cannot pass too many arguments to the inner action in +// WithArgs(). +void Test() { + Action a = WithArgs<1, 2, 0>(Invoke(Binary)); +} + +#elif defined(TEST_INCOMPATIBLE_ARG_TYPES_FOR_WITH_ARGS) + +// Tests that you cannot pass arguments of incompatible types to the +// inner action in WithArgs(). +void Test() { + Action a = WithArgs<1, 2>(Invoke(Binary)); +} + +#elif defined(TEST_WRONG_ARG_TYPE_IN_ACTION_MACRO) + +// Tests using an ACTION definition in a mock function whose argument +// types are incompatible. +ACTION(WrongArgType) { return 10/arg0; } + +void Test() { + Action a = WrongArgType(); +} + +#elif defined(TEST_WRONG_RETURN_TYPE_IN_ACTION_MACRO) + +// Tests using an ACTION definition in a mock function whose return +// types is incompatible. +ACTION(WrongReturnType) { return 10; } + +void Test() { + Action a = WrongReturnType(); +} + +#elif defined(TEST_EXCESSIVE_ARG_IN_ACTION_MACRO) + +// Tests using an ACTION definition in a mock function that doesn't +// provide enough arguments. +ACTION(UseExcessiveArg) { return arg0 + arg1; } + +void Test() { + Action a = UseExcessiveArg(); +} + +#elif defined(TEST_ACTION_MACRO_IN_CLASS) + +// Tests using ACTION in a class scope. +class Foo { + public: + // This won't compile as C++ doesn't allow defining a method of a + // nested class out-of-line in the enclosing class. + ACTION(Bar) { return arg0; } +}; + +#elif defined(TEST_ACTION_MACRO_IN_FUNCTION) + +// Tests using ACTION in a function body. +void Test() { + // This won't compile as C++ doesn't allow member templates in local + // classes. We may want to revisit this when C++0x is widely + // implemented. + ACTION(Bar) { return arg0; } +} + +#elif defined(TEST_SET_ARG_REFEREE_MUST_BE_USED_WITH_REFERENCE) + +// Verifies that using SetArgReferee(...) where the k-th argument +// of the mock function is not a reference generates a compiler error. +void Test() { + Action a = testing::SetArgReferee<1>(5); +} + +#elif defined(TEST_DELETE_ARG_MUST_BE_USED_WITH_POINTER) + +// Verifies that using DeleteArg(...) where the k-th argument of the mock +// function is not a pointer generates a compiler error. +void Test() { + Action a = testing::DeleteArg<0>(); // NOLINT +} + +#elif defined(TEST_CANNOT_OVERLOAD_ACTION_TEMPLATE_ON_TEMPLATE_PARAM_NUMBER) + +// Tests that ACTION_TEMPLATE cannot be overloaded on the number of +// template parameters alone. + +ACTION_TEMPLATE(OverloadedAction, + HAS_1_TEMPLATE_PARAMS(typename, T), + AND_1_VALUE_PARAMS(p)) {} + +ACTION_TEMPLATE(OverloadedAction, + HAS_2_TEMPLATE_PARAMS(typename, T1, typename, T2), + AND_1_VALUE_PARAMS(p)) {} + +#elif defined(TEST_CANNOT_OVERLOAD_ACTION_AND_ACTION_TEMPLATE_W_SAME_VALUE_PS) + +// Tests that ACTION_TEMPLATE and ACTION_P cannot be overloaded when +// they have the same number of value parameters. + +ACTION_P(OverloadedAction, p) {} + +ACTION_TEMPLATE(OverloadedAction, + HAS_1_TEMPLATE_PARAMS(typename, T), + AND_1_VALUE_PARAMS(p)) {} + +#else + +// Sanity check - this should compile. + +#endif diff --git a/googlemock/test/gmock_generated_actions_nc_test.py b/googlemock/test/gmock_generated_actions_nc_test.py new file mode 100755 index 00000000..499a1031 --- /dev/null +++ b/googlemock/test/gmock_generated_actions_nc_test.py @@ -0,0 +1,137 @@ +#!/usr/bin/env python +# +# Copyright 2008, Google Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +# Google Mock - a framework for writing C++ mock classes. +# +# This file drives the negative compilation tests for script-generated +# Google Mock actions. + +"""Driver for the NC tests for script-generated Google Mock actions.""" + +import os +import sys + +IS_LINUX = os.name == "posix" and os.uname()[0] == "Linux" +if not IS_LINUX: + sys.stderr.write( + "WARNING: Negative compilation tests are not supported on this platform") + sys.exit(0) + +# Suppresses the 'Import not at the top of the file' lint complaint. +# pylint: disable-msg=C6204 +from google3.testing.pybase import fake_target_util +from google3.testing.pybase import googletest +# pylint: enable-msg=C6204 + + +class GMockGeneratedActionTest(googletest.TestCase): + """Negative compilation tests for generated Google Mock actions.""" + + # The class body is intentionally empty. The actual test*() methods + # will be defined at run time by a call to + # DefineNegativeCompilationTests() later. + pass + +# Defines a list of test specs, where each element is a tuple +# (test name, list of regexes for matching the compiler errors). +TEST_SPECS = [ + ("NULLARY_WITH_ARGS", [ + r"no matching function for call to 'WithArgs", + ]), + ("TOO_FEW_ARGS_FOR_WITH_ARGS", [ + r"no known conversion", + ]), + ("TOO_MANY_ARGS_FOR_WITH_ARGS", [ + r"no known conversion", + ]), + ("INCOMPATIBLE_ARG_TYPES_FOR_WITH_ARGS", [ + r"no known conversion", + ]), + ("WRONG_ARG_TYPE_IN_ACTION_MACRO", [ + r"invalid operands", + ]), + ( + "WRONG_RETURN_TYPE_IN_ACTION_MACRO", + [ + r"invalid conversion", # GCC + r"cannot initialize return object", # Clang + ]), + ( + "EXCESSIVE_ARG_IN_ACTION_MACRO", + [ + r"no match for 'operator\+'", # GCC + r"invalid operands to binary expression", # Clang + ]), + ( + "ACTION_MACRO_IN_CLASS", + [ + r"cannot define member function.*Bar.*within.*Foo", # GCC + r"ACTION\(Bar\)", # Clang + ]), + ( + "ACTION_MACRO_IN_FUNCTION", + [ + r"invalid declaration of member template in local class", # GCC + r"templates cannot be declared inside of a local class", # Clang + ]), + ("SET_ARG_REFEREE_MUST_BE_USED_WITH_REFERENCE", + [r"Argument must be a reference type"]), + ( + "DELETE_ARG_MUST_BE_USED_WITH_POINTER", + [ + r"argument given to 'delete', expected pointer", # GCC + r"cannot delete expression of type", # Clang + ]), + ( + "CANNOT_OVERLOAD_ACTION_TEMPLATE_ON_TEMPLATE_PARAM_NUMBER", + [ + r"wrong number of template arguments", # GCC + r"too many template parameters", # Clang + ]), + ( + "CANNOT_OVERLOAD_ACTION_AND_ACTION_TEMPLATE_W_SAME_VALUE_PS", + [ + r"wrong number of template arguments", # GCC + r"too many template parameters", # Clang + ]), + ("SANITY", None), +] + +# Define a test method in GMockGeneratedActionTest for each element in +# TEST_SPECS. +fake_target_util.DefineNegativeCompilationTests( + GMockGeneratedActionTest, + "google3/third_party/googletest/googlemock/test/gmock-generated-actions_nc", # fake target + "gmock-generated-actions_nc.o", # object file + TEST_SPECS) + +if __name__ == "__main__": + googletest.main() diff --git a/googletest/LICENSE b/googletest/LICENSE deleted file mode 100644 index 1941a11f..00000000 --- a/googletest/LICENSE +++ /dev/null @@ -1,28 +0,0 @@ -Copyright 2008, Google Inc. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/googletest/include/gtest/internal/custom/gtest-port.h b/googletest/include/gtest/internal/custom/gtest-port.h index cd85d956..0973a105 100644 --- a/googletest/include/gtest/internal/custom/gtest-port.h +++ b/googletest/include/gtest/internal/custom/gtest-port.h @@ -33,5 +33,170 @@ #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 + +// 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 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_ diff --git a/googletest/include/gtest/internal/custom/gtest-printers.h b/googletest/include/gtest/internal/custom/gtest-printers.h index eb4467ab..669e4845 100644 --- a/googletest/include/gtest/internal/custom/gtest-printers.h +++ b/googletest/include/gtest/internal/custom/gtest-printers.h @@ -38,5 +38,83 @@ #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(code); + } + } +}; + +template +class UniversalPrinter > { + public: + static void Print(const absl::StatusOr& 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 + : public FormatForComparisonAsStringImpl {}; +template <> +class FormatForComparison + : public FormatForComparisonAsStringImpl {}; + +template <> +class FormatForComparison + : public FormatForComparisonAsStringImpl {}; +template <> +class FormatForComparison + : public FormatForComparisonAsStringImpl {}; + +} // namespace internal +} // namespace testing + +#endif // GTEST_GOOGLE3_MODE_ +// absl:google3-end #endif // GTEST_INCLUDE_GTEST_INTERNAL_CUSTOM_GTEST_PRINTERS_H_ diff --git a/googletest/include/gtest/internal/custom/gtest.h b/googletest/include/gtest/internal/custom/gtest.h index 4c8e07be..20fb7bcb 100644 --- a/googletest/include/gtest/internal/custom/gtest.h +++ b/googletest/include/gtest/internal/custom/gtest.h @@ -34,4 +34,105 @@ #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 +#include + +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 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_