|
|
// 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.
// 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-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 <typename T> void JoinAndDelete(ThreadWithParam<T>* t) { t->Join(); delete t; }
struct Dummy {};
// 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<Helper1Param>* const t = new ThreadWithParam<Helper1Param>(Helper1, param, nullptr);
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<MockFoo*>* const t = new ThreadWithParam<MockFoo*>(Helper2, &foo, nullptr); 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) = { &TestConcurrentMockObjects, &TestConcurrentCallsOnSameObject, &TestPartiallyOrderedExpectationsWithThreads, };
const int kRoutines = sizeof(test_routines)/sizeof(test_routines[0]); const int kCopiesOfEachRoutine = kMaxTestThreads / kRoutines; const int kTestThreads = kCopiesOfEachRoutine * kRoutines; ThreadWithParam<Dummy>* threads[kTestThreads] = {}; for (int i = 0; i < kTestThreads; i++) { // Creates a thread to run the test function.
threads[i] = new ThreadWithParam<Dummy>(test_routines[i % kRoutines], Dummy(), nullptr); 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; }
|