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_stress_test.cc | 323 --------------------- 1 file changed, 323 deletions(-) delete mode 100644 third_party/googletest/googlemock/test/gmock_stress_test.cc (limited to 'third_party/googletest/googlemock/test/gmock_stress_test.cc') diff --git a/third_party/googletest/googlemock/test/gmock_stress_test.cc b/third_party/googletest/googlemock/test/gmock_stress_test.cc deleted file mode 100644 index b9fdc45..0000000 --- a/third_party/googletest/googlemock/test/gmock_stress_test.cc +++ /dev/null @@ -1,323 +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) - -// Tests that Google Mock constructs can be used in a large number of -// threads concurrently. - -#include "gmock/gmock.h" - -#include "gtest/gtest.h" - -namespace testing { -namespace { - -// From "gtest/internal/gtest-port.h". -using ::testing::internal::ThreadWithParam; - -// The maximum number of test threads (not including helper threads) -// to create. -const int kMaxTestThreads = 50; - -// How many times to repeat a task in a test thread. -const int kRepeat = 50; - -class MockFoo { - public: - MOCK_METHOD1(Bar, int(int n)); // NOLINT - MOCK_METHOD2(Baz, char(const char* s1, const std::string& s2)); // NOLINT -}; - -// Helper for waiting for the given thread to finish and then deleting it. -template -void JoinAndDelete(ThreadWithParam* t) { - t->Join(); - delete t; -} - -using internal::linked_ptr; - -// Helper classes for testing using linked_ptr concurrently. - -class Base { - public: - explicit Base(int a_x) : x_(a_x) {} - virtual ~Base() {} - int x() const { return x_; } - private: - int x_; -}; - -class Derived1 : public Base { - public: - Derived1(int a_x, int a_y) : Base(a_x), y_(a_y) {} - int y() const { return y_; } - private: - int y_; -}; - -class Derived2 : public Base { - public: - Derived2(int a_x, int a_z) : Base(a_x), z_(a_z) {} - int z() const { return z_; } - private: - int z_; -}; - -linked_ptr pointer1(new Derived1(1, 2)); -linked_ptr pointer2(new Derived2(3, 4)); - -struct Dummy {}; - -// Tests that we can copy from a linked_ptr and read it concurrently. -void TestConcurrentCopyAndReadLinkedPtr(Dummy /* dummy */) { - // Reads pointer1 and pointer2 while they are being copied from in - // another thread. - EXPECT_EQ(1, pointer1->x()); - EXPECT_EQ(2, pointer1->y()); - EXPECT_EQ(3, pointer2->x()); - EXPECT_EQ(4, pointer2->z()); - - // Copies from pointer1. - linked_ptr p1(pointer1); - EXPECT_EQ(1, p1->x()); - EXPECT_EQ(2, p1->y()); - - // Assigns from pointer2 where the LHS was empty. - linked_ptr p2; - p2 = pointer1; - EXPECT_EQ(1, p2->x()); - - // Assigns from pointer2 where the LHS was not empty. - p2 = pointer2; - EXPECT_EQ(3, p2->x()); -} - -const linked_ptr p0(new Derived1(1, 2)); - -// Tests that we can concurrently modify two linked_ptrs that point to -// the same object. -void TestConcurrentWriteToEqualLinkedPtr(Dummy /* dummy */) { - // p1 and p2 point to the same, shared thing. One thread resets p1. - // Another thread assigns to p2. This will cause the same - // underlying "ring" to be updated concurrently. - linked_ptr p1(p0); - linked_ptr p2(p0); - - EXPECT_EQ(1, p1->x()); - EXPECT_EQ(2, p1->y()); - - EXPECT_EQ(1, p2->x()); - EXPECT_EQ(2, p2->y()); - - p1.reset(); - p2 = p0; - - EXPECT_EQ(1, p2->x()); - EXPECT_EQ(2, p2->y()); -} - -// Tests that different mock objects can be used in their respective -// threads. This should generate no Google Test failure. -void TestConcurrentMockObjects(Dummy /* dummy */) { - // Creates a mock and does some typical operations on it. - MockFoo foo; - ON_CALL(foo, Bar(_)) - .WillByDefault(Return(1)); - ON_CALL(foo, Baz(_, _)) - .WillByDefault(Return('b')); - ON_CALL(foo, Baz(_, "you")) - .WillByDefault(Return('a')); - - EXPECT_CALL(foo, Bar(0)) - .Times(AtMost(3)); - EXPECT_CALL(foo, Baz(_, _)); - EXPECT_CALL(foo, Baz("hi", "you")) - .WillOnce(Return('z')) - .WillRepeatedly(DoDefault()); - - EXPECT_EQ(1, foo.Bar(0)); - EXPECT_EQ(1, foo.Bar(0)); - EXPECT_EQ('z', foo.Baz("hi", "you")); - EXPECT_EQ('a', foo.Baz("hi", "you")); - EXPECT_EQ('b', foo.Baz("hi", "me")); -} - -// Tests invoking methods of the same mock object in multiple threads. - -struct Helper1Param { - MockFoo* mock_foo; - int* count; -}; - -void Helper1(Helper1Param param) { - for (int i = 0; i < kRepeat; i++) { - const char ch = param.mock_foo->Baz("a", "b"); - if (ch == 'a') { - // It was an expected call. - (*param.count)++; - } else { - // It was an excessive call. - EXPECT_EQ('\0', ch); - } - - // An unexpected call. - EXPECT_EQ('\0', param.mock_foo->Baz("x", "y")) << "Expected failure."; - - // An uninteresting call. - EXPECT_EQ(1, param.mock_foo->Bar(5)); - } -} - -// This should generate 3*kRepeat + 1 failures in total. -void TestConcurrentCallsOnSameObject(Dummy /* dummy */) { - MockFoo foo; - - ON_CALL(foo, Bar(_)) - .WillByDefault(Return(1)); - EXPECT_CALL(foo, Baz(_, "b")) - .Times(kRepeat) - .WillRepeatedly(Return('a')); - EXPECT_CALL(foo, Baz(_, "c")); // Expected to be unsatisfied. - - // This chunk of code should generate kRepeat failures about - // excessive calls, and 2*kRepeat failures about unexpected calls. - int count1 = 0; - const Helper1Param param = { &foo, &count1 }; - ThreadWithParam* const t = - new ThreadWithParam(Helper1, param, NULL); - - int count2 = 0; - const Helper1Param param2 = { &foo, &count2 }; - Helper1(param2); - JoinAndDelete(t); - - EXPECT_EQ(kRepeat, count1 + count2); - - // foo's destructor should generate one failure about unsatisfied - // expectation. -} - -// Tests using the same mock object in multiple threads when the -// expectations are partially ordered. - -void Helper2(MockFoo* foo) { - for (int i = 0; i < kRepeat; i++) { - foo->Bar(2); - foo->Bar(3); - } -} - -// This should generate no Google Test failures. -void TestPartiallyOrderedExpectationsWithThreads(Dummy /* dummy */) { - MockFoo foo; - Sequence s1, s2; - - { - InSequence dummy; - EXPECT_CALL(foo, Bar(0)); - EXPECT_CALL(foo, Bar(1)) - .InSequence(s1, s2); - } - - EXPECT_CALL(foo, Bar(2)) - .Times(2*kRepeat) - .InSequence(s1) - .RetiresOnSaturation(); - EXPECT_CALL(foo, Bar(3)) - .Times(2*kRepeat) - .InSequence(s2); - - { - InSequence dummy; - EXPECT_CALL(foo, Bar(2)) - .InSequence(s1, s2); - EXPECT_CALL(foo, Bar(4)); - } - - foo.Bar(0); - foo.Bar(1); - - ThreadWithParam* const t = - new ThreadWithParam(Helper2, &foo, NULL); - Helper2(&foo); - JoinAndDelete(t); - - foo.Bar(2); - foo.Bar(4); -} - -// Tests using Google Mock constructs in many threads concurrently. -TEST(StressTest, CanUseGMockWithThreads) { - void (*test_routines[])(Dummy dummy) = { - &TestConcurrentCopyAndReadLinkedPtr, - &TestConcurrentWriteToEqualLinkedPtr, - &TestConcurrentMockObjects, - &TestConcurrentCallsOnSameObject, - &TestPartiallyOrderedExpectationsWithThreads, - }; - - const int kRoutines = sizeof(test_routines)/sizeof(test_routines[0]); - const int kCopiesOfEachRoutine = kMaxTestThreads / kRoutines; - const int kTestThreads = kCopiesOfEachRoutine * kRoutines; - ThreadWithParam* threads[kTestThreads] = {}; - for (int i = 0; i < kTestThreads; i++) { - // Creates a thread to run the test function. - threads[i] = - new ThreadWithParam(test_routines[i % kRoutines], Dummy(), NULL); - GTEST_LOG_(INFO) << "Thread #" << i << " running . . ."; - } - - // At this point, we have many threads running. - for (int i = 0; i < kTestThreads; i++) { - JoinAndDelete(threads[i]); - } - - // Ensures that the correct number of failures have been reported. - const TestInfo* const info = UnitTest::GetInstance()->current_test_info(); - const TestResult& result = *info->result(); - const int kExpectedFailures = (3*kRepeat + 1)*kCopiesOfEachRoutine; - GTEST_CHECK_(kExpectedFailures == result.total_part_count()) - << "Expected " << kExpectedFailures << " failures, but got " - << result.total_part_count(); -} - -} // namespace -} // namespace testing - -int main(int argc, char **argv) { - testing::InitGoogleMock(&argc, argv); - - const int exit_code = RUN_ALL_TESTS(); // Expected to fail. - GTEST_CHECK_(exit_code != 0) << "RUN_ALL_TESTS() did not fail as expected"; - - printf("\nPASS\n"); - return 0; -} -- cgit v1.2.3