From 6b50058889099e4287f683b97a86ca74607172c4 Mon Sep 17 00:00:00 2001 From: Jeff McGlynn Date: Thu, 26 Jul 2018 13:08:01 -0700 Subject: Remove third_party/googletest and reference git repo instead Use a Bazel git_repository rule to reference the git repository instead of bundling the source. Change-Id: I32a0970178cb87fbf0e381db2e2d51fcccab542f --- .../googlemock/test/gmock-internal-utils_test.cc | 718 --------------------- 1 file changed, 718 deletions(-) delete mode 100644 third_party/googletest/googlemock/test/gmock-internal-utils_test.cc (limited to 'third_party/googletest/googlemock/test/gmock-internal-utils_test.cc') diff --git a/third_party/googletest/googlemock/test/gmock-internal-utils_test.cc b/third_party/googletest/googlemock/test/gmock-internal-utils_test.cc deleted file mode 100644 index f8633df..0000000 --- a/third_party/googletest/googlemock/test/gmock-internal-utils_test.cc +++ /dev/null @@ -1,718 +0,0 @@ -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Author: wan@google.com (Zhanyong Wan) - -// Google Mock - a framework for writing C++ mock classes. -// -// This file tests the internal utilities. - -#include "gmock/internal/gmock-internal-utils.h" -#include -#include -#include -#include -#include -#include -#include "gmock/gmock.h" -#include "gmock/internal/gmock-port.h" -#include "gtest/gtest.h" -#include "gtest/gtest-spi.h" - -// Indicates that this translation unit is part of Google Test's -// implementation. It must come before gtest-internal-inl.h is -// included, or there will be a compiler error. This trick is to -// prevent a user from accidentally including gtest-internal-inl.h in -// their code. -#define GTEST_IMPLEMENTATION_ 1 -#include "src/gtest-internal-inl.h" -#undef GTEST_IMPLEMENTATION_ - -#if GTEST_OS_CYGWIN -# include // For ssize_t. NOLINT -#endif - -class ProtocolMessage; - -namespace proto2 { -class Message; -} // namespace proto2 - -namespace testing { -namespace internal { - -namespace { - -TEST(JoinAsTupleTest, JoinsEmptyTuple) { - EXPECT_EQ("", JoinAsTuple(Strings())); -} - -TEST(JoinAsTupleTest, JoinsOneTuple) { - const char* fields[] = {"1"}; - EXPECT_EQ("1", JoinAsTuple(Strings(fields, fields + 1))); -} - -TEST(JoinAsTupleTest, JoinsTwoTuple) { - const char* fields[] = {"1", "a"}; - EXPECT_EQ("(1, a)", JoinAsTuple(Strings(fields, fields + 2))); -} - -TEST(JoinAsTupleTest, JoinsTenTuple) { - const char* fields[] = {"1", "2", "3", "4", "5", "6", "7", "8", "9", "10"}; - EXPECT_EQ("(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)", - JoinAsTuple(Strings(fields, fields + 10))); -} - -TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsNoWord) { - EXPECT_EQ("", ConvertIdentifierNameToWords("")); - EXPECT_EQ("", ConvertIdentifierNameToWords("_")); - EXPECT_EQ("", ConvertIdentifierNameToWords("__")); -} - -TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsDigits) { - EXPECT_EQ("1", ConvertIdentifierNameToWords("_1")); - EXPECT_EQ("2", ConvertIdentifierNameToWords("2_")); - EXPECT_EQ("34", ConvertIdentifierNameToWords("_34_")); - EXPECT_EQ("34 56", ConvertIdentifierNameToWords("_34_56")); -} - -TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContainsCamelCaseWords) { - EXPECT_EQ("a big word", ConvertIdentifierNameToWords("ABigWord")); - EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("FooBar")); - EXPECT_EQ("foo", ConvertIdentifierNameToWords("Foo_")); - EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_Foo_Bar_")); - EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_Foo__And_Bar")); -} - -TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameContains_SeparatedWords) { - EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("foo_bar")); - EXPECT_EQ("foo", ConvertIdentifierNameToWords("_foo_")); - EXPECT_EQ("foo bar", ConvertIdentifierNameToWords("_foo_bar_")); - EXPECT_EQ("foo and bar", ConvertIdentifierNameToWords("_foo__and_bar")); -} - -TEST(ConvertIdentifierNameToWordsTest, WorksWhenNameIsMixture) { - EXPECT_EQ("foo bar 123", ConvertIdentifierNameToWords("Foo_bar123")); - EXPECT_EQ("chapter 11 section 1", - ConvertIdentifierNameToWords("_Chapter11Section_1_")); -} - -TEST(PointeeOfTest, WorksForSmartPointers) { - CompileAssertTypesEqual >::type>(); -#if GTEST_HAS_STD_UNIQUE_PTR_ - CompileAssertTypesEqual >::type>(); -#endif // GTEST_HAS_STD_UNIQUE_PTR_ -#if GTEST_HAS_STD_SHARED_PTR_ - CompileAssertTypesEqual >::type>(); -#endif // GTEST_HAS_STD_SHARED_PTR_ -} - -TEST(PointeeOfTest, WorksForRawPointers) { - CompileAssertTypesEqual::type>(); - CompileAssertTypesEqual::type>(); - CompileAssertTypesEqual::type>(); -} - -TEST(GetRawPointerTest, WorksForSmartPointers) { -#if GTEST_HAS_STD_UNIQUE_PTR_ - const char* const raw_p1 = new const char('a'); // NOLINT - const std::unique_ptr p1(raw_p1); - EXPECT_EQ(raw_p1, GetRawPointer(p1)); -#endif // GTEST_HAS_STD_UNIQUE_PTR_ -#if GTEST_HAS_STD_SHARED_PTR_ - double* const raw_p2 = new double(2.5); // NOLINT - const std::shared_ptr p2(raw_p2); - EXPECT_EQ(raw_p2, GetRawPointer(p2)); -#endif // GTEST_HAS_STD_SHARED_PTR_ - - const char* const raw_p4 = new const char('a'); // NOLINT - const internal::linked_ptr p4(raw_p4); - EXPECT_EQ(raw_p4, GetRawPointer(p4)); -} - -TEST(GetRawPointerTest, WorksForRawPointers) { - int* p = NULL; - // Don't use EXPECT_EQ as no NULL-testing magic on Symbian. - EXPECT_TRUE(NULL == GetRawPointer(p)); - int n = 1; - EXPECT_EQ(&n, GetRawPointer(&n)); -} - -// Tests KindOf. - -class Base {}; -class Derived : public Base {}; - -TEST(KindOfTest, Bool) { - EXPECT_EQ(kBool, GMOCK_KIND_OF_(bool)); // NOLINT -} - -TEST(KindOfTest, Integer) { - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(char)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(signed char)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned char)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(short)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned short)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(int)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned int)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(long)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(unsigned long)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(wchar_t)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(Int64)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(UInt64)); // NOLINT - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(size_t)); // NOLINT -#if GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN - // ssize_t is not defined on Windows and possibly some other OSes. - EXPECT_EQ(kInteger, GMOCK_KIND_OF_(ssize_t)); // NOLINT -#endif -} - -TEST(KindOfTest, FloatingPoint) { - EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(float)); // NOLINT - EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(double)); // NOLINT - EXPECT_EQ(kFloatingPoint, GMOCK_KIND_OF_(long double)); // NOLINT -} - -TEST(KindOfTest, Other) { - EXPECT_EQ(kOther, GMOCK_KIND_OF_(void*)); // NOLINT - EXPECT_EQ(kOther, GMOCK_KIND_OF_(char**)); // NOLINT - EXPECT_EQ(kOther, GMOCK_KIND_OF_(Base)); // NOLINT -} - -// Tests LosslessArithmeticConvertible. - -TEST(LosslessArithmeticConvertibleTest, BoolToBool) { - EXPECT_TRUE((LosslessArithmeticConvertible::value)); -} - -TEST(LosslessArithmeticConvertibleTest, BoolToInteger) { - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE( - (LosslessArithmeticConvertible::value)); // NOLINT -} - -TEST(LosslessArithmeticConvertibleTest, BoolToFloatingPoint) { - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE((LosslessArithmeticConvertible::value)); -} - -TEST(LosslessArithmeticConvertibleTest, IntegerToBool) { - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - EXPECT_FALSE((LosslessArithmeticConvertible::value)); -} - -TEST(LosslessArithmeticConvertibleTest, IntegerToInteger) { - // Unsigned => larger signed is fine. - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - - // Unsigned => larger unsigned is fine. - EXPECT_TRUE( - (LosslessArithmeticConvertible::value)); // NOLINT - - // Signed => unsigned is not fine. - EXPECT_FALSE((LosslessArithmeticConvertible::value)); // NOLINT - EXPECT_FALSE((LosslessArithmeticConvertible< - signed char, unsigned int>::value)); // NOLINT - - // Same size and same signedness: fine too. - EXPECT_TRUE((LosslessArithmeticConvertible< - unsigned char, unsigned char>::value)); - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE((LosslessArithmeticConvertible< - unsigned long, unsigned long>::value)); // NOLINT - - // Same size, different signedness: not fine. - EXPECT_FALSE((LosslessArithmeticConvertible< - unsigned char, signed char>::value)); - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - - // Larger size => smaller size is not fine. - EXPECT_FALSE((LosslessArithmeticConvertible::value)); // NOLINT - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - EXPECT_FALSE((LosslessArithmeticConvertible::value)); -} - -TEST(LosslessArithmeticConvertibleTest, IntegerToFloatingPoint) { - // Integers cannot be losslessly converted to floating-points, as - // the format of the latter is implementation-defined. - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - EXPECT_FALSE((LosslessArithmeticConvertible< - short, long double>::value)); // NOLINT -} - -TEST(LosslessArithmeticConvertibleTest, FloatingPointToBool) { - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - EXPECT_FALSE((LosslessArithmeticConvertible::value)); -} - -TEST(LosslessArithmeticConvertibleTest, FloatingPointToInteger) { - EXPECT_FALSE((LosslessArithmeticConvertible::value)); // NOLINT - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - EXPECT_FALSE((LosslessArithmeticConvertible::value)); -} - -TEST(LosslessArithmeticConvertibleTest, FloatingPointToFloatingPoint) { - // Smaller size => larger size is fine. - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - - // Same size: fine. - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - - // Larger size => smaller size is not fine. - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - GTEST_INTENTIONAL_CONST_COND_PUSH_() - if (sizeof(double) == sizeof(long double)) { // NOLINT - GTEST_INTENTIONAL_CONST_COND_POP_() - // In some implementations (e.g. MSVC), double and long double - // have the same size. - EXPECT_TRUE((LosslessArithmeticConvertible::value)); - } else { - EXPECT_FALSE((LosslessArithmeticConvertible::value)); - } -} - -// Tests the TupleMatches() template function. - -TEST(TupleMatchesTest, WorksForSize0) { - tuple<> matchers; - tuple<> values; - - EXPECT_TRUE(TupleMatches(matchers, values)); -} - -TEST(TupleMatchesTest, WorksForSize1) { - tuple > matchers(Eq(1)); - tuple values1(1), - values2(2); - - EXPECT_TRUE(TupleMatches(matchers, values1)); - EXPECT_FALSE(TupleMatches(matchers, values2)); -} - -TEST(TupleMatchesTest, WorksForSize2) { - tuple, Matcher > matchers(Eq(1), Eq('a')); - tuple values1(1, 'a'), - values2(1, 'b'), - values3(2, 'a'), - values4(2, 'b'); - - EXPECT_TRUE(TupleMatches(matchers, values1)); - EXPECT_FALSE(TupleMatches(matchers, values2)); - EXPECT_FALSE(TupleMatches(matchers, values3)); - EXPECT_FALSE(TupleMatches(matchers, values4)); -} - -TEST(TupleMatchesTest, WorksForSize5) { - tuple, Matcher, Matcher, Matcher, // NOLINT - Matcher > - matchers(Eq(1), Eq('a'), Eq(true), Eq(2L), Eq("hi")); - tuple // NOLINT - values1(1, 'a', true, 2L, "hi"), values2(1, 'a', true, 2L, "hello"), - values3(2, 'a', true, 2L, "hi"); - - EXPECT_TRUE(TupleMatches(matchers, values1)); - EXPECT_FALSE(TupleMatches(matchers, values2)); - EXPECT_FALSE(TupleMatches(matchers, values3)); -} - -// Tests that Assert(true, ...) succeeds. -TEST(AssertTest, SucceedsOnTrue) { - Assert(true, __FILE__, __LINE__, "This should succeed."); - Assert(true, __FILE__, __LINE__); // This should succeed too. -} - -// Tests that Assert(false, ...) generates a fatal failure. -TEST(AssertTest, FailsFatallyOnFalse) { - EXPECT_DEATH_IF_SUPPORTED({ - Assert(false, __FILE__, __LINE__, "This should fail."); - }, ""); - - EXPECT_DEATH_IF_SUPPORTED({ - Assert(false, __FILE__, __LINE__); - }, ""); -} - -// Tests that Expect(true, ...) succeeds. -TEST(ExpectTest, SucceedsOnTrue) { - Expect(true, __FILE__, __LINE__, "This should succeed."); - Expect(true, __FILE__, __LINE__); // This should succeed too. -} - -// Tests that Expect(false, ...) generates a non-fatal failure. -TEST(ExpectTest, FailsNonfatallyOnFalse) { - EXPECT_NONFATAL_FAILURE({ // NOLINT - Expect(false, __FILE__, __LINE__, "This should fail."); - }, "This should fail"); - - EXPECT_NONFATAL_FAILURE({ // NOLINT - Expect(false, __FILE__, __LINE__); - }, "Expectation failed"); -} - -// Tests LogIsVisible(). - -class LogIsVisibleTest : public ::testing::Test { - protected: - virtual void SetUp() { - original_verbose_ = GMOCK_FLAG(verbose); - } - - virtual void TearDown() { GMOCK_FLAG(verbose) = original_verbose_; } - - std::string original_verbose_; -}; - -TEST_F(LogIsVisibleTest, AlwaysReturnsTrueIfVerbosityIsInfo) { - GMOCK_FLAG(verbose) = kInfoVerbosity; - EXPECT_TRUE(LogIsVisible(kInfo)); - EXPECT_TRUE(LogIsVisible(kWarning)); -} - -TEST_F(LogIsVisibleTest, AlwaysReturnsFalseIfVerbosityIsError) { - GMOCK_FLAG(verbose) = kErrorVerbosity; - EXPECT_FALSE(LogIsVisible(kInfo)); - EXPECT_FALSE(LogIsVisible(kWarning)); -} - -TEST_F(LogIsVisibleTest, WorksWhenVerbosityIsWarning) { - GMOCK_FLAG(verbose) = kWarningVerbosity; - EXPECT_FALSE(LogIsVisible(kInfo)); - EXPECT_TRUE(LogIsVisible(kWarning)); -} - -#if GTEST_HAS_STREAM_REDIRECTION - -// Tests the Log() function. - -// Verifies that Log() behaves correctly for the given verbosity level -// and log severity. -void TestLogWithSeverity(const std::string& verbosity, LogSeverity severity, - bool should_print) { - const std::string old_flag = GMOCK_FLAG(verbose); - GMOCK_FLAG(verbose) = verbosity; - CaptureStdout(); - Log(severity, "Test log.\n", 0); - if (should_print) { - EXPECT_THAT(GetCapturedStdout().c_str(), - ContainsRegex( - severity == kWarning ? - "^\nGMOCK WARNING:\nTest log\\.\nStack trace:\n" : - "^\nTest log\\.\nStack trace:\n")); - } else { - EXPECT_STREQ("", GetCapturedStdout().c_str()); - } - GMOCK_FLAG(verbose) = old_flag; -} - -// Tests that when the stack_frames_to_skip parameter is negative, -// Log() doesn't include the stack trace in the output. -TEST(LogTest, NoStackTraceWhenStackFramesToSkipIsNegative) { - const std::string saved_flag = GMOCK_FLAG(verbose); - GMOCK_FLAG(verbose) = kInfoVerbosity; - CaptureStdout(); - Log(kInfo, "Test log.\n", -1); - EXPECT_STREQ("\nTest log.\n", GetCapturedStdout().c_str()); - GMOCK_FLAG(verbose) = saved_flag; -} - -struct MockStackTraceGetter : testing::internal::OsStackTraceGetterInterface { - virtual std::string CurrentStackTrace(int max_depth, int skip_count) { - return (testing::Message() << max_depth << "::" << skip_count << "\n") - .GetString(); - } - virtual void UponLeavingGTest() {} -}; - -// Tests that in opt mode, a positive stack_frames_to_skip argument is -// treated as 0. -TEST(LogTest, NoSkippingStackFrameInOptMode) { - MockStackTraceGetter* mock_os_stack_trace_getter = new MockStackTraceGetter; - GetUnitTestImpl()->set_os_stack_trace_getter(mock_os_stack_trace_getter); - - CaptureStdout(); - Log(kWarning, "Test log.\n", 100); - const std::string log = GetCapturedStdout(); - - std::string expected_trace = - (testing::Message() << GTEST_FLAG(stack_trace_depth) << "::").GetString(); - std::string expected_message = - "\nGMOCK WARNING:\n" - "Test log.\n" - "Stack trace:\n" + - expected_trace; - EXPECT_THAT(log, HasSubstr(expected_message)); - int skip_count = atoi(log.substr(expected_message.size()).c_str()); - -# if defined(NDEBUG) - // In opt mode, no stack frame should be skipped. - const int expected_skip_count = 0; -# else - // In dbg mode, the stack frames should be skipped. - const int expected_skip_count = 100; -# endif - - // Note that each inner implementation layer will +1 the number to remove - // itself from the trace. This means that the value is a little higher than - // expected, but close enough. - EXPECT_THAT(skip_count, - AllOf(Ge(expected_skip_count), Le(expected_skip_count + 10))); - - // Restores the default OS stack trace getter. - GetUnitTestImpl()->set_os_stack_trace_getter(NULL); -} - -// Tests that all logs are printed when the value of the -// --gmock_verbose flag is "info". -TEST(LogTest, AllLogsArePrintedWhenVerbosityIsInfo) { - TestLogWithSeverity(kInfoVerbosity, kInfo, true); - TestLogWithSeverity(kInfoVerbosity, kWarning, true); -} - -// Tests that only warnings are printed when the value of the -// --gmock_verbose flag is "warning". -TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsWarning) { - TestLogWithSeverity(kWarningVerbosity, kInfo, false); - TestLogWithSeverity(kWarningVerbosity, kWarning, true); -} - -// Tests that no logs are printed when the value of the -// --gmock_verbose flag is "error". -TEST(LogTest, NoLogsArePrintedWhenVerbosityIsError) { - TestLogWithSeverity(kErrorVerbosity, kInfo, false); - TestLogWithSeverity(kErrorVerbosity, kWarning, false); -} - -// Tests that only warnings are printed when the value of the -// --gmock_verbose flag is invalid. -TEST(LogTest, OnlyWarningsArePrintedWhenVerbosityIsInvalid) { - TestLogWithSeverity("invalid", kInfo, false); - TestLogWithSeverity("invalid", kWarning, true); -} - -#endif // GTEST_HAS_STREAM_REDIRECTION - -TEST(TypeTraitsTest, true_type) { - EXPECT_TRUE(true_type::value); -} - -TEST(TypeTraitsTest, false_type) { - EXPECT_FALSE(false_type::value); -} - -TEST(TypeTraitsTest, is_reference) { - EXPECT_FALSE(is_reference::value); - EXPECT_FALSE(is_reference::value); - EXPECT_TRUE(is_reference::value); -} - -TEST(TypeTraitsTest, is_pointer) { - EXPECT_FALSE(is_pointer::value); - EXPECT_FALSE(is_pointer::value); - EXPECT_TRUE(is_pointer::value); -} - -TEST(TypeTraitsTest, type_equals) { - EXPECT_FALSE((type_equals::value)); - EXPECT_FALSE((type_equals::value)); - EXPECT_FALSE((type_equals::value)); - EXPECT_TRUE((type_equals::value)); -} - -TEST(TypeTraitsTest, remove_reference) { - EXPECT_TRUE((type_equals::type>::value)); - EXPECT_TRUE((type_equals::type>::value)); - EXPECT_TRUE((type_equals::type>::value)); - EXPECT_TRUE((type_equals::type>::value)); -} - -#if GTEST_HAS_STREAM_REDIRECTION - -// Verifies that Log() behaves correctly for the given verbosity level -// and log severity. -std::string GrabOutput(void(*logger)(), const char* verbosity) { - const std::string saved_flag = GMOCK_FLAG(verbose); - GMOCK_FLAG(verbose) = verbosity; - CaptureStdout(); - logger(); - GMOCK_FLAG(verbose) = saved_flag; - return GetCapturedStdout(); -} - -class DummyMock { - public: - MOCK_METHOD0(TestMethod, void()); - MOCK_METHOD1(TestMethodArg, void(int dummy)); -}; - -void ExpectCallLogger() { - DummyMock mock; - EXPECT_CALL(mock, TestMethod()); - mock.TestMethod(); -}; - -// Verifies that EXPECT_CALL logs if the --gmock_verbose flag is set to "info". -TEST(ExpectCallTest, LogsWhenVerbosityIsInfo) { - EXPECT_THAT(std::string(GrabOutput(ExpectCallLogger, kInfoVerbosity)), - HasSubstr("EXPECT_CALL(mock, TestMethod())")); -} - -// Verifies that EXPECT_CALL doesn't log -// if the --gmock_verbose flag is set to "warning". -TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsWarning) { - EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kWarningVerbosity).c_str()); -} - -// Verifies that EXPECT_CALL doesn't log -// if the --gmock_verbose flag is set to "error". -TEST(ExpectCallTest, DoesNotLogWhenVerbosityIsError) { - EXPECT_STREQ("", GrabOutput(ExpectCallLogger, kErrorVerbosity).c_str()); -} - -void OnCallLogger() { - DummyMock mock; - ON_CALL(mock, TestMethod()); -}; - -// Verifies that ON_CALL logs if the --gmock_verbose flag is set to "info". -TEST(OnCallTest, LogsWhenVerbosityIsInfo) { - EXPECT_THAT(std::string(GrabOutput(OnCallLogger, kInfoVerbosity)), - HasSubstr("ON_CALL(mock, TestMethod())")); -} - -// Verifies that ON_CALL doesn't log -// if the --gmock_verbose flag is set to "warning". -TEST(OnCallTest, DoesNotLogWhenVerbosityIsWarning) { - EXPECT_STREQ("", GrabOutput(OnCallLogger, kWarningVerbosity).c_str()); -} - -// Verifies that ON_CALL doesn't log if -// the --gmock_verbose flag is set to "error". -TEST(OnCallTest, DoesNotLogWhenVerbosityIsError) { - EXPECT_STREQ("", GrabOutput(OnCallLogger, kErrorVerbosity).c_str()); -} - -void OnCallAnyArgumentLogger() { - DummyMock mock; - ON_CALL(mock, TestMethodArg(_)); -} - -// Verifies that ON_CALL prints provided _ argument. -TEST(OnCallTest, LogsAnythingArgument) { - EXPECT_THAT(std::string(GrabOutput(OnCallAnyArgumentLogger, kInfoVerbosity)), - HasSubstr("ON_CALL(mock, TestMethodArg(_)")); -} - -#endif // GTEST_HAS_STREAM_REDIRECTION - -// Tests StlContainerView. - -TEST(StlContainerViewTest, WorksForStlContainer) { - StaticAssertTypeEq, - StlContainerView >::type>(); - StaticAssertTypeEq&, - StlContainerView >::const_reference>(); - - typedef std::vector Chars; - Chars v1; - const Chars& v2(StlContainerView::ConstReference(v1)); - EXPECT_EQ(&v1, &v2); - - v1.push_back('a'); - Chars v3 = StlContainerView::Copy(v1); - EXPECT_THAT(v3, Eq(v3)); -} - -TEST(StlContainerViewTest, WorksForStaticNativeArray) { - StaticAssertTypeEq, - StlContainerView::type>(); - StaticAssertTypeEq, - StlContainerView::type>(); - StaticAssertTypeEq, - StlContainerView::type>(); - - StaticAssertTypeEq, - StlContainerView::const_reference>(); - - int a1[3] = { 0, 1, 2 }; - NativeArray a2 = StlContainerView::ConstReference(a1); - EXPECT_EQ(3U, a2.size()); - EXPECT_EQ(a1, a2.begin()); - - const NativeArray a3 = StlContainerView::Copy(a1); - ASSERT_EQ(3U, a3.size()); - EXPECT_EQ(0, a3.begin()[0]); - EXPECT_EQ(1, a3.begin()[1]); - EXPECT_EQ(2, a3.begin()[2]); - - // Makes sure a1 and a3 aren't aliases. - a1[0] = 3; - EXPECT_EQ(0, a3.begin()[0]); -} - -TEST(StlContainerViewTest, WorksForDynamicNativeArray) { - StaticAssertTypeEq, - StlContainerView >::type>(); - StaticAssertTypeEq, - StlContainerView, int> >::type>(); - - StaticAssertTypeEq, - StlContainerView >::const_reference>(); - - int a1[3] = { 0, 1, 2 }; - const int* const p1 = a1; - NativeArray a2 = StlContainerView >:: - ConstReference(make_tuple(p1, 3)); - EXPECT_EQ(3U, a2.size()); - EXPECT_EQ(a1, a2.begin()); - - const NativeArray a3 = StlContainerView >:: - Copy(make_tuple(static_cast(a1), 3)); - ASSERT_EQ(3U, a3.size()); - EXPECT_EQ(0, a3.begin()[0]); - EXPECT_EQ(1, a3.begin()[1]); - EXPECT_EQ(2, a3.begin()[2]); - - // Makes sure a1 and a3 aren't aliases. - a1[0] = 3; - EXPECT_EQ(0, a3.begin()[0]); -} - -} // namespace -} // namespace internal -} // namespace testing -- cgit v1.2.3