Skip to content

GitLab

Commit 5e24f358 authored by Roger Leigh's avatar Roger Leigh Committed by Jesse Beder
Browse files

test: Upgrade googlemock 1.7.0 to googletest 1.8.0 

Note that with the release of 1.8.0, googlemock and
googletest are unified into a single release.
parent e2818c42
Hide whitespace changes
Inline Side-by-side
Showing with 259 additions and 111 deletions
test/gmock-1.7.0/include/gmock/gmock-spec-builders.h → test/gtest-1.8.0/googlemock/include/gmock/gmock-spec-builders.h
View file @ 5e24f358
...@@ -211,7 +211,7 @@ class GTEST_API_ UntypedFunctionMockerBase { ...@@ -211,7 +211,7 @@ class GTEST_API_ UntypedFunctionMockerBase {
// arguments. This function can be safely called from multiple // arguments. This function can be safely called from multiple
// threads concurrently. The caller is responsible for deleting the // threads concurrently. The caller is responsible for deleting the
// result. // result.
const UntypedActionResultHolderBase* UntypedInvokeWith( UntypedActionResultHolderBase* UntypedInvokeWith(
const void* untyped_args) const void* untyped_args)
GTEST_LOCK_EXCLUDED_(g_gmock_mutex); GTEST_LOCK_EXCLUDED_(g_gmock_mutex);
...@@ -1289,6 +1289,57 @@ class MockSpec { ...@@ -1289,6 +1289,57 @@ class MockSpec {
GTEST_DISALLOW_ASSIGN_(MockSpec); GTEST_DISALLOW_ASSIGN_(MockSpec);
}; // class MockSpec }; // class MockSpec
// Wrapper type for generically holding an ordinary value or lvalue reference.
// If T is not a reference type, it must be copyable or movable.
// ReferenceOrValueWrapper<T> is movable, and will also be copyable unless
// T is a move-only value type (which means that it will always be copyable
// if the current platform does not support move semantics).
//
// The primary template defines handling for values, but function header
// comments describe the contract for the whole template (including
// specializations).
template <typename T>
class ReferenceOrValueWrapper {
public:
// Constructs a wrapper from the given value/reference.
explicit ReferenceOrValueWrapper(T value)
: value_(::testing::internal::move(value)) {
}
// Unwraps and returns the underlying value/reference, exactly as
// originally passed. The behavior of calling this more than once on
// the same object is unspecified.
T Unwrap() { return ::testing::internal::move(value_); }
// Provides nondestructive access to the underlying value/reference.
// Always returns a const reference (more precisely,
// const RemoveReference<T>&). The behavior of calling this after
// calling Unwrap on the same object is unspecified.
const T& Peek() const {
return value_;
}
private:
T value_;
};
// Specialization for lvalue reference types. See primary template
// for documentation.
template <typename T>
class ReferenceOrValueWrapper<T&> {
public:
// Workaround for debatable pass-by-reference lint warning (c-library-team
// policy precludes NOLINT in this context)
typedef T& reference;
explicit ReferenceOrValueWrapper(reference ref)
: value_ptr_(&ref) {}
T& Unwrap() { return *value_ptr_; }
const T& Peek() const { return *value_ptr_; }
private:
T* value_ptr_;
};
// MSVC warns about using 'this' in base member initializer list, so // MSVC warns about using 'this' in base member initializer list, so
// we need to temporarily disable the warning. We have to do it for // we need to temporarily disable the warning. We have to do it for
// the entire class to suppress the warning, even though it's about // the entire class to suppress the warning, even though it's about
...@@ -1320,23 +1371,16 @@ class UntypedActionResultHolderBase { ...@@ -1320,23 +1371,16 @@ class UntypedActionResultHolderBase {
template <typename T> template <typename T>
class ActionResultHolder : public UntypedActionResultHolderBase { class ActionResultHolder : public UntypedActionResultHolderBase {
public: public:
explicit ActionResultHolder(T a_value) : value_(a_value) {} // Returns the held value. Must not be called more than once.
T Unwrap() {
// The compiler-generated copy constructor and assignment operator return result_.Unwrap();
// are exactly what we need, so we don't need to define them.
// Returns the held value and deletes this object.
T GetValueAndDelete() const {
T retval(value_);
delete this;
return retval;
} }
// Prints the held value as an action's result to os. // Prints the held value as an action's result to os.
virtual void PrintAsActionResult(::std::ostream* os) const { virtual void PrintAsActionResult(::std::ostream* os) const {
*os << "\n Returns: "; *os << "\n Returns: ";
// T may be a reference type, so we don't use UniversalPrint(). // T may be a reference type, so we don't use UniversalPrint().
UniversalPrinter<T>::Print(value_, os); UniversalPrinter<T>::Print(result_.Peek(), os);
} }
// Performs the given mock function's default action and returns the // Performs the given mock function's default action and returns the
...@@ -1346,8 +1390,8 @@ class ActionResultHolder : public UntypedActionResultHolderBase { ...@@ -1346,8 +1390,8 @@ class ActionResultHolder : public UntypedActionResultHolderBase {
const FunctionMockerBase<F>* func_mocker, const FunctionMockerBase<F>* func_mocker,
const typename Function<F>::ArgumentTuple& args, const typename Function<F>::ArgumentTuple& args,
const string& call_description) { const string& call_description) {
return new ActionResultHolder( return new ActionResultHolder(Wrapper(
func_mocker->PerformDefaultAction(args, call_description)); func_mocker->PerformDefaultAction(args, call_description)));
} }
// Performs the given action and returns the result in a new-ed // Performs the given action and returns the result in a new-ed
...@@ -1356,44 +1400,53 @@ class ActionResultHolder : public UntypedActionResultHolderBase { ...@@ -1356,44 +1400,53 @@ class ActionResultHolder : public UntypedActionResultHolderBase {
static ActionResultHolder* static ActionResultHolder*
PerformAction(const Action<F>& action, PerformAction(const Action<F>& action,
const typename Function<F>::ArgumentTuple& args) { const typename Function<F>::ArgumentTuple& args) {
return new ActionResultHolder(action.Perform(args)); return new ActionResultHolder(Wrapper(action.Perform(args)));
} }
private: private:
T value_; typedef ReferenceOrValueWrapper<T> Wrapper;
// T could be a reference type, so = isn't supported. explicit ActionResultHolder(Wrapper result)
GTEST_DISALLOW_ASSIGN_(ActionResultHolder); : result_(::testing::internal::move(result)) {
}
Wrapper result_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
}; };
// Specialization for T = void. // Specialization for T = void.
template <> template <>
class ActionResultHolder<void> : public UntypedActionResultHolderBase { class ActionResultHolder<void> : public UntypedActionResultHolderBase {
public: public:
explicit ActionResultHolder() {} void Unwrap() { }
void GetValueAndDelete() const { delete this; }
virtual void PrintAsActionResult(::std::ostream* /* os */) const {} virtual void PrintAsActionResult(::std::ostream* /* os */) const {}
// Performs the given mock function's default action and returns NULL; // Performs the given mock function's default action and returns ownership
// of an empty ActionResultHolder*.
template <typename F> template <typename F>
static ActionResultHolder* PerformDefaultAction( static ActionResultHolder* PerformDefaultAction(
const FunctionMockerBase<F>* func_mocker, const FunctionMockerBase<F>* func_mocker,
const typename Function<F>::ArgumentTuple& args, const typename Function<F>::ArgumentTuple& args,
const string& call_description) { const string& call_description) {
func_mocker->PerformDefaultAction(args, call_description); func_mocker->PerformDefaultAction(args, call_description);
return new ActionResultHolder(); return new ActionResultHolder;
} }
// Performs the given action and returns NULL. // Performs the given action and returns ownership of an empty
// ActionResultHolder*.
template <typename F> template <typename F>
static ActionResultHolder* PerformAction( static ActionResultHolder* PerformAction(
const Action<F>& action, const Action<F>& action,
const typename Function<F>::ArgumentTuple& args) { const typename Function<F>::ArgumentTuple& args) {
action.Perform(args); action.Perform(args);
return new ActionResultHolder(); return new ActionResultHolder;
} }
private:
ActionResultHolder() {}
GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionResultHolder);
}; };
// The base of the function mocker class for the given function type. // The base of the function mocker class for the given function type.
...@@ -1528,8 +1581,9 @@ class FunctionMockerBase : public UntypedFunctionMockerBase { ...@@ -1528,8 +1581,9 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
// threads concurrently. // threads concurrently.
Result InvokeWith(const ArgumentTuple& args) Result InvokeWith(const ArgumentTuple& args)
GTEST_LOCK_EXCLUDED_(g_gmock_mutex) { GTEST_LOCK_EXCLUDED_(g_gmock_mutex) {
return static_cast<const ResultHolder*>( scoped_ptr<ResultHolder> holder(
this->UntypedInvokeWith(&args))->GetValueAndDelete(); DownCast_<ResultHolder*>(this->UntypedInvokeWith(&args)));
return holder->Unwrap();
} }
// Adds and returns a default action spec for this mock function. // Adds and returns a default action spec for this mock function.
......
test/gtest-1.8.0/googlemock/include/gmock/internal/custom/gmock-generated-actions.h 0 → 100644
View file @ 5e24f358
// This file was GENERATED by command:
// pump.py gmock-generated-actions.h.pump
// DO NOT EDIT BY HAND!!!
#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_
test/gtest-1.8.0/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump 0 → 100644
View file @ 5e24f358
$$ -*- mode: c++; -*-
$$ This is a Pump source file (http://go/pump). Please use Pump to convert
$$ it to callback-actions.h.
$$
$var max_callback_arity = 5
$$}} This meta comment fixes auto-indentation in editors.
#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_
test/gmock-1.7.0/src/gmock_main.cc → test/gtest-1.8.0/googlemock/include/gmock/internal/custom/gmock-matchers.h
View file @ 5e24f358
// Copyright 2008, Google Inc. // Copyright 2015, Google Inc.
// All rights reserved. // All rights reserved.
// //
// Redistribution and use in source and binary forms, with or without // Redistribution and use in source and binary forms, with or without
...@@ -27,28 +27,13 @@ ...@@ -27,28 +27,13 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// //
// Author: wan@google.com (Zhanyong Wan) // ============================================================
// An installation-specific extension point for gmock-matchers.h.
#include <iostream> // ============================================================
#include "gmock/gmock.h" //
#include "gtest/gtest.h" // Adds google3 callback support to CallableTraits.
//
// MS C++ compiler/linker has a bug on Windows (not on Windows CE), which #ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
// causes a link error when _tmain is defined in a static library and UNICODE #define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
// is enabled. For this reason instead of _tmain, main function is used on
// Windows. See the following link to track the current status of this bug:
// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=394464 // NOLINT
#if GTEST_OS_WINDOWS_MOBILE
# include <tchar.h> // NOLINT
GTEST_API_ int _tmain(int argc, TCHAR** argv) { #endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_CALLBACK_MATCHERS_H_
#else
GTEST_API_ int main(int argc, char** argv) {
#endif // GTEST_OS_WINDOWS_MOBILE
std::cout << "Running main() from gmock_main.cc\n";
// Since Google Mock depends on Google Test, InitGoogleMock() is
// also responsible for initializing Google Test. Therefore there's
// no need for calling testing::InitGoogleTest() separately.
testing::InitGoogleMock(&argc, argv);
return RUN_ALL_TESTS();
}
test/gtest-1.8.0/googlemock/include/gmock/internal/custom/gmock-port.h 0 → 100644
View file @ 5e24f358
// Copyright 2015, 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.
//
// Injection point for custom user configurations.
// The following macros can be defined:
//
// Flag related macros:
// GMOCK_DECLARE_bool_(name)
// GMOCK_DECLARE_int32_(name)
// GMOCK_DECLARE_string_(name)
// GMOCK_DEFINE_bool_(name, default_val, doc)
// GMOCK_DEFINE_int32_(name, default_val, doc)
// GMOCK_DEFINE_string_(name, default_val, doc)
//
// ** Custom implementation starts here **
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
#define GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_CUSTOM_GMOCK_PORT_H_
test/gmock-1.7.0/include/gmock/internal/gmock-generated-internal-utils.h → test/gtest-1.8.0/googlemock/include/gmock/internal/gmock-generated-internal-utils.h
View file @ 5e24f358
...@@ -69,70 +69,70 @@ template <typename Tuple> ...@@ -69,70 +69,70 @@ template <typename Tuple>
struct MatcherTuple; struct MatcherTuple;
template <> template <>
struct MatcherTuple< ::std::tr1::tuple<> > { struct MatcherTuple< ::testing::tuple<> > {
typedef ::std::tr1::tuple< > type; typedef ::testing::tuple< > type;
}; };
template <typename A1> template <typename A1>
struct MatcherTuple< ::std::tr1::tuple<A1> > { struct MatcherTuple< ::testing::tuple<A1> > {
typedef ::std::tr1::tuple<Matcher<A1> > type; typedef ::testing::tuple<Matcher<A1> > type;
}; };
template <typename A1, typename A2> template <typename A1, typename A2>
struct MatcherTuple< ::std::tr1::tuple<A1, A2> > { struct MatcherTuple< ::testing::tuple<A1, A2> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2> > type; typedef ::testing::tuple<Matcher<A1>, Matcher<A2> > type;
}; };
template <typename A1, typename A2, typename A3> template <typename A1, typename A2, typename A3>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3> > { struct MatcherTuple< ::testing::tuple<A1, A2, A3> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type; typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3> > type;
}; };
template <typename A1, typename A2, typename A3, typename A4> template <typename A1, typename A2, typename A3, typename A4>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4> > { struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>,
Matcher<A4> > type; Matcher<A4> > type;
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5> template <typename A1, typename A2, typename A3, typename A4, typename A5>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5> > { struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>, typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
Matcher<A5> > type; Matcher<A5> > type;
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5, template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6> typename A6>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> > { struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>, typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
Matcher<A5>, Matcher<A6> > type; Matcher<A5>, Matcher<A6> > type;
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5, template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7> typename A6, typename A7>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> > { struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>, typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
Matcher<A5>, Matcher<A6>, Matcher<A7> > type; Matcher<A5>, Matcher<A6>, Matcher<A7> > type;
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5, template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8> typename A6, typename A7, typename A8>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > { struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>, typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type; Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8> > type;
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5, template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9> typename A6, typename A7, typename A8, typename A9>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > { struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>, typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type; Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9> > type;
}; };
template <typename A1, typename A2, typename A3, typename A4, typename A5, template <typename A1, typename A2, typename A3, typename A4, typename A5,
typename A6, typename A7, typename A8, typename A9, typename A10> typename A6, typename A7, typename A8, typename A9, typename A10>
struct MatcherTuple< ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9, struct MatcherTuple< ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
A10> > { A10> > {
typedef ::std::tr1::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>, typedef ::testing::tuple<Matcher<A1>, Matcher<A2>, Matcher<A3>, Matcher<A4>,
Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>, Matcher<A5>, Matcher<A6>, Matcher<A7>, Matcher<A8>, Matcher<A9>,
Matcher<A10> > type; Matcher<A10> > type;
}; };
...@@ -156,7 +156,7 @@ struct Function; ...@@ -156,7 +156,7 @@ struct Function;
template <typename R> template <typename R>
struct Function<R()> { struct Function<R()> {
typedef R Result; typedef R Result;
typedef ::std::tr1::tuple<> ArgumentTuple; typedef ::testing::tuple<> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(); typedef void MakeResultVoid();
typedef IgnoredValue MakeResultIgnoredValue(); typedef IgnoredValue MakeResultIgnoredValue();
...@@ -166,7 +166,7 @@ template <typename R, typename A1> ...@@ -166,7 +166,7 @@ template <typename R, typename A1>
struct Function<R(A1)> struct Function<R(A1)>
: Function<R()> { : Function<R()> {
typedef A1 Argument1; typedef A1 Argument1;
typedef ::std::tr1::tuple<A1> ArgumentTuple; typedef ::testing::tuple<A1> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1); typedef void MakeResultVoid(A1);
typedef IgnoredValue MakeResultIgnoredValue(A1); typedef IgnoredValue MakeResultIgnoredValue(A1);
...@@ -176,7 +176,7 @@ template <typename R, typename A1, typename A2> ...@@ -176,7 +176,7 @@ template <typename R, typename A1, typename A2>
struct Function<R(A1, A2)> struct Function<R(A1, A2)>
: Function<R(A1)> { : Function<R(A1)> {
typedef A2 Argument2; typedef A2 Argument2;
typedef ::std::tr1::tuple<A1, A2> ArgumentTuple; typedef ::testing::tuple<A1, A2> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2); typedef void MakeResultVoid(A1, A2);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2); typedef IgnoredValue MakeResultIgnoredValue(A1, A2);
...@@ -186,7 +186,7 @@ template <typename R, typename A1, typename A2, typename A3> ...@@ -186,7 +186,7 @@ template <typename R, typename A1, typename A2, typename A3>
struct Function<R(A1, A2, A3)> struct Function<R(A1, A2, A3)>
: Function<R(A1, A2)> { : Function<R(A1, A2)> {
typedef A3 Argument3; typedef A3 Argument3;
typedef ::std::tr1::tuple<A1, A2, A3> ArgumentTuple; typedef ::testing::tuple<A1, A2, A3> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3); typedef void MakeResultVoid(A1, A2, A3);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3); typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3);
...@@ -196,7 +196,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4> ...@@ -196,7 +196,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4>
struct Function<R(A1, A2, A3, A4)> struct Function<R(A1, A2, A3, A4)>
: Function<R(A1, A2, A3)> { : Function<R(A1, A2, A3)> {
typedef A4 Argument4; typedef A4 Argument4;
typedef ::std::tr1::tuple<A1, A2, A3, A4> ArgumentTuple; typedef ::testing::tuple<A1, A2, A3, A4> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3, A4); typedef void MakeResultVoid(A1, A2, A3, A4);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4); typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4);
...@@ -207,7 +207,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4, ...@@ -207,7 +207,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4,
struct Function<R(A1, A2, A3, A4, A5)> struct Function<R(A1, A2, A3, A4, A5)>
: Function<R(A1, A2, A3, A4)> { : Function<R(A1, A2, A3, A4)> {
typedef A5 Argument5; typedef A5 Argument5;
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5> ArgumentTuple; typedef ::testing::tuple<A1, A2, A3, A4, A5> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3, A4, A5); typedef void MakeResultVoid(A1, A2, A3, A4, A5);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5); typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5);
...@@ -218,7 +218,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4, ...@@ -218,7 +218,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4,
struct Function<R(A1, A2, A3, A4, A5, A6)> struct Function<R(A1, A2, A3, A4, A5, A6)>
: Function<R(A1, A2, A3, A4, A5)> { : Function<R(A1, A2, A3, A4, A5)> {
typedef A6 Argument6; typedef A6 Argument6;
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple; typedef ::testing::tuple<A1, A2, A3, A4, A5, A6> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6); typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6); typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6);
...@@ -229,7 +229,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4, ...@@ -229,7 +229,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4,
struct Function<R(A1, A2, A3, A4, A5, A6, A7)> struct Function<R(A1, A2, A3, A4, A5, A6, A7)>
: Function<R(A1, A2, A3, A4, A5, A6)> { : Function<R(A1, A2, A3, A4, A5, A6)> {
typedef A7 Argument7; typedef A7 Argument7;
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple; typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7); typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7); typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7);
...@@ -240,7 +240,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4, ...@@ -240,7 +240,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4,
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8)>
: Function<R(A1, A2, A3, A4, A5, A6, A7)> { : Function<R(A1, A2, A3, A4, A5, A6, A7)> {
typedef A8 Argument8; typedef A8 Argument8;
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple; typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8); typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8); typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8);
...@@ -251,7 +251,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4, ...@@ -251,7 +251,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4,
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
: Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> { : Function<R(A1, A2, A3, A4, A5, A6, A7, A8)> {
typedef A9 Argument9; typedef A9 Argument9;
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple; typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9); typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9);
typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8, typedef IgnoredValue MakeResultIgnoredValue(A1, A2, A3, A4, A5, A6, A7, A8,
...@@ -264,7 +264,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4, ...@@ -264,7 +264,7 @@ template <typename R, typename A1, typename A2, typename A3, typename A4,
struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> struct Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
: Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> { : Function<R(A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
typedef A10 Argument10; typedef A10 Argument10;
typedef ::std::tr1::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9, typedef ::testing::tuple<A1, A2, A3, A4, A5, A6, A7, A8, A9,
A10> ArgumentTuple; A10> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10); typedef void MakeResultVoid(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
......
test/gmock-1.7.0/include/gmock/internal/gmock-generated-internal-utils.h.pump → test/gtest-1.8.0/googlemock/include/gmock/internal/gmock-generated-internal-utils.h.pump
View file @ 5e24f358
...@@ -77,8 +77,8 @@ $var typename_As = [[$for j, [[typename A$j]]]] ...@@ -77,8 +77,8 @@ $var typename_As = [[$for j, [[typename A$j]]]]
$var As = [[$for j, [[A$j]]]] $var As = [[$for j, [[A$j]]]]
$var matcher_As = [[$for j, [[Matcher<A$j>]]]] $var matcher_As = [[$for j, [[Matcher<A$j>]]]]
template <$typename_As> template <$typename_As>
struct MatcherTuple< ::std::tr1::tuple<$As> > { struct MatcherTuple< ::testing::tuple<$As> > {
typedef ::std::tr1::tuple<$matcher_As > type; typedef ::testing::tuple<$matcher_As > type;
}; };
...@@ -102,7 +102,7 @@ struct Function; ...@@ -102,7 +102,7 @@ struct Function;
template <typename R> template <typename R>
struct Function<R()> { struct Function<R()> {
typedef R Result; typedef R Result;
typedef ::std::tr1::tuple<> ArgumentTuple; typedef ::testing::tuple<> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid(); typedef void MakeResultVoid();
typedef IgnoredValue MakeResultIgnoredValue(); typedef IgnoredValue MakeResultIgnoredValue();
...@@ -121,7 +121,7 @@ template <typename R$typename_As> ...@@ -121,7 +121,7 @@ template <typename R$typename_As>
struct Function<R($As)> struct Function<R($As)>
: Function<R($prev_As)> { : Function<R($prev_As)> {
typedef A$i Argument$i; typedef A$i Argument$i;
typedef ::std::tr1::tuple<$As> ArgumentTuple; typedef ::testing::tuple<$As> ArgumentTuple;
typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple; typedef typename MatcherTuple<ArgumentTuple>::type ArgumentMatcherTuple;
typedef void MakeResultVoid($As); typedef void MakeResultVoid($As);
typedef IgnoredValue MakeResultIgnoredValue($As); typedef IgnoredValue MakeResultIgnoredValue($As);
......
test/gmock-1.7.0/include/gmock/internal/gmock-internal-utils.h → test/gtest-1.8.0/googlemock/include/gmock/internal/gmock-internal-utils.h
View file @ 5e24f358
...@@ -361,17 +361,30 @@ template <typename T> struct DecayArray<T[]> { ...@@ -361,17 +361,30 @@ template <typename T> struct DecayArray<T[]> {
typedef const T* type; typedef const T* type;
}; };
// Invalid<T>() returns an invalid value of type T. This is useful // Disable MSVC warnings for infinite recursion, since in this case the
// the recursion is unreachable.
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable:4717)
#endif
// Invalid<T>() is usable as an expression of type T, but will terminate
// the program with an assertion failure if actually run. This is useful
// when a value of type T is needed for compilation, but the statement // when a value of type T is needed for compilation, but the statement
// will not really be executed (or we don't care if the statement // will not really be executed (or we don't care if the statement
// crashes). // crashes).
template <typename T> template <typename T>
inline T Invalid() { inline T Invalid() {
return const_cast<typename remove_reference<T>::type&>( Assert(false, "", -1, "Internal error: attempt to return invalid value");
*static_cast<volatile typename remove_reference<T>::type*>(NULL)); // This statement is unreachable, and would never terminate even if it
// could be reached. It is provided only to placate compiler warnings
// about missing return statements.
return Invalid<T>();
} }
template <>
inline void Invalid<void>() {} #ifdef _MSC_VER
# pragma warning(pop)
#endif
// Given a raw type (i.e. having no top-level reference or const // Given a raw type (i.e. having no top-level reference or const
// modifier) RawContainer that's either an STL-style container or a // modifier) RawContainer that's either an STL-style container or a
...@@ -434,16 +447,17 @@ class StlContainerView<Element[N]> { ...@@ -434,16 +447,17 @@ class StlContainerView<Element[N]> {
// ConstReference(const char * (&)[4])') // ConstReference(const char * (&)[4])')
// (and though the N parameter type is mismatched in the above explicit // (and though the N parameter type is mismatched in the above explicit
// conversion of it doesn't help - only the conversion of the array). // conversion of it doesn't help - only the conversion of the array).
return type(const_cast<Element*>(&array[0]), N, kReference); return type(const_cast<Element*>(&array[0]), N,
RelationToSourceReference());
#else #else
return type(array, N, kReference); return type(array, N, RelationToSourceReference());
#endif // GTEST_OS_SYMBIAN #endif // GTEST_OS_SYMBIAN
} }
static type Copy(const Element (&array)[N]) { static type Copy(const Element (&array)[N]) {
#if GTEST_OS_SYMBIAN #if GTEST_OS_SYMBIAN
return type(const_cast<Element*>(&array[0]), N, kCopy); return type(const_cast<Element*>(&array[0]), N, RelationToSourceCopy());
#else #else
return type(array, N, kCopy); return type(array, N, RelationToSourceCopy());
#endif // GTEST_OS_SYMBIAN #endif // GTEST_OS_SYMBIAN
} }
}; };
...@@ -451,7 +465,7 @@ class StlContainerView<Element[N]> { ...@@ -451,7 +465,7 @@ class StlContainerView<Element[N]> {
// This specialization is used when RawContainer is a native array // This specialization is used when RawContainer is a native array
// represented as a (pointer, size) tuple. // represented as a (pointer, size) tuple.
template <typename ElementPointer, typename Size> template <typename ElementPointer, typename Size>
class StlContainerView< ::std::tr1::tuple<ElementPointer, Size> > { class StlContainerView< ::testing::tuple<ElementPointer, Size> > {
public: public:
typedef GTEST_REMOVE_CONST_( typedef GTEST_REMOVE_CONST_(
typename internal::PointeeOf<ElementPointer>::type) RawElement; typename internal::PointeeOf<ElementPointer>::type) RawElement;
...@@ -459,13 +473,11 @@ class StlContainerView< ::std::tr1::tuple<ElementPointer, Size> > { ...@@ -459,13 +473,11 @@ class StlContainerView< ::std::tr1::tuple<ElementPointer, Size> > {
typedef const type const_reference; typedef const type const_reference;
static const_reference ConstReference( static const_reference ConstReference(
const ::std::tr1::tuple<ElementPointer, Size>& array) { const ::testing::tuple<ElementPointer, Size>& array) {
using ::std::tr1::get; return type(get<0>(array), get<1>(array), RelationToSourceReference());
return type(get<0>(array), get<1>(array), kReference);
} }
static type Copy(const ::std::tr1::tuple<ElementPointer, Size>& array) { static type Copy(const ::testing::tuple<ElementPointer, Size>& array) {
using ::std::tr1::get; return type(get<0>(array), get<1>(array), RelationToSourceCopy());
return type(get<0>(array), get<1>(array), kCopy);
} }
}; };
...@@ -496,3 +508,4 @@ struct BooleanConstant {}; ...@@ -496,3 +508,4 @@ struct BooleanConstant {};
} // namespace testing } // namespace testing
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_ #endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_INTERNAL_UTILS_H_
test/gmock-1.7.0/include/gmock/internal/gmock-port.h → test/gtest-1.8.0/googlemock/include/gmock/internal/gmock-port.h
View file @ 5e24f358
...@@ -30,8 +30,11 @@ ...@@ -30,8 +30,11 @@
// Author: vadimb@google.com (Vadim Berman) // Author: vadimb@google.com (Vadim Berman)
// //
// Low-level types and utilities for porting Google Mock to various // Low-level types and utilities for porting Google Mock to various
// platforms. They are subject to change without notice. DO NOT USE // platforms. All macros ending with _ and symbols defined in an
// THEM IN USER CODE. // internal namespace are subject to change without notice. Code
// outside Google Mock MUST NOT USE THEM DIRECTLY. Macros that don't
// end with _ are part of Google Mock's public API and can be used by
// code outside Google Mock.
#ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ #ifndef GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
#define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ #define GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
...@@ -40,10 +43,16 @@ ...@@ -40,10 +43,16 @@
#include <stdlib.h> #include <stdlib.h>
#include <iostream> #include <iostream>
// Most of the types needed for porting Google Mock are also required // Most of the utilities needed for porting Google Mock are also
// for Google Test and are defined in gtest-port.h. // required for Google Test and are defined in gtest-port.h.
//
// Note to maintainers: to reduce code duplication, prefer adding
// portability utilities to Google Test's gtest-port.h instead of
// here, as Google Mock depends on Google Test. Only add a utility
// here if it's truly specific to Google Mock.
#include "gtest/internal/gtest-linked_ptr.h" #include "gtest/internal/gtest-linked_ptr.h"
#include "gtest/internal/gtest-port.h" #include "gtest/internal/gtest-port.h"
#include "gmock/internal/custom/gmock-port.h"
// To avoid conditional compilation everywhere, we make it // To avoid conditional compilation everywhere, we make it
// gmock-port.h's responsibility to #include the header implementing // gmock-port.h's responsibility to #include the header implementing
...@@ -60,6 +69,8 @@ ...@@ -60,6 +69,8 @@
// use this syntax to reference Google Mock flags. // use this syntax to reference Google Mock flags.
#define GMOCK_FLAG(name) FLAGS_gmock_##name #define GMOCK_FLAG(name) FLAGS_gmock_##name
#if !defined(GMOCK_DECLARE_bool_)
// Macros for declaring flags. // Macros for declaring flags.
#define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name) #define GMOCK_DECLARE_bool_(name) extern GTEST_API_ bool GMOCK_FLAG(name)
#define GMOCK_DECLARE_int32_(name) \ #define GMOCK_DECLARE_int32_(name) \
...@@ -75,4 +86,6 @@ ...@@ -75,4 +86,6 @@
#define GMOCK_DEFINE_string_(name, default_val, doc) \ #define GMOCK_DEFINE_string_(name, default_val, doc) \
GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val) GTEST_API_ ::std::string GMOCK_FLAG(name) = (default_val)
#endif // !defined(GMOCK_DECLARE_bool_)
#endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_ #endif // GMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_PORT_H_
test/gmock-1.7.0/make/Makefile → test/gtest-1.8.0/googlemock/make/Makefile
View file @ 5e24f358
...@@ -17,7 +17,7 @@ ...@@ -17,7 +17,7 @@
# Points to the root of Google Test, relative to where this file is. # Points to the root of Google Test, relative to where this file is.
# Remember to tweak this if you move this file, or if you want to use # Remember to tweak this if you move this file, or if you want to use
# a copy of Google Test at a different location. # a copy of Google Test at a different location.
GTEST_DIR = ../gtest GTEST_DIR = ../../googletest
# Points to the root of Google Mock, relative to where this file is. # Points to the root of Google Mock, relative to where this file is.
# Remember to tweak this if you move this file. # Remember to tweak this if you move this file.
......
test/gmock-1.7.0/msvc/2005/gmock_config.vsprops → test/gtest-1.8.0/googlemock/msvc/2005/gmock_config.vsprops
View file @ 5e24f358
...@@ -10,6 +10,6 @@ ...@@ -10,6 +10,6 @@
/> />
<UserMacro <UserMacro
Name="GTestDir" Name="GTestDir"
Value="../../gtest" Value="../../../googletest"
/> />
</VisualStudioPropertySheet> </VisualStudioPropertySheet>
test/gtest-1.8.0/googlemock/msvc/2010/gmock_config.props 0 → 100644
View file @ 5e24f358
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup Label="UserMacros">
<GTestDir>../../../googletest</GTestDir>
</PropertyGroup>
<PropertyGroup>
<_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>
</PropertyGroup>
<ItemDefinitionGroup>
<ClCompile>
<AdditionalIncludeDirectories>$(GTestDir)/include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
</ItemDefinitionGroup>
<ItemGroup>
<BuildMacro Include="GTestDir">
<Value>$(GTestDir)</Value>
</BuildMacro>
</ItemGroup>
</Project>
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