GoogleTest - Google Testing and Mocking Framework (grpc protobuff依赖)
https://google.github.io/googletest/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
322 lines
9.1 KiB
322 lines
9.1 KiB
// 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 <typename T> |
|
void JoinAndDelete(ThreadWithParam<T>* 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<Derived1> pointer1(new Derived1(1, 2)); |
|
linked_ptr<Derived2> 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<Derived1> p1(pointer1); |
|
EXPECT_EQ(1, p1->x()); |
|
EXPECT_EQ(2, p1->y()); |
|
|
|
// Assigns from pointer2 where the LHS was empty. |
|
linked_ptr<Base> 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<Derived1> 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<Derived1> p1(p0); |
|
linked_ptr<Derived1> 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<Helper1Param>* const t = |
|
new ThreadWithParam<Helper1Param>(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<MockFoo*>* const t = |
|
new ThreadWithParam<MockFoo*>(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<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(), 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; |
|
}
|
|
|