From 32de5f53763125925e078498250f7e73a88de9ed Mon Sep 17 00:00:00 2001 From: "zhanyong.wan" Date: Wed, 23 Dec 2009 00:13:23 +0000 Subject: Fixes a slew of compiler warnings and turns on "warning as error" in the scons build. --- test/gmock-actions_test.cc | 31 +++++++++++-------- test/gmock-cardinalities_test.cc | 8 ++++- test/gmock-generated-actions_test.cc | 44 +++++++++++++++++++-------- test/gmock-generated-function-mockers_test.cc | 30 ++++++++++++++++++ test/gmock-generated-matchers_test.cc | 23 +++++++++----- test/gmock-internal-utils_test.cc | 14 ++++----- test/gmock-matchers_test.cc | 31 +++++++++++++------ test/gmock-more-actions_test.cc | 20 +++++++----- test/gmock-nice-strict_test.cc | 11 +++++++ test/gmock-port_test.cc | 8 ++--- test/gmock-printers_test.cc | 14 ++++----- test/gmock-spec-builders_test.cc | 40 +++++++++++++++++++++++- test/gmock_leak_test_.cc | 5 +++ test/gmock_link_test.h | 21 ++++++++++++- test/gmock_output_test_.cc | 5 +++ 15 files changed, 235 insertions(+), 70 deletions(-) (limited to 'test') diff --git a/test/gmock-actions_test.cc b/test/gmock-actions_test.cc index ea3c3100..a2c6fe11 100644 --- a/test/gmock-actions_test.cc +++ b/test/gmock-actions_test.cc @@ -95,26 +95,26 @@ TEST(BuiltInDefaultValueTest, ExistsForPointerTypes) { // Tests that BuiltInDefaultValue::Get() returns 0 when T is a // built-in numeric type. TEST(BuiltInDefaultValueTest, IsZeroForNumericTypes) { - EXPECT_EQ(0, BuiltInDefaultValue::Get()); + EXPECT_EQ(0U, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::Get()); #if GMOCK_HAS_SIGNED_WCHAR_T_ - EXPECT_EQ(0, BuiltInDefaultValue::Get()); + EXPECT_EQ(0U, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::Get()); #endif #if GMOCK_WCHAR_T_IS_NATIVE_ EXPECT_EQ(0, BuiltInDefaultValue::Get()); #endif - EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT + EXPECT_EQ(0U, BuiltInDefaultValue::Get()); // NOLINT EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0, BuiltInDefaultValue::Get()); + EXPECT_EQ(0U, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::Get()); - EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT + EXPECT_EQ(0U, BuiltInDefaultValue::Get()); // NOLINT EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT EXPECT_EQ(0, BuiltInDefaultValue::Get()); // NOLINT - EXPECT_EQ(0, BuiltInDefaultValue::Get()); + EXPECT_EQ(0U, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::Get()); EXPECT_EQ(0, BuiltInDefaultValue::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 a2 = InvokeWithoutArgs(Nullary); // NOLINT + Action 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 a2 = // NOLINT + Action 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(); } diff --git a/test/gmock-cardinalities_test.cc b/test/gmock-cardinalities_test.cc index f3f1e106..f6a94916 100644 --- a/test/gmock-cardinalities_test.cc +++ b/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 { diff --git a/test/gmock-generated-actions_test.cc b/test/gmock-generated-actions_test.cc index 2e6fa0b6..3c076d7c 100644 --- a/test/gmock-generated-actions_test.cc +++ b/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 a = // NOLINT - InvokeArgument<0>(static_cast("Hi"), 1); + InvokeArgument<0>(static_cast("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 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 a = + Action 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 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 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 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 a = // NOLINT + Action 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 a1 = Sum2(); int dummy = 0; - EXPECT_EQ(11, a1.Perform(make_tuple(5, static_cast(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 a1 = TypedPlus(9); - EXPECT_EQ(10, a1.Perform(make_tuple(static_cast(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(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 diff --git a/test/gmock-generated-function-mockers_test.cc b/test/gmock-generated-function-mockers_test.cc index 1ce8c451..5d839c41 100644 --- a/test/gmock-generated-function-mockers_test.cc +++ b/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 class MockStack : public StackInterface { 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 class MockStackWithCallType : public StackInterfaceWithCallType { 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) { diff --git a/test/gmock-generated-matchers_test.cc b/test/gmock-generated-matchers_test.cc index 19024d0d..41413055 100644 --- a/test/gmock-generated-matchers_test.cc +++ b/test/gmock-generated-matchers_test.cc @@ -223,8 +223,9 @@ class GreaterThanMatcher : public MatcherInterface { *os << "is " << -diff << " less than " << rhs_; } } + private: - const int rhs_; + int rhs_; }; Matcher GreaterThan(int n) { @@ -411,7 +412,7 @@ TEST(ElementsAreTest, WorksForNestedContainer) { }; vector > 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(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 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 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(suffix); return arg == prefix_str + suffix_char; } diff --git a/test/gmock-internal-utils_test.cc b/test/gmock-internal-utils_test.cc index ac3b2dd2..7dd83115 100644 --- a/test/gmock-internal-utils_test.cc +++ b/test/gmock-internal-utils_test.cc @@ -819,7 +819,7 @@ TEST(CopyArrayTest, WorksForTwoDimensionalArrays) { TEST(NativeArrayTest, ConstructorFromArrayWorks) { const int a[3] = { 0, 1, 2 }; NativeArray 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 na(a, 3, kCopy); - ASSERT_EQ(3, na.size()); + ASSERT_EQ(3U, na.size()); EXPECT_EQ(3, na.end() - na.begin()); NativeArray::const_iterator it = na.begin(); @@ -875,7 +875,7 @@ TEST(NativeArrayTest, MethodsWork) { TEST(NativeArrayTest, WorksForTwoDimensionalArray) { const char a[2][3] = { "hi", "lo" }; NativeArray 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 a2 = StlContainerView::ConstReference(a1); - EXPECT_EQ(3, a2.size()); + EXPECT_EQ(3U, a2.size()); EXPECT_EQ(a1, a2.begin()); const NativeArray a3 = StlContainerView::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 a2 = StlContainerView >:: ConstReference(make_tuple(p1, 3)); - EXPECT_EQ(3, a2.size()); + EXPECT_EQ(3U, a2.size()); EXPECT_EQ(a1, a2.begin()); const NativeArray a3 = StlContainerView >:: Copy(make_tuple(static_cast(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]); diff --git a/test/gmock-matchers_test.cc b/test/gmock-matchers_test.cc index 919ce651..907749d1 100644 --- a/test/gmock-matchers_test.cc +++ b/test/gmock-matchers_test.cc @@ -152,8 +152,9 @@ class GreaterThanMatcher : public MatcherInterface { *os << "is " << -diff << " less than " << rhs_; } } + private: - const int rhs_; + int rhs_; }; Matcher 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 struct Type { - static bool IsTypeOf(const T& v) { return true; } + static bool IsTypeOf(const T& /* v */) { return true; } template 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 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_; } diff --git a/test/gmock-more-actions_test.cc b/test/gmock-more-actions_test.cc index f5dab5bf..b3b17d33 100644 --- a/test/gmock-more-actions_test.cc +++ b/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 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 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 a = Invoke(plus()); // NOLINT - EXPECT_EQ(3, a.Perform(make_tuple(1, 2))); + Action a = Invoke(plus()); // 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 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 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 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. diff --git a/test/gmock-nice-strict_test.cc b/test/gmock-nice-strict_test.cc index faf0145b..1d36e03e 100644 --- a/test/gmock-nice-strict_test.cc +++ b/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. diff --git a/test/gmock-port_test.cc b/test/gmock-port_test.cc index b2afb932..054313b7 100644 --- a/test/gmock-port_test.cc +++ b/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) { diff --git a/test/gmock-printers_test.cc b/test/gmock-printers_test.cc index abfa923c..0553e9ce 100644 --- a/test/gmock-printers_test.cc +++ b/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 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 std::basic_ostream& operator<<( std::basic_ostream& os, - const AllowsGenericStreaming& a) { + const AllowsGenericStreaming& /* a */) { return os << "AllowsGenericStreaming"; } @@ -620,7 +620,7 @@ class AllowsGenericStreamingTemplate {}; template std::basic_ostream& operator<<( std::basic_ostream& os, - const AllowsGenericStreamingTemplate& a) { + const AllowsGenericStreamingTemplate& /* a */) { return os << "AllowsGenericStreamingTemplate"; } @@ -641,7 +641,7 @@ class AllowsGenericStreamingAndImplicitConversionTemplate { template std::basic_ostream& operator<<( std::basic_ostream& os, - const AllowsGenericStreamingAndImplicitConversionTemplate& a) { + const AllowsGenericStreamingAndImplicitConversionTemplate& /* a */) { return os << "AllowsGenericStreamingAndImplicitConversionTemplate"; } diff --git a/test/gmock-spec-builders_test.cc b/test/gmock-spec-builders_test.cc index 5fd97112..c1e77381 100644 --- a/test/gmock-spec-builders_test.cc +++ b/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 { diff --git a/test/gmock_leak_test_.cc b/test/gmock_leak_test_.cc index 157bd7ec..24dfc1ff 100644 --- a/test/gmock_leak_test_.cc +++ b/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) { diff --git a/test/gmock_link_test.h b/test/gmock_link_test.h index 40554bfe..d9635907 100644 --- a/test/gmock_link_test.h +++ b/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& 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'; diff --git a/test/gmock_output_test_.cc b/test/gmock_output_test_.cc index c33dc6fb..24c9b383 100644 --- a/test/gmock_output_test_.cc +++ b/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 { -- cgit v1.2.3