Skip to content

G
googletest
Commit 32de5f53 by zhanyong.wan
Options

Fixes a slew of compiler warnings and turns on "warning as error" in the scons build.

parent 284b54d3
Showing with 703 additions and 105 deletions
include/gmock/gmock-actions.h
......@@ -268,6 +268,7 @@ class ActionInterface {
// Returns true iff this is the DoDefault() action.
bool IsDoDefault() const { return is_do_default_; }
private:
template <typename Function>
friend class internal::MonomorphicDoDefaultActionImpl;
......@@ -279,6 +280,8 @@ class ActionInterface {
// True iff this action is DoDefault().
const bool is_do_default_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(ActionInterface);
};
// An Action<F> is a copyable and IMMUTABLE (except by assignment)
......@@ -325,6 +328,7 @@ class Action {
Result Perform(const ArgumentTuple& args) const {
return impl_->Perform(args);
}
private:
template <typename F1, typename F2>
friend class internal::ActionAdaptor;
......@@ -362,6 +366,7 @@ class PolymorphicAction {
operator Action<F>() const {
return Action<F>(new MonomorphicImpl<F>(impl_));
}
private:
template <typename F>
class MonomorphicImpl : public ActionInterface<F> {
......@@ -377,9 +382,13 @@ class PolymorphicAction {
private:
Impl impl_;
GTEST_DISALLOW_ASSIGN_(MonomorphicImpl);
};
Impl impl_;
GTEST_DISALLOW_ASSIGN_(PolymorphicAction);
};
// Creates an Action from its implementation and returns it. The
......@@ -416,8 +425,11 @@ class ActionAdaptor : public ActionInterface<F1> {
virtual Result Perform(const ArgumentTuple& args) {
return impl_->Perform(args);
}
private:
const internal::linked_ptr<ActionInterface<F2> > impl_;
GTEST_DISALLOW_ASSIGN_(ActionAdaptor);
};
// Implements the polymorphic Return(x) action, which can be used in
......@@ -470,6 +482,7 @@ class ReturnAction {
use_ReturnRef_instead_of_Return_to_return_a_reference);
return Action<F>(new Impl<F>(value_));
}
private:
// Implements the Return(x) action for a particular function type F.
template <typename F>
......@@ -494,9 +507,13 @@ class ReturnAction {
GMOCK_COMPILE_ASSERT_(!internal::is_reference<Result>::value,
Result_cannot_be_a_reference_type);
Result value_;
GTEST_DISALLOW_ASSIGN_(Impl);
};
R value_;
GTEST_DISALLOW_ASSIGN_(ReturnAction);
};
// Implements the ReturnNull() action.
......@@ -542,6 +559,7 @@ class ReturnRefAction {
use_Return_instead_of_ReturnRef_to_return_a_value);
return Action<F>(new Impl<F>(ref_));
}
private:
// Implements the ReturnRef(x) action for a particular function type F.
template <typename F>
......@@ -555,11 +573,16 @@ class ReturnRefAction {
virtual Result Perform(const ArgumentTuple&) {
return ref_;
}
private:
T& ref_;
GTEST_DISALLOW_ASSIGN_(Impl);
};
T& ref_;
GTEST_DISALLOW_ASSIGN_(ReturnRefAction);
};
// Implements the DoDefault() action for a particular function type F.
......@@ -611,9 +634,12 @@ class AssignAction {
void Perform(const ArgumentTuple& /* args */) const {
*ptr_ = value_;
}
private:
T1* const ptr_;
const T2 value_;
GTEST_DISALLOW_ASSIGN_(AssignAction);
};
#if !GTEST_OS_WINDOWS_MOBILE
......@@ -631,9 +657,12 @@ class SetErrnoAndReturnAction {
errno = errno_;
return result_;
}
private:
const int errno_;
const T result_;
GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction);
};
#endif // !GTEST_OS_WINDOWS_MOBILE
......@@ -657,6 +686,8 @@ class SetArgumentPointeeAction {
private:
const A value_;
GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
};
template <size_t N, typename Proto>
......@@ -675,8 +706,11 @@ class SetArgumentPointeeAction<N, Proto, true> {
CompileAssertTypesEqual<void, Result>();
::std::tr1::get<N>(args)->CopyFrom(*proto_);
}
private:
const internal::linked_ptr<Proto> proto_;
GTEST_DISALLOW_ASSIGN_(SetArgumentPointeeAction);
};
// Implements the InvokeWithoutArgs(f) action. The template argument
......@@ -696,8 +730,11 @@ class InvokeWithoutArgsAction {
// compatible with f.
template <typename Result, typename ArgumentTuple>
Result Perform(const ArgumentTuple&) { return function_impl_(); }
private:
FunctionImpl function_impl_;
GTEST_DISALLOW_ASSIGN_(InvokeWithoutArgsAction);
};
// Implements the InvokeWithoutArgs(object_ptr, &Class::Method) action.
......@@ -711,9 +748,12 @@ class InvokeMethodWithoutArgsAction {
Result Perform(const ArgumentTuple&) const {
return (obj_ptr_->*method_ptr_)();
}
private:
Class* const obj_ptr_;
const MethodPtr method_ptr_;
GTEST_DISALLOW_ASSIGN_(InvokeMethodWithoutArgsAction);
};
// Implements the IgnoreResult(action) action.
......@@ -739,6 +779,7 @@ class IgnoreResultAction {
return Action<F>(new Impl<F>(action_));
}
private:
template <typename F>
class Impl : public ActionInterface<F> {
......@@ -760,9 +801,13 @@ class IgnoreResultAction {
OriginalFunction;
const Action<OriginalFunction> action_;
GTEST_DISALLOW_ASSIGN_(Impl);
};
const A action_;
GTEST_DISALLOW_ASSIGN_(IgnoreResultAction);
};
// A ReferenceWrapper<T> object represents a reference to type T,
......@@ -827,10 +872,14 @@ class DoBothAction {
private:
const Action<VoidResult> action1_;
const Action<F> action2_;
GTEST_DISALLOW_ASSIGN_(Impl);
};
Action1 action1_;
Action2 action2_;
GTEST_DISALLOW_ASSIGN_(DoBothAction);
};
} // namespace internal
......
include/gmock/gmock-generated-actions.h
......@@ -615,6 +615,8 @@ class WithArgsAction {
};
const InnerAction action_;
GTEST_DISALLOW_ASSIGN_(WithArgsAction);
};
// A macro from the ACTION* family (defined later in this file)
......@@ -1406,12 +1408,16 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
arg9_type arg9) const;\
GMOCK_INTERNAL_DEFN_##value_params\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(\
new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
}\
GMOCK_INTERNAL_DEFN_##value_params\
private:\
GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
};\
template <GMOCK_INTERNAL_DECL_##template_params\
GMOCK_INTERNAL_DECL_TYPE_##value_params>\
......@@ -1462,10 +1468,14 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
arg1_type arg1, arg2_type arg2, arg3_type arg3, arg4_type arg4, \
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
arg9_type arg9) const;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>());\
}\
private:\
GTEST_DISALLOW_ASSIGN_(name##Action);\
};\
inline name##Action name() {\
return name##Action();\
......@@ -1505,11 +1515,15 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
arg5_type arg5, arg6_type arg6, arg7_type arg7, arg8_type arg8, \
arg9_type arg9) const;\
p0##_type p0;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0));\
}\
p0##_type p0;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP);\
};\
template <typename p0##_type>\
inline name##ActionP<p0##_type> name(p0##_type p0) {\
......@@ -1554,12 +1568,16 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
arg9_type arg9) const;\
p0##_type p0;\
p1##_type p1;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1));\
}\
p0##_type p0;\
p1##_type p1;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP2);\
};\
template <typename p0##_type, typename p1##_type>\
inline name##ActionP2<p0##_type, p1##_type> name(p0##_type p0, \
......@@ -1606,6 +1624,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p0##_type p0;\
p1##_type p1;\
p2##_type p2;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2));\
......@@ -1613,6 +1633,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p0##_type p0;\
p1##_type p1;\
p2##_type p2;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP3);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type>\
inline name##ActionP3<p0##_type, p1##_type, p2##_type> name(p0##_type p0, \
......@@ -1664,6 +1686,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p1##_type p1;\
p2##_type p2;\
p3##_type p3;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3));\
......@@ -1672,6 +1696,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p1##_type p1;\
p2##_type p2;\
p3##_type p3;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP4);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type, \
typename p3##_type>\
......@@ -1729,6 +1755,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p2##_type p2;\
p3##_type p3;\
p4##_type p4;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4));\
......@@ -1738,6 +1766,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p2##_type p2;\
p3##_type p3;\
p4##_type p4;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP5);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type, \
typename p3##_type, typename p4##_type>\
......@@ -1797,6 +1827,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p3##_type p3;\
p4##_type p4;\
p5##_type p5;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5));\
......@@ -1807,6 +1839,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p3##_type p3;\
p4##_type p4;\
p5##_type p5;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP6);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type, \
typename p3##_type, typename p4##_type, typename p5##_type>\
......@@ -1869,6 +1903,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p4##_type p4;\
p5##_type p5;\
p6##_type p6;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
......@@ -1881,6 +1917,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p4##_type p4;\
p5##_type p5;\
p6##_type p6;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP7);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type, \
typename p3##_type, typename p4##_type, typename p5##_type, \
......@@ -1949,6 +1987,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p5##_type p5;\
p6##_type p6;\
p7##_type p7;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
......@@ -1962,6 +2002,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p5##_type p5;\
p6##_type p6;\
p7##_type p7;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP8);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type, \
typename p3##_type, typename p4##_type, typename p5##_type, \
......@@ -2034,6 +2076,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p6##_type p6;\
p7##_type p7;\
p8##_type p8;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
......@@ -2048,6 +2092,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p6##_type p6;\
p7##_type p7;\
p8##_type p8;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP9);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type, \
typename p3##_type, typename p4##_type, typename p5##_type, \
......@@ -2123,6 +2169,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p7##_type p7;\
p8##_type p8;\
p9##_type p9;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>(p0, p1, p2, p3, p4, p5, \
......@@ -2138,6 +2186,8 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
p7##_type p7;\
p8##_type p8;\
p9##_type p9;\
private:\
GTEST_DISALLOW_ASSIGN_(name##ActionP10);\
};\
template <typename p0##_type, typename p1##_type, typename p2##_type, \
typename p3##_type, typename p4##_type, typename p5##_type, \
......@@ -2172,6 +2222,16 @@ DoAll(Action1 a1, Action2 a2, Action3 a3, Action4 a4, Action5 a5, Action6 a6,
// updated.
namespace testing {
// The ACTION*() macros trigger warning C4100 (unreferenced formal
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma. Therefore
// we suppress them here.
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4100)
#endif
// Various overloads for InvokeArgument<N>().
//
// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
......@@ -2350,6 +2410,10 @@ ACTION_TEMPLATE(ReturnNew,
return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9);
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace testing
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
include/gmock/gmock-generated-actions.h.pump
......@@ -228,6 +228,8 @@ class WithArgsAction {
};
const InnerAction action_;
GTEST_DISALLOW_ASSIGN_(WithArgsAction);
};
// A macro from the ACTION* family (defined later in this file)
......@@ -630,12 +632,16 @@ $range k 0..n-1
return_type gmock_PerformImpl(const args_type& args[[]]
$for k [[, arg$k[[]]_type arg$k]]) const;\
GMOCK_INTERNAL_DEFN_##value_params\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(\
new gmock_Impl<F>(GMOCK_INTERNAL_LIST_##value_params));\
}\
GMOCK_INTERNAL_DEFN_##value_params\
private:\
GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\
};\
template <GMOCK_INTERNAL_DECL_##template_params\
GMOCK_INTERNAL_DECL_TYPE_##value_params>\
......@@ -712,10 +718,14 @@ $var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]]
template <$typename_arg_types>\
return_type gmock_PerformImpl(const args_type& args, [[]]
$arg_types_and_names) const;\$param_field_decls
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename F> operator ::testing::Action<F>() const {\
return ::testing::Action<F>(new gmock_Impl<F>($params));\
}\$param_field_decls2
private:\
GTEST_DISALLOW_ASSIGN_($class_name);\
};\$template
inline $class_name$param_types name($param_types_and_names) {\
return $class_name$param_types($params);\
......@@ -735,6 +745,16 @@ $$ // show up in the generated code.
// updated.
namespace testing {
// The ACTION*() macros trigger warning C4100 (unreferenced formal
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma. Therefore
// we suppress them here.
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4100)
#endif
// Various overloads for InvokeArgument<N>().
//
// The InvokeArgument<N>(a1, a2, ..., a_k) action invokes the N-th
......@@ -796,6 +816,10 @@ ACTION_TEMPLATE(ReturnNew,
]]
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace testing
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_
include/gmock/gmock-generated-function-mockers.h
......@@ -794,66 +794,116 @@ class MockFunction;
template <typename R>
class MockFunction<R()> {
public:
MockFunction() {}
MOCK_METHOD0_T(Call, R());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0>
class MockFunction<R(A0)> {
public:
MockFunction() {}
MOCK_METHOD1_T(Call, R(A0));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1>
class MockFunction<R(A0, A1)> {
public:
MockFunction() {}
MOCK_METHOD2_T(Call, R(A0, A1));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2>
class MockFunction<R(A0, A1, A2)> {
public:
MockFunction() {}
MOCK_METHOD3_T(Call, R(A0, A1, A2));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2, typename A3>
class MockFunction<R(A0, A1, A2, A3)> {
public:
MockFunction() {}
MOCK_METHOD4_T(Call, R(A0, A1, A2, A3));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2, typename A3,
typename A4>
class MockFunction<R(A0, A1, A2, A3, A4)> {
public:
MockFunction() {}
MOCK_METHOD5_T(Call, R(A0, A1, A2, A3, A4));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2, typename A3,
typename A4, typename A5>
class MockFunction<R(A0, A1, A2, A3, A4, A5)> {
public:
MockFunction() {}
MOCK_METHOD6_T(Call, R(A0, A1, A2, A3, A4, A5));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2, typename A3,
typename A4, typename A5, typename A6>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6)> {
public:
MockFunction() {}
MOCK_METHOD7_T(Call, R(A0, A1, A2, A3, A4, A5, A6));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2, typename A3,
typename A4, typename A5, typename A6, typename A7>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7)> {
public:
MockFunction() {}
MOCK_METHOD8_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2, typename A3,
typename A4, typename A5, typename A6, typename A7, typename A8>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8)> {
public:
MockFunction() {}
MOCK_METHOD9_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
template <typename R, typename A0, typename A1, typename A2, typename A3,
......@@ -861,7 +911,12 @@ template <typename R, typename A0, typename A1, typename A2, typename A3,
typename A9>
class MockFunction<R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)> {
public:
MockFunction() {}
MOCK_METHOD10_T(Call, R(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
} // namespace testing
......
include/gmock/gmock-generated-function-mockers.h.pump
......@@ -242,7 +242,12 @@ $range j 0..i-1
template <typename R$for j [[, typename A$j]]>
class MockFunction<R($for j, [[A$j]])> {
public:
MockFunction() {}
MOCK_METHOD$i[[]]_T(Call, R($for j, [[A$j]]));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFunction);
};
......
include/gmock/gmock-generated-matchers.h.pump
......@@ -91,7 +91,7 @@ template <class Tuple$for j [[, int k$j]]>
class TupleFields<Tuple, $for k, [[$if k < i [[k$k]] $else [[-1]]]]> {
public:
typedef ::std::tr1::tuple<$for j, [[GMOCK_FIELD_TYPE_(Tuple, k$j)]]> type;
static type GetSelectedFields(const Tuple& t) {
static type GetSelectedFields(const Tuple& $if i==0 [[/* t */]] $else [[t]]) {
using ::std::tr1::get;
return type($for j, [[get<k$j>(t)]]);
}
......@@ -157,6 +157,8 @@ class ArgsMatcherImpl : public MatcherInterface<ArgsTuple> {
}
const MonomorphicInnerMatcher inner_matcher_;
GTEST_DISALLOW_ASSIGN_(ArgsMatcherImpl);
};
template <class InnerMatcher$for i [[, int k$i = -1]]>
......@@ -170,7 +172,10 @@ class ArgsMatcher {
return MakeMatcher(new ArgsMatcherImpl<ArgsTuple, $ks>(inner_matcher_));
}
private:
const InnerMatcher inner_matcher_;
GTEST_DISALLOW_ASSIGN_(ArgsMatcher);
};
// Implements ElementsAre() of 1-$n arguments.
......@@ -224,6 +229,8 @@ $for j [[
const T$j& e$j[[]]_;
]]
GTEST_DISALLOW_ASSIGN_(ElementsAreMatcher$i);
};
......@@ -512,6 +519,8 @@ $var param_field_decls2 = [[$for j
#name, description, gmock_interp_, gmock_printed_params);\
}\$param_field_decls
const ::testing::internal::Interpolations gmock_interp_;\
private:\
GTEST_DISALLOW_ASSIGN_(gmock_Impl);\
};\
template <typename arg_type>\
operator ::testing::Matcher<arg_type>() const {\
......@@ -523,7 +532,9 @@ $var param_field_decls2 = [[$for j
gmock_interp_ = ::testing::internal::ValidateMatcherDescription(\
gmock_param_names, ("" description ""));\
}\$param_field_decls2
private:\
::testing::internal::Interpolations gmock_interp_;\
GTEST_DISALLOW_ASSIGN_($class_name);\
};\$template
inline $class_name$param_types name($param_types_and_names) {\
return $class_name$param_types($params);\
......
include/gmock/gmock-generated-nice-strict.h
......@@ -155,6 +155,9 @@ class NiceMock : public MockClass {
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
};
template <class MockClass>
......@@ -246,6 +249,9 @@ class StrictMock : public MockClass {
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
};
// The following specializations catch some (relatively more common)
......
include/gmock/gmock-generated-nice-strict.h.pump
......@@ -100,6 +100,9 @@ $range j 1..i
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(NiceMock);
};
template <class MockClass>
......@@ -132,6 +135,9 @@ $range j 1..i
::testing::Mock::UnregisterCallReaction(
internal::implicit_cast<MockClass*>(this));
}
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(StrictMock);
};
// The following specializations catch some (relatively more common)
......
include/gmock/gmock-more-actions.h
......@@ -58,8 +58,11 @@ class InvokeAction {
Result Perform(const ArgumentTuple& args) {
return InvokeHelper<Result, ArgumentTuple>::Invoke(function_impl_, args);
}
private:
FunctionImpl function_impl_;
GTEST_DISALLOW_ASSIGN_(InvokeAction);
};
// Implements the Invoke(object_ptr, &Class::Method) action.
......@@ -74,9 +77,12 @@ class InvokeMethodAction {
return InvokeHelper<Result, ArgumentTuple>::InvokeMethod(
obj_ptr_, method_ptr_, args);
}
private:
Class* const obj_ptr_;
const MethodPtr method_ptr_;
GTEST_DISALLOW_ASSIGN_(InvokeMethodAction);
};
} // namespace internal
......@@ -122,6 +128,16 @@ WithArg(const InnerAction& action) {
return internal::WithArgsAction<InnerAction, k>(action);
}
// The ACTION*() macros trigger warning C4100 (unreferenced formal
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma. Therefore
// we suppress them here.
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4100)
#endif
// Action ReturnArg<k>() returns the k-th argument of the mock function.
ACTION_TEMPLATE(ReturnArg,
HAS_1_TEMPLATE_PARAMS(int, k),
......@@ -185,6 +201,10 @@ ACTION_TEMPLATE(DeleteArg,
ACTION_P(Throw, exception) { throw exception; }
#endif // GTEST_HAS_EXCEPTIONS
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace testing
#endif // GMOCK_INCLUDE_GMOCK_GMOCK_MORE_ACTIONS_H_
include/gmock/gmock-spec-builders.h
......@@ -142,10 +142,10 @@ class DefaultActionSpec {
// Constructs a DefaultActionSpec object from the information inside
// the parenthesis of an ON_CALL() statement.
DefaultActionSpec(const char* file, int line,
DefaultActionSpec(const char* a_file, int a_line,
const ArgumentMatcherTuple& matchers)
: file_(file),
line_(line),
: file_(a_file),
line_(a_line),
matchers_(matchers),
// By default, extra_matcher_ should match anything. However,
// we cannot initialize it with _ as that triggers a compiler
......@@ -196,6 +196,7 @@ class DefaultActionSpec {
"once in an ON_CALL().");
return action_;
}
private:
// Gives each clause in the ON_CALL() statement a name.
enum Clause {
......@@ -582,6 +583,7 @@ class ExpectationBase {
// expectation has occurred.
// L >= g_gmock_mutex
virtual void DescribeCallCountTo(::std::ostream* os) const = 0;
protected:
friend class ::testing::Expectation;
......@@ -620,8 +622,8 @@ class ExpectationBase {
bool cardinality_specified() const { return cardinality_specified_; }
// Sets the cardinality of this expectation spec.
void set_cardinality(const Cardinality& cardinality) {
cardinality_ = cardinality;
void set_cardinality(const Cardinality& a_cardinality) {
cardinality_ = a_cardinality;
}
// The following group of methods should only be called after the
......@@ -716,6 +718,8 @@ class ExpectationBase {
// and can change as the mock function is called.
int call_count_; // How many times this expectation has been invoked.
bool retired_; // True iff this expectation has retired.
GTEST_DISALLOW_ASSIGN_(ExpectationBase);
}; // class ExpectationBase
// Impements an expectation for the given function type.
......@@ -727,9 +731,9 @@ class TypedExpectation : public ExpectationBase {
typedef typename Function<F>::Result Result;
TypedExpectation(FunctionMockerBase<F>* owner,
const char* file, int line, const string& source_text,
const char* a_file, int a_line, const string& a_source_text,
const ArgumentMatcherTuple& m)
: ExpectationBase(file, line, source_text),
: ExpectationBase(a_file, a_line, a_source_text),
owner_(owner),
matchers_(m),
extra_matcher_specified_(false),
......@@ -769,7 +773,7 @@ class TypedExpectation : public ExpectationBase {
}
// Implements the .Times() clause.
TypedExpectation& Times(const Cardinality& cardinality) {
TypedExpectation& Times(const Cardinality& a_cardinality) {
if (last_clause_ ==kTimes) {
ExpectSpecProperty(false,
".Times() cannot appear "
......@@ -782,7 +786,7 @@ class TypedExpectation : public ExpectationBase {
}
last_clause_ = kTimes;
ExpectationBase::SpecifyCardinality(cardinality);
ExpectationBase::SpecifyCardinality(a_cardinality);
return *this;
}
......@@ -1164,6 +1168,8 @@ class TypedExpectation : public ExpectationBase {
Clause last_clause_;
mutable bool action_count_checked_; // Under mutex_.
mutable Mutex mutex_; // Protects action_count_checked_.
GTEST_DISALLOW_COPY_AND_ASSIGN_(TypedExpectation);
}; // class TypedExpectation
// A MockSpec object is used by ON_CALL() or EXPECT_CALL() for
......@@ -1228,6 +1234,8 @@ class MockSpec {
internal::FunctionMockerBase<F>* const function_mocker_;
// The argument matchers specified in the spec.
ArgumentMatcherTuple matchers_;
GTEST_DISALLOW_ASSIGN_(MockSpec);
}; // class MockSpec
// MSVC warns about using 'this' in base member initializer list, so
......@@ -1251,7 +1259,7 @@ class MockSpec {
template <typename T>
class ActionResultHolder {
public:
explicit ActionResultHolder(T value) : value_(value) {}
explicit ActionResultHolder(T a_value) : value_(a_value) {}
// The compiler-generated copy constructor and assignment operator
// are exactly what we need, so we don't need to define them.
......@@ -1285,6 +1293,9 @@ class ActionResultHolder {
private:
T value_;
// T could be a reference type, so = isn't supported.
GTEST_DISALLOW_ASSIGN_(ActionResultHolder);
};
// Specialization for T = void.
......@@ -1433,6 +1444,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
}
return name;
}
protected:
template <typename Function>
friend class MockSpec;
......@@ -1477,6 +1489,7 @@ class FunctionMockerBase : public UntypedFunctionMockerBase {
// The current spec (either default action spec or expectation spec)
// being described on this function mocker.
MockSpec<F>& current_spec() { return current_spec_; }
private:
template <typename Func> friend class TypedExpectation;
......
include/gmock/internal/gmock-internal-utils.h
......@@ -640,15 +640,15 @@ class NativeArray {
// Initializes this object; makes a copy of the input array if
// 'relation' is kCopy.
void Init(const Element* array, size_t size, RelationToSource relation) {
void Init(const Element* array, size_t a_size, RelationToSource relation) {
if (relation == kReference) {
array_ = array;
} else {
Element* const copy = new Element[size];
CopyArray(array, size, copy);
Element* const copy = new Element[a_size];
CopyArray(array, a_size, copy);
array_ = copy;
}
size_ = size;
size_ = a_size;
relation_to_source_ = relation;
}
......
scons/SConscript
......@@ -105,9 +105,19 @@ GtestTest = gtest_exports['GtestTest']
gtest_common_exports = SConscript(GTEST_DIR + '/scons/SConscript.common')
EnvCreator = gtest_common_exports['EnvCreator']
# TODO(vladl@google.com): restore warnings as errors once all warnings are fixed
# in gMock.
env = EnvCreator.Create(env, EnvCreator.WarningOk)
env = env.Clone()
if env['PLATFORM'] == 'win32':
env.Append(CCFLAGS=[
'-wd4127', # Disables warning "conditional expression is constant",
# triggered by VC 8.0's own STL header <list>.
'-wd4702', # Disables warning "unreachable code", triggered by VC
# 7.1's own STL header <xtree>.
'-wd4675', # Disables warning "resolved overload was found by
# argument-dependent lookup" generated by VC 7.1.
# It just says that VC 7.1 fixed a bug in earlier
# versions of VC so the code behavior will be
# different than compiled with VC 6.0, for example.
])
# Note: The relative paths in SConscript files are relative to the location
# of the SConscript file itself. To make a path relative to the location of
......
src/gmock-internal-utils.cc
......@@ -64,7 +64,7 @@ string ConvertIdentifierNameToWords(const char* id_name) {
if (isalnum(*p)) {
if (starts_new_word && result != "")
result += ' ';
result += tolower(*p);
result += static_cast<char>(tolower(*p));
}
}
return result;
......
src/gmock-spec-builders.cc
......@@ -56,12 +56,12 @@ namespace internal {
Mutex g_gmock_mutex(Mutex::NO_CONSTRUCTOR_NEEDED_FOR_STATIC_MUTEX);
// Constructs an ExpectationBase object.
ExpectationBase::ExpectationBase(const char* file,
int line,
const string& source_text)
: file_(file),
line_(line),
source_text_(source_text),
ExpectationBase::ExpectationBase(const char* a_file,
int a_line,
const string& a_source_text)
: file_(a_file),
line_(a_line),
source_text_(a_source_text),
cardinality_specified_(false),
cardinality_(Exactly(1)),
call_count_(0),
......@@ -73,9 +73,9 @@ ExpectationBase::~ExpectationBase() {}
// Explicitly specifies the cardinality of this expectation. Used by
// the subclasses to implement the .Times() clause.
void ExpectationBase::SpecifyCardinality(const Cardinality& cardinality) {
void ExpectationBase::SpecifyCardinality(const Cardinality& a_cardinality) {
cardinality_specified_ = true;
cardinality_ = cardinality;
cardinality_ = a_cardinality;
}
// Retires all pre-requisites of this expectation.
......@@ -427,8 +427,8 @@ void Mock::ClearDefaultActionsLocked(void* mock_obj) {
Expectation::Expectation() {}
Expectation::Expectation(
const internal::linked_ptr<internal::ExpectationBase>& expectation_base)
: expectation_base_(expectation_base) {}
const internal::linked_ptr<internal::ExpectationBase>& an_expectation_base)
: expectation_base_(an_expectation_base) {}
Expectation::~Expectation() {}
......
test/gmock-actions_test.cc
......@@ -95,26 +95,26 @@ TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) {
// Tests that BuiltInDefaultValue<T>::Get() returns 0 when T is a
// built-in numeric type.
TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) {
EXPECT_EQ(0, BuiltInDefaultValue<unsigned char>::Get());
EXPECT_EQ(0U, BuiltInDefaultValue<unsigned char>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<signed char>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<char>::Get());
#if GMOCK_HAS_SIGNED_WCHAR_T_
EXPECT_EQ(0, BuiltInDefaultValue<unsigned wchar_t>::Get());
EXPECT_EQ(0U, BuiltInDefaultValue<unsigned wchar_t>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<signed wchar_t>::Get());
#endif
#if GMOCK_WCHAR_T_IS_NATIVE_
EXPECT_EQ(0, BuiltInDefaultValue<wchar_t>::Get());
#endif
EXPECT_EQ(0, BuiltInDefaultValue<unsigned short>::Get()); // NOLINT
EXPECT_EQ(0U, BuiltInDefaultValue<unsigned short>::Get()); // NOLINT
EXPECT_EQ(0, BuiltInDefaultValue<signed short>::Get()); // NOLINT
EXPECT_EQ(0, BuiltInDefaultValue<short>::Get()); // NOLINT
EXPECT_EQ(0, BuiltInDefaultValue<unsigned int>::Get());
EXPECT_EQ(0U, BuiltInDefaultValue<unsigned int>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<signed int>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<int>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<unsigned long>::Get()); // NOLINT
EXPECT_EQ(0U, BuiltInDefaultValue<unsigned long>::Get()); // NOLINT
EXPECT_EQ(0, BuiltInDefaultValue<signed long>::Get()); // NOLINT
EXPECT_EQ(0, BuiltInDefaultValue<long>::Get()); // NOLINT
EXPECT_EQ(0, BuiltInDefaultValue<UInt64>::Get());
EXPECT_EQ(0U, BuiltInDefaultValue<UInt64>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<Int64>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<float>::Get());
EXPECT_EQ(0, BuiltInDefaultValue<double>::Get());
......@@ -517,11 +517,13 @@ TEST(ReturnTest, IsCovariant) {
// gmock-actions.h for more information.
class FromType {
public:
FromType(bool* converted) : converted_(converted) {}
FromType(bool* is_converted) : converted_(is_converted) {}
bool* converted() const { return converted_; }
private:
bool* const converted_;
GTEST_DISALLOW_ASSIGN_(FromType);
};
class ToType {
......@@ -588,8 +590,13 @@ class MyClass {};
class MockClass {
public:
MockClass() {}
MOCK_METHOD1(IntFunc, int(bool flag)); // NOLINT
MOCK_METHOD0(Foo, MyClass());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockClass);
};
// Tests that DoDefault() returns the built-in default value for the
......@@ -615,7 +622,7 @@ TEST(DoDefaultDeathTest, DiesForUnknowType) {
// Tests that using DoDefault() inside a composite action leads to a
// run-time error.
void VoidFunc(bool flag) {}
void VoidFunc(bool /* flag */) {}
TEST(DoDefaultDeathTest, DiesIfUsedInCompositeAction) {
MockClass mock;
......@@ -801,7 +808,7 @@ bool Unary(int x) { return x < 0; }
const char* Plus1(const char* s) { return s + 1; }
void VoidUnary(int n) { g_done = true; }
void VoidUnary(int /* n */) { g_done = true; }
bool ByConstRef(const std::string& s) { return s == "Hi"; }
......@@ -870,7 +877,7 @@ TEST(InvokeWithoutArgsTest, Function) {
EXPECT_EQ(1, a.Perform(make_tuple(2)));
// As an action that takes two arguments.
Action<short(int, double)> a2 = InvokeWithoutArgs(Nullary); // NOLINT
Action<int(int, double)> a2 = InvokeWithoutArgs(Nullary); // NOLINT
EXPECT_EQ(1, a2.Perform(make_tuple(2, 3.5)));
// As an action that returns void.
......@@ -887,7 +894,7 @@ TEST(InvokeWithoutArgsTest, Functor) {
EXPECT_EQ(2, a.Perform(make_tuple()));
// As an action that takes three arguments.
Action<short(int, double, char)> a2 = // NOLINT
Action<int(int, double, char)> a2 = // NOLINT
InvokeWithoutArgs(NullaryFunctor());
EXPECT_EQ(2, a2.Perform(make_tuple(3, 3.5, 'a')));
......@@ -928,7 +935,7 @@ TEST(IgnoreResultTest, MonomorphicAction) {
// Tests using IgnoreResult() on an action that returns a class type.
MyClass ReturnMyClass(double x) {
MyClass ReturnMyClass(double /* x */) {
g_done = true;
return MyClass();
}
......
test/gmock-cardinalities_test.cc
......@@ -52,7 +52,11 @@ using testing::MakeCardinality;
class MockFoo {
public:
MockFoo() {}
MOCK_METHOD0(Bar, int()); // NOLINT
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
};
// Tests that Cardinality objects can be default constructed.
......@@ -398,7 +402,9 @@ class EvenCardinality : public CardinalityInterface {
}
// Returns true iff call_count calls will saturate this cardinality.
virtual bool IsSaturatedByCallCount(int call_count) const { return false; }
virtual bool IsSaturatedByCallCount(int /* call_count */) const {
return false;
}
// Describes self to an ostream.
virtual void DescribeTo(::std::ostream* ss) const {
......
test/gmock-generated-actions_test.cc
......@@ -63,6 +63,10 @@ using testing::StaticAssertTypeEq;
using testing::Unused;
using testing::WithArgs;
// For suppressing compiler warnings on conversion possibly losing precision.
inline short Short(short n) { return n; } // NOLINT
inline char Char(char ch) { return ch; }
// Sample functions and functors for testing various actions.
int Nullary() { return 1; }
......@@ -242,7 +246,7 @@ TEST(InvokeArgumentTest, Function10) {
// Tests using InvokeArgument with a function that takes a pointer argument.
TEST(InvokeArgumentTest, ByPointerFunction) {
Action<const char*(const char*(*)(const char* input, short n))> a = // NOLINT
InvokeArgument<0>(static_cast<const char*>("Hi"), 1);
InvokeArgument<0>(static_cast<const char*>("Hi"), Short(1));
EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
}
......@@ -250,7 +254,7 @@ TEST(InvokeArgumentTest, ByPointerFunction) {
// by passing it a C-string literal.
TEST(InvokeArgumentTest, FunctionWithCStringLiteral) {
Action<const char*(const char*(*)(const char* input, short n))> a = // NOLINT
InvokeArgument<0>("Hi", 1);
InvokeArgument<0>("Hi", Short(1));
EXPECT_STREQ("i", a.Perform(make_tuple(&Binary)));
}
......@@ -286,17 +290,17 @@ TEST(WithArgsTest, OneArg) {
// Tests using WithArgs with an action that takes 2 arguments.
TEST(WithArgsTest, TwoArgs) {
Action<const char*(const char* s, double x, int n)> a =
Action<const char*(const char* s, double x, short n)> a =
WithArgs<0, 2>(Invoke(Binary));
const char s[] = "Hello";
EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, 2)));
EXPECT_EQ(s + 2, a.Perform(make_tuple(CharPtr(s), 0.5, Short(2))));
}
// Tests using WithArgs with an action that takes 3 arguments.
TEST(WithArgsTest, ThreeArgs) {
Action<int(int, double, char, short)> a = // NOLINT
WithArgs<0, 2, 3>(Invoke(Ternary));
EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, 20, 3)));
EXPECT_EQ(123, a.Perform(make_tuple(100, 6.5, Char(20), Short(3))));
}
// Tests using WithArgs with an action that takes 4 arguments.
......@@ -379,7 +383,7 @@ TEST(WithArgsTest, NonInvokeAction) {
TEST(WithArgsTest, Identity) {
Action<int(int x, char y, short z)> a = // NOLINT
WithArgs<0, 1, 2>(Invoke(Ternary));
EXPECT_EQ(123, a.Perform(make_tuple(100, 20, 3)));
EXPECT_EQ(123, a.Perform(make_tuple(100, Char(20), Short(3))));
}
// Tests using WithArgs with repeated arguments.
......@@ -394,14 +398,14 @@ TEST(WithArgsTest, ReversedArgumentOrder) {
Action<const char*(short n, const char* input)> a = // NOLINT
WithArgs<1, 0>(Invoke(Binary));
const char s[] = "Hello";
EXPECT_EQ(s + 2, a.Perform(make_tuple(2, CharPtr(s))));
EXPECT_EQ(s + 2, a.Perform(make_tuple(Short(2), CharPtr(s))));
}
// Tests using WithArgs with compatible, but not identical, argument types.
TEST(WithArgsTest, ArgsOfCompatibleTypes) {
Action<long(short x, int y, double z, char c)> a = // NOLINT
Action<long(short x, char y, double z, char c)> a = // NOLINT
WithArgs<0, 1, 3>(Invoke(Ternary));
EXPECT_EQ(123, a.Perform(make_tuple(100, 20, 5.6, 3)));
EXPECT_EQ(123, a.Perform(make_tuple(Short(100), Char(20), 5.6, Char(3))));
}
// Tests using WithArgs with an action that returns void.
......@@ -583,6 +587,16 @@ TEST(DoAllTest, TenActions) {
EXPECT_EQ('g', g);
}
// The ACTION*() macros trigger warning C4100 (unreferenced formal
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma. Therefore
// we suppress them here.
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4100)
#endif
// Tests the ACTION*() macro family.
// Tests that ACTION() can define an action that doesn't reference the
......@@ -633,7 +647,7 @@ ACTION(Sum2) {
TEST(ActionMacroTest, CanReferenceArgumentTuple) {
Action<int(int, char, int*)> a1 = Sum2();
int dummy = 0;
EXPECT_EQ(11, a1.Perform(make_tuple(5, static_cast<char>(6), &dummy)));
EXPECT_EQ(11, a1.Perform(make_tuple(5, Char(6), &dummy)));
}
// Tests that the body of ACTION() can reference the mock function
......@@ -731,7 +745,7 @@ ACTION_P(TypedPlus, n) {
TEST(ActionPMacroTest, CanReferenceArgumentAndParameterTypes) {
Action<int(char m, bool t)> a1 = TypedPlus(9);
EXPECT_EQ(10, a1.Perform(make_tuple(static_cast<char>(1), true)));
EXPECT_EQ(10, a1.Perform(make_tuple(Char(1), true)));
}
// Tests that a parameterized action can be used in any mock function
......@@ -851,7 +865,7 @@ TEST(ActionPnMacroTest, WorksFor10Parameters) {
ACTION_P2(PadArgument, prefix, suffix) {
// The following lines promote the two parameters to desired types.
std::string prefix_str(prefix);
char suffix_char(suffix);
char suffix_char = static_cast<char>(suffix);
return prefix_str + arg0 + suffix_char;
}
......@@ -1078,7 +1092,7 @@ class BoolResetter {
explicit BoolResetter(bool* value) : value_(value) {}
~BoolResetter() { *value_ = false; }
private:
bool* const value_;
bool* value_;
};
TEST(ActionTemplateTest, WorksForIntegralTemplateParams) {
......@@ -1190,5 +1204,9 @@ TEST(ActionTemplateTest, CanBeOverloadedOnNumberOfValueParameters) {
EXPECT_EQ(12345, a4.Perform(make_tuple()));
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
} // namespace gmock_generated_actions_test
} // namespace testing
test/gmock-generated-function-mockers_test.cc
......@@ -114,6 +114,8 @@ class FooInterface {
class MockFoo : public FooInterface {
public:
MockFoo() {}
// Makes sure that a mock function parameter can be named.
MOCK_METHOD1(VoidReturning, void(int n)); // NOLINT
......@@ -149,6 +151,9 @@ class MockFoo : public FooInterface {
const string& k));
MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, CTConst, char(int));
#endif // GTEST_OS_WINDOWS
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
};
class FunctionMockerTest : public testing::Test {
......@@ -305,7 +310,12 @@ TEST_F(FunctionMockerTest, MocksFunctionsConstFunctionWithCallType) {
class MockB {
public:
MockB() {}
MOCK_METHOD0(DoB, void());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
};
// Tests that functions with no EXPECT_CALL() ruls can be called any
......@@ -345,10 +355,15 @@ class StackInterface {
template <typename T>
class MockStack : public StackInterface<T> {
public:
MockStack() {}
MOCK_METHOD1_T(Push, void(const T& elem));
MOCK_METHOD0_T(Pop, void());
MOCK_CONST_METHOD0_T(GetSize, int()); // NOLINT
MOCK_CONST_METHOD0_T(GetTop, const T&());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStack);
};
// Tests that template mock works.
......@@ -393,10 +408,15 @@ class StackInterfaceWithCallType {
template <typename T>
class MockStackWithCallType : public StackInterfaceWithCallType<T> {
public:
MockStackWithCallType() {}
MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Push, void(const T& elem));
MOCK_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Pop, void());
MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetSize, int());
MOCK_CONST_METHOD0_T_WITH_CALLTYPE(STDMETHODCALLTYPE, GetTop, const T&());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockStackWithCallType);
};
// Tests that template mock with calltype works.
......@@ -430,7 +450,12 @@ TEST(TemplateMockTestWithCallType, Works) {
class MockOverloadedOnArgNumber {
public:
MockOverloadedOnArgNumber() {}
MY_MOCK_METHODS1_;
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnArgNumber);
};
TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
......@@ -450,7 +475,12 @@ TEST(OverloadedMockMethodTest, CanOverloadOnArgNumberInMacroBody) {
class MockOverloadedOnConstness {
public:
MockOverloadedOnConstness() {}
MY_MOCK_METHODS2_;
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockOverloadedOnConstness);
};
TEST(OverloadedMockMethodTest, CanOverloadOnConstnessInMacroBody) {
......
test/gmock-generated-matchers_test.cc
......@@ -223,8 +223,9 @@ class GreaterThanMatcher : public MatcherInterface<int> {
*os << "is " << -diff << " less than " << rhs_;
}
}
private:
const int rhs_;
int rhs_;
};
Matcher<int> GreaterThan(int n) {
......@@ -411,7 +412,7 @@ TEST(ElementsAreTest, WorksForNestedContainer) {
};
vector<list<char> > nested;
for (int i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) {
for (size_t i = 0; i < GMOCK_ARRAY_SIZE_(strings); i++) {
nested.push_back(list<char>(strings[i], strings[i] + strlen(strings[i])));
}
......@@ -446,7 +447,12 @@ TEST(ElementsAreTest, WorksWithNativeArrayPassedByReference) {
class NativeArrayPassedAsPointerAndSize {
public:
NativeArrayPassedAsPointerAndSize() {}
MOCK_METHOD2(Helper, void(int* array, int size));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(NativeArrayPassedAsPointerAndSize);
};
TEST(ElementsAreTest, WorksWithNativeArrayPassedAsPointerAndSize) {
......@@ -550,7 +556,10 @@ TEST(MatcherMacroTest, Works) {
// Tests that the description string supplied to MATCHER() must be
// valid.
MATCHER(HasBadDescription, "Invalid%") { return true; }
MATCHER(HasBadDescription, "Invalid%") {
// Uses arg to suppress "unused parameter" warning.
return arg==arg;
}
TEST(MatcherMacroTest,
CreatingMatcherWithBadDescriptionGeneratesNonfatalFailure) {
......@@ -560,7 +569,7 @@ TEST(MatcherMacroTest,
"use \"%%\" instead of \"%\" to print \"%\".");
}
MATCHER(HasGoodDescription, "good") { return true; }
MATCHER(HasGoodDescription, "good") { return arg==arg; }
TEST(MatcherMacroTest, AcceptsValidDescription) {
const Matcher<int> m = HasGoodDescription();
......@@ -642,7 +651,7 @@ TEST(MatcherPMacroTest,
}
MATCHER_P(HasGoodDescription1, n, "good %(n)s") { return true; }
MATCHER_P(HasGoodDescription1, n, "good %(n)s") { return arg==arg; }
TEST(MatcherPMacroTest, AcceptsValidDescription) {
const Matcher<int> m = HasGoodDescription1(5);
......@@ -709,7 +718,7 @@ TEST(MatcherPnMacroTest,
MATCHER_P2(HasComplexDescription, foo, bar,
"is as complex as %(foo)s %(bar)s (i.e. %(*)s or %%%(foo)s!)") {
return true;
return arg==arg;
}
TEST(MatcherPnMacroTest, AcceptsValidDescription) {
......@@ -861,7 +870,7 @@ TEST(MatcherPnMacroTest, WorksForDifferentParameterTypes) {
MATCHER_P2(EqConcat, prefix, suffix, "") {
// The following lines promote the two parameters to desired types.
std::string prefix_str(prefix);
char suffix_char(suffix);
char suffix_char = static_cast<char>(suffix);
return arg == prefix_str + suffix_char;
}
......
test/gmock-internal-utils_test.cc
......@@ -819,7 +819,7 @@ TEST(CopyArrayTest, WorksForTwoDimensionalArrays) {
TEST(NativeArrayTest, ConstructorFromArrayWorks) {
const int a[3] = { 0, 1, 2 };
NativeArray<int> na(a, 3, kReference);
EXPECT_EQ(3, na.size());
EXPECT_EQ(3U, na.size());
EXPECT_EQ(a, na.begin());
}
......@@ -849,7 +849,7 @@ TEST(NativeArrayTest, TypeMembersAreCorrect) {
TEST(NativeArrayTest, MethodsWork) {
const int a[3] = { 0, 1, 2 };
NativeArray<int> na(a, 3, kCopy);
ASSERT_EQ(3, na.size());
ASSERT_EQ(3U, na.size());
EXPECT_EQ(3, na.end() - na.begin());
NativeArray<int>::const_iterator it = na.begin();
......@@ -875,7 +875,7 @@ TEST(NativeArrayTest, MethodsWork) {
TEST(NativeArrayTest, WorksForTwoDimensionalArray) {
const char a[2][3] = { "hi", "lo" };
NativeArray<char[3]> na(a, 2, kReference);
ASSERT_EQ(2, na.size());
ASSERT_EQ(2U, na.size());
EXPECT_EQ(a, na.begin());
}
......@@ -910,11 +910,11 @@ TEST(StlContainerViewTest, WorksForStaticNativeArray) {
int a1[3] = { 0, 1, 2 };
NativeArray<int> a2 = StlContainerView<int[3]>::ConstReference(a1);
EXPECT_EQ(3, a2.size());
EXPECT_EQ(3U, a2.size());
EXPECT_EQ(a1, a2.begin());
const NativeArray<int> a3 = StlContainerView<int[3]>::Copy(a1);
ASSERT_EQ(3, a3.size());
ASSERT_EQ(3U, a3.size());
EXPECT_EQ(0, a3.begin()[0]);
EXPECT_EQ(1, a3.begin()[1]);
EXPECT_EQ(2, a3.begin()[2]);
......@@ -937,12 +937,12 @@ TEST(StlContainerViewTest, WorksForDynamicNativeArray) {
const int* const p1 = a1;
NativeArray<int> a2 = StlContainerView<tuple<const int*, int> >::
ConstReference(make_tuple(p1, 3));
EXPECT_EQ(3, a2.size());
EXPECT_EQ(3U, a2.size());
EXPECT_EQ(a1, a2.begin());
const NativeArray<int> a3 = StlContainerView<tuple<int*, size_t> >::
Copy(make_tuple(static_cast<int*>(a1), 3));
ASSERT_EQ(3, a3.size());
ASSERT_EQ(3U, a3.size());
EXPECT_EQ(0, a3.begin()[0]);
EXPECT_EQ(1, a3.begin()[1]);
EXPECT_EQ(2, a3.begin()[2]);
......
test/gmock-matchers_test.cc
......@@ -152,8 +152,9 @@ class GreaterThanMatcher : public MatcherInterface<int> {
*os << "is " << -diff << " less than " << rhs_;
}
}
private:
const int rhs_;
int rhs_;
};
Matcher<int> GreaterThan(int n) {
......@@ -335,7 +336,7 @@ class IntValue {
public:
// An int can be statically (although not implicitly) cast to a
// IntValue.
explicit IntValue(int value) : value_(value) {}
explicit IntValue(int a_value) : value_(a_value) {}
int value() const { return value_; }
private:
......@@ -560,7 +561,7 @@ class Unprintable {
public:
Unprintable() : c_('a') {}
bool operator==(const Unprintable& rhs) { return true; }
bool operator==(const Unprintable& /* rhs */) { return true; }
private:
char c_;
};
......@@ -606,7 +607,7 @@ TEST(TypedEqTest, CanDescribeSelf) {
// "undefined referece".
template <typename T>
struct Type {
static bool IsTypeOf(const T& v) { return true; }
static bool IsTypeOf(const T& /* v */) { return true; }
template <typename T2>
static void IsTypeOf(T2 v);
......@@ -1861,8 +1862,9 @@ class IsGreaterThan {
explicit IsGreaterThan(int threshold) : threshold_(threshold) {}
bool operator()(int n) const { return n > threshold_; }
private:
const int threshold_;
int threshold_;
};
// For testing Truly().
......@@ -1959,7 +1961,12 @@ TEST(AllArgsTest, WorksForNonTuple) {
class AllArgsHelper {
public:
AllArgsHelper() {}
MOCK_METHOD2(Helper, int(char x, int y));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(AllArgsHelper);
};
TEST(AllArgsTest, WorksInWithClause) {
......@@ -2384,7 +2391,7 @@ TEST(PointeeTest, CanExplainMatchResult) {
// An uncopyable class.
class Uncopyable {
public:
explicit Uncopyable(int value) : value_(value) {}
explicit Uncopyable(int a_value) : value_(a_value) {}
int value() const { return value_; }
private:
......@@ -2405,11 +2412,17 @@ struct AStruct {
const double y; // A const field.
Uncopyable z; // An uncopyable field.
const char* p; // A pointer field.
private:
GTEST_DISALLOW_ASSIGN_(AStruct);
};
// A derived struct for testing Field().
struct DerivedStruct : public AStruct {
char ch;
private:
GTEST_DISALLOW_ASSIGN_(DerivedStruct);
};
// Tests that Field(&Foo::field, ...) works when field is non-const.
......@@ -2943,7 +2956,7 @@ TEST(ResultOfTest, WorksForReferencingCallables) {
class DivisibleByImpl {
public:
explicit DivisibleByImpl(int divider) : divider_(divider) {}
explicit DivisibleByImpl(int a_divider) : divider_(a_divider) {}
template <typename T>
bool Matches(const T& n) const {
......@@ -2958,7 +2971,7 @@ class DivisibleByImpl {
*os << "is not divisible by " << divider_;
}
void set_divider(int divider) { divider_ = divider; }
void set_divider(int a_divider) { divider_ = a_divider; }
int divider() const { return divider_; }
private:
......@@ -3021,7 +3034,7 @@ TEST(ExplainmatcherResultTest, MonomorphicMatcher) {
class NotCopyable {
public:
explicit NotCopyable(int value) : value_(value) {}
explicit NotCopyable(int a_value) : value_(a_value) {}
int value() const { return value_; }
......
test/gmock-more-actions_test.cc
......@@ -65,6 +65,10 @@ using testing::Unused;
using testing::WithArg;
using testing::WithoutArgs;
// For suppressing compiler warnings on conversion possibly losing precision.
inline short Short(short n) { return n; } // NOLINT
inline char Char(char ch) { return ch; }
// Sample functions and functors for testing Invoke() and etc.
int Nullary() { return 1; }
......@@ -85,7 +89,7 @@ bool Unary(int x) { return x < 0; }
const char* Plus1(const char* s) { return s + 1; }
void VoidUnary(int n) { g_done = true; }
void VoidUnary(int /* n */) { g_done = true; }
bool ByConstRef(const string& s) { return s == "Hi"; }
......@@ -239,13 +243,13 @@ TEST(InvokeTest, Unary) {
TEST(InvokeTest, Binary) {
Action<const char*(const char*, short)> a = Invoke(Binary); // NOLINT
const char* p = "Hello";
EXPECT_EQ(p + 2, a.Perform(make_tuple(p, 2)));
EXPECT_EQ(p + 2, a.Perform(make_tuple(p, Short(2))));
}
// Tests using Invoke() with a ternary function.
TEST(InvokeTest, Ternary) {
Action<int(int, char, short)> a = Invoke(Ternary); // NOLINT
EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', 3)));
EXPECT_EQ(6, a.Perform(make_tuple(1, '\2', Short(3))));
}
// Tests using Invoke() with a 4-argument function.
......@@ -340,14 +344,14 @@ TEST(InvokeTest, MethodWithUnusedParameters) {
// Tests using Invoke() with a functor.
TEST(InvokeTest, Functor) {
Action<int(short, char)> a = Invoke(plus<short>()); // NOLINT
EXPECT_EQ(3, a.Perform(make_tuple(1, 2)));
Action<long(long, int)> a = Invoke(plus<long>()); // NOLINT
EXPECT_EQ(3L, a.Perform(make_tuple(1, 2)));
}
// Tests using Invoke(f) as an action of a compatible type.
TEST(InvokeTest, FunctionWithCompatibleType) {
Action<long(int, short, char, bool)> a = Invoke(SumOf4); // NOLINT
EXPECT_EQ(4321, a.Perform(make_tuple(4000, 300, 20, true)));
EXPECT_EQ(4321, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
}
// Tests using Invoke() with an object pointer and a method pointer.
......@@ -378,7 +382,7 @@ TEST(InvokeMethodTest, Binary) {
TEST(InvokeMethodTest, Ternary) {
Foo foo;
Action<int(int, bool, char)> a = Invoke(&foo, &Foo::Ternary); // NOLINT
EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, 1)));
EXPECT_EQ(1124, a.Perform(make_tuple(1000, true, Char(1))));
}
// Tests using Invoke() with a 4-argument method.
......@@ -457,7 +461,7 @@ TEST(InvokeMethodTest, MethodWithCompatibleType) {
Foo foo;
Action<long(int, short, char, bool)> a = // NOLINT
Invoke(&foo, &Foo::SumOf4);
EXPECT_EQ(4444, a.Perform(make_tuple(4000, 300, 20, true)));
EXPECT_EQ(4444, a.Perform(make_tuple(4000, Short(300), Char(20), true)));
}
// Tests using WithoutArgs with an action that takes no argument.
......
test/gmock-nice-strict_test.cc
......@@ -40,7 +40,12 @@
// clash with ::testing::Mock.
class Mock {
public:
Mock() {}
MOCK_METHOD0(DoThis, void());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
};
namespace testing {
......@@ -64,10 +69,14 @@ class Foo {
class MockFoo : public Foo {
public:
MockFoo() {}
void Delete() { delete this; }
MOCK_METHOD0(DoThis, void());
MOCK_METHOD1(DoThat, int(bool flag));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
};
class MockBar {
......@@ -89,6 +98,8 @@ class MockBar {
private:
string str_;
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockBar);
};
// TODO(wan@google.com): find a way to re-enable these tests.
......
test/gmock-port_test.cc
......@@ -85,7 +85,7 @@ class Castable {
}
private:
bool* const converted_;
bool* converted_;
};
TEST(ImplicitCastTest, CanUseNonConstCastOperator) {
......@@ -104,7 +104,7 @@ class ConstCastable {
}
private:
bool* const converted_;
bool* converted_;
};
TEST(ImplicitCastTest, CanUseConstCastOperatorOnConstValues) {
......@@ -128,8 +128,8 @@ class ConstAndNonConstCastable {
}
private:
bool* const converted_;
bool* const const_converted_;
bool* converted_;
bool* const_converted_;
};
TEST(ImplicitCastTest, CanSelectBetweenConstAndNonConstCasrAppropriately) {
......
test/gmock-printers_test.cc
......@@ -77,7 +77,7 @@ class StreamableInGlobal {
virtual ~StreamableInGlobal() {}
};
inline void operator<<(::std::ostream& os, const StreamableInGlobal& x) {
inline void operator<<(::std::ostream& os, const StreamableInGlobal& /* x */) {
os << "StreamableInGlobal";
}
......@@ -107,7 +107,7 @@ void PrintTo(const PrintableViaPrintTo& x, ::std::ostream* os) {
template <typename T>
class PrintableViaPrintToTemplate {
public:
explicit PrintableViaPrintToTemplate(const T& value) : value_(value) {}
explicit PrintableViaPrintToTemplate(const T& a_value) : value_(a_value) {}
const T& value() const { return value_; }
private:
......@@ -440,7 +440,7 @@ TEST(PrintPointerToPointerTest, IntPointerPointer) {
// Tests printing (non-member) function pointers.
void MyFunction(int n) {}
void MyFunction(int /* n */) {}
TEST(PrintPointerTest, NonMemberFunctionPointer) {
// We cannot directly cast &MyFunction to const void* because the
......@@ -464,7 +464,7 @@ struct Foo {
public:
virtual ~Foo() {}
int MyMethod(char x) { return x + 1; }
virtual char MyVirtualMethod(int n) { return 'a'; }
virtual char MyVirtualMethod(int /* n */) { return 'a'; }
int value;
};
......@@ -603,7 +603,7 @@ class AllowsGenericStreaming {};
template <typename Char, typename CharTraits>
std::basic_ostream<Char, CharTraits>& operator<<(
std::basic_ostream<Char, CharTraits>& os,
const AllowsGenericStreaming& a) {
const AllowsGenericStreaming& /* a */) {
return os << "AllowsGenericStreaming";
}
......@@ -620,7 +620,7 @@ class AllowsGenericStreamingTemplate {};
template <typename Char, typename CharTraits, typename T>
std::basic_ostream<Char, CharTraits>& operator<<(
std::basic_ostream<Char, CharTraits>& os,
const AllowsGenericStreamingTemplate<T>& a) {
const AllowsGenericStreamingTemplate<T>& /* a */) {
return os << "AllowsGenericStreamingTemplate";
}
......@@ -641,7 +641,7 @@ class AllowsGenericStreamingAndImplicitConversionTemplate {
template <typename Char, typename CharTraits, typename T>
std::basic_ostream<Char, CharTraits>& operator<<(
std::basic_ostream<Char, CharTraits>& os,
const AllowsGenericStreamingAndImplicitConversionTemplate<T>& a) {
const AllowsGenericStreamingAndImplicitConversionTemplate<T>& /* a */) {
return os << "AllowsGenericStreamingAndImplicitConversionTemplate";
}
......
test/gmock-spec-builders_test.cc
......@@ -97,16 +97,26 @@ class Result {};
class MockA {
public:
MockA() {}
MOCK_METHOD1(DoA, void(int n)); // NOLINT
MOCK_METHOD1(ReturnResult, Result(int n)); // NOLINT
MOCK_METHOD2(Binary, bool(int x, int y)); // NOLINT
MOCK_METHOD2(ReturnInt, int(int x, int y)); // NOLINT
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockA);
};
class MockB {
public:
MockB() {}
MOCK_CONST_METHOD0(DoB, int()); // NOLINT
MOCK_METHOD1(DoB, int(int n)); // NOLINT
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockB);
};
// Tests that EXPECT_CALL and ON_CALL compile in a presence of macro
......@@ -123,7 +133,12 @@ class CC {
};
class MockCC : public CC {
public:
MockCC() {}
MOCK_METHOD0(Method, int());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockCC);
};
// Tests that a method with expanded name compiles.
......@@ -1617,8 +1632,19 @@ TEST(DeletingMockEarlyTest, Success2) {
// Tests that it's OK to delete a mock object itself in its action.
// Suppresses warning on unreferenced formal parameter in MSVC with
// -W4.
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4100)
#endif
ACTION_P(Delete, ptr) { delete ptr; }
#ifdef _MSC_VER
#pragma warning(pop)
#endif
TEST(DeletingMockEarlyTest, CanDeleteSelfInActionReturningVoid) {
MockA* const a = new MockA;
EXPECT_CALL(*a, DoA(_)).WillOnce(Delete(a));
......@@ -1691,7 +1717,9 @@ class EvenNumberCardinality : public CardinalityInterface {
}
// Returns true iff call_count calls will saturate this cardinality.
virtual bool IsSaturatedByCallCount(int call_count) const { return false; }
virtual bool IsSaturatedByCallCount(int /* call_count */) const {
return false;
}
// Describes self to an ostream.
virtual void DescribeTo(::std::ostream* os) const {
......@@ -1740,9 +1768,14 @@ struct Unprintable {
class MockC {
public:
MockC() {}
MOCK_METHOD6(VoidMethod, void(bool cond, int n, string s, void* p,
const Printable& x, Unprintable y));
MOCK_METHOD0(NonVoidMethod, int()); // NOLINT
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockC);
};
// TODO(wan@google.com): find a way to re-enable these tests.
......@@ -1935,7 +1968,12 @@ void PrintTo(PrintMeNot /* dummy */, ::std::ostream* /* os */) {
class LogTestHelper {
public:
LogTestHelper() {}
MOCK_METHOD1(Foo, PrintMeNot(PrintMeNot));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(LogTestHelper);
};
class GMockLogTest : public ::testing::Test {
......
test/gmock_leak_test_.cc
......@@ -48,7 +48,12 @@ class FooInterface {
class MockFoo : public FooInterface {
public:
MockFoo() {}
MOCK_METHOD0(DoThis, void());
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
};
TEST(LeakTest, LeakedMockWithExpectCallCausesFailureWhenLeakCheckingIsEnabled) {
......
test/gmock_link_test.h
......@@ -206,6 +206,8 @@ class Interface {
class Mock: public Interface {
public:
Mock() {}
MOCK_METHOD1(VoidFromString, void(char* str));
MOCK_METHOD1(StringFromString, char*(char* str));
MOCK_METHOD1(IntFromString, int(char* str));
......@@ -215,6 +217,9 @@ class Mock: public Interface {
MOCK_METHOD1(VoidFromFloat, void(float n));
MOCK_METHOD1(VoidFromDouble, void(double n));
MOCK_METHOD1(VoidFromVector, void(const std::vector<int>& v));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(Mock);
};
class InvokeHelper {
......@@ -229,7 +234,7 @@ class InvokeHelper {
class FieldHelper {
public:
FieldHelper(int field) : field_(field) {}
FieldHelper(int a_field) : field_(a_field) {}
int field() const { return field_; }
int field_; // NOLINT -- need external access to field_ to test
// the Field matcher.
......@@ -410,6 +415,16 @@ TEST(LinkTest, TestThrow) {
}
#endif // GTEST_HAS_EXCEPTIONS
// The ACTION*() macros trigger warning C4100 (unreferenced formal
// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in
// the macro definition, as the warnings are generated when the macro
// is expanded and macro expansion cannot contain #pragma. Therefore
// we suppress them here.
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4100)
#endif
// Tests the linkage of actions created using ACTION macro.
namespace {
ACTION(Return1) { return 1; }
......@@ -441,6 +456,10 @@ ACTION_P2(ReturnEqualsEitherOf, first, second) {
}
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
TEST(LinkTest, TestActionP2Macro) {
Mock mock;
char ch = 'x';
......
test/gmock_output_test_.cc
......@@ -49,9 +49,14 @@ using testing::Sequence;
class MockFoo {
public:
MockFoo() {}
MOCK_METHOD3(Bar, char(const std::string& s, int i, double x));
MOCK_METHOD2(Bar2, bool(int x, int y));
MOCK_METHOD2(Bar3, void(int x, int y));
private:
GTEST_DISALLOW_COPY_AND_ASSIGN_(MockFoo);
};
class GMockOutputTest : public testing::Test {
......
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