GoogleMock - 由于交叉引用模拟类而泄漏模拟对象

Question

我有两个类， Server和Client ，每个类都有自己的模拟 class 并且分别有一个getClients和getServer方法（实际的类要大得多，但这是最小的情况）。 我想在getClients方法返回的MockServer中添加一个变量，允许我在适当的时候在我的测试中修改这个变量（注意clients变量）。

虽然这有效，但它会导致两个模拟对象相互保持活动状态，每个都保持对另一个的shared_ptr引用，从而导致测试泄漏对象。 请查看下面提供的示例。

问题：如何在不修改接口或create函数的情况下修改Mock Classes以防止泄漏 mock 对象同时保留clients变量？

#include <gmock/gmock.h>
#include <gtest/gtest.h>

struct Client;
struct Server
{
  virtual const std::vector<std::shared_ptr<Client>>& getClients() = 0;
};
struct Client
{
  virtual std::shared_ptr<Server> getServer() = 0;
};

struct MockServer : virtual Server
{
  MOCK_METHOD0(getClients, const std::vector<std::shared_ptr<Client>>&());
  std::vector<std::shared_ptr<Client>> clients;  // I want to add this variable...

protected:
  MockServer()
  {
    ON_CALL(*this, getClients()).WillByDefault(testing::ReturnRef(this->clients));  // ...and return it whenever getClients is called.
  }
  ~MockServer()
  {
    clients.clear();  // This doesn't help...
    std::cout << __func__ << " - This is never printed." << std::endl;
  }

public:
  static std::shared_ptr<MockServer> create()
  {
    return std::make_shared<testing::NiceMock<MockServer>>();
  }
};
struct MockClient : virtual Client
{
  MOCK_METHOD0(getServer, std::shared_ptr<Server>());

protected:
  MockClient(std::shared_ptr<Server> server)
  {
    ON_CALL(*this, getServer()).WillByDefault(testing::Return(server));
  }
  ~MockClient()
  {
    std::cout << __func__ << " - This is never printed." << std::endl;
  }

public:
  static std::shared_ptr<MockClient> create(std::shared_ptr<Server> server)
  {
    return std::make_shared<testing::NiceMock<MockClient>>(server);
  }
};

TEST(ExampleOfLeak, testLeakedMockObjects)
{
  auto server = MockServer::create();
  auto client1 = MockClient::create(server);
  auto client2 = MockClient::create(server);
  EXPECT_EQ(server, client1->getServer());
  EXPECT_EQ(server, client2->getServer());
  EXPECT_TRUE(server->getClients().empty());
  server->clients.push_back(client1);  // This causes leaked mock objects!
  server->clients.push_back(client2);  // And this too...
  EXPECT_EQ(client1, server->getClients().front());
  EXPECT_EQ(client2, server->getClients().back());
  // server->clients.clear();  // This prevents mock objects from leaking, but doing this manually everywhere is highly unfeasible. 
}

结果：

[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from ExampleOfLeak
[ RUN      ] ExampleOfLeak.testLeakedMockObjects
[       OK ] ExampleOfLeak.testLeakedMockObjects (0 ms)
[----------] 1 test from ExampleOfLeak (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (0 ms total)
[  PASSED  ] 1 test.

foo.cc:43: ERROR: this mock object (used in test ExampleOfLeak.testLeakedMockObjects) should be deleted but never is. Its address is @0x2fc3170.
foo.cc:43: ERROR: this mock object (used in test ExampleOfLeak.testLeakedMockObjects) should be deleted but never is. Its address is @0x2fcbcb0.
foo.cc:22: ERROR: this mock object (used in test ExampleOfLeak.testLeakedMockObjects) should be deleted but never is. Its address is @0x2fd6570.
ERROR: 3 leaked mock objects found at program exit.

Answer 1

可以使用lock()方法将weak_ptr转换为shared_ptr 。 这样你就可以在模拟 class 中存储一个weak_ptr ，然后再转换它。 不过要小心并确保weak_ptr没有expired() 。

#include <gmock/gmock.h>
#include <gtest/gtest.h>

struct Client;
struct Server
{
  virtual const std::vector<std::shared_ptr<Client>>& getClients() = 0;
};
struct Client
{
  virtual std::shared_ptr<Server> getServer() = 0;
};

struct MockServer : virtual Server
{
  MOCK_METHOD0(getClients, const std::vector<std::shared_ptr<Client>>&());
  std::vector<std::shared_ptr<Client>> clients;

protected:
  MockServer()
  {
    ON_CALL(*this, getClients()).WillByDefault(testing::ReturnRef(this->clients));
  }
  ~MockServer()
  {
    clients.clear();
    std::cout << __func__ << " - This is printed." << std::endl;
  }

public:
  static std::shared_ptr<MockServer> create()
  {
    return std::make_shared<testing::NiceMock<MockServer>>();
  }
};

ACTION_P(ReturnWeakToShared, wp)
{
  bool isWeakPtrExpired = wp.expired();
  EXPECT_FALSE(isWeakPtrExpired) << "Dangling pointer.";
  return wp.lock();
}

struct MockClient : virtual Client
{
  MOCK_METHOD0(getServer, std::shared_ptr<Server>());
  std::weak_ptr<Server> server;

protected:
  MockClient(std::shared_ptr<Server> server)
  {
    this->server = server;
    ON_CALL(*this, getServer()).WillByDefault(ReturnWeakToShared(this->server));
  }
  ~MockClient()
  {
    std::cout << __func__ << " - This is printed." << std::endl;
  }

public:
  static std::shared_ptr<MockClient> create(std::shared_ptr<Server> server)
  {
    return std::make_shared<testing::NiceMock<MockClient>>(server);
  }
};

TEST(ExampleOfLeak, testLeakedMockObjects)
{
  auto server = MockServer::create();
  auto client1 = MockClient::create(server);
  auto client2 = MockClient::create(server);
  EXPECT_EQ(server, client1->getServer());
  EXPECT_EQ(server, client2->getServer());
  EXPECT_TRUE(server->getClients().empty());
  server->clients.push_back(client1);
  server->clients.push_back(client2);
  EXPECT_EQ(client1, server->getClients().front());
  EXPECT_EQ(client2, server->getClients().back());
}

Answer 2

两个模拟对象让彼此保持活力

其中一个绝对应该对另一个使用弱引用。

例如

#include <gmock/gmock.h>
#include <gtest/gtest.h>

struct Client;
struct Server
{
  virtual const std::vector<std::weak_ptr<Client>>& getClients() = 0;
};
struct Client
{
  virtual std::shared_ptr<Server> getServer() = 0;
};

struct MockServer : virtual Server
{
  MOCK_METHOD0(getClients, const std::vector<std::weak_ptr<Client>>&());
  std::vector<std::weak_ptr<Client>> clients;  // I want to add this variable...

protected:
  MockServer()
  {
    ON_CALL(*this, getClients()).WillByDefault(testing::ReturnRef(this->clients));  // ...and return it whenever getClients is called.
  }
  ~MockServer()
  {
    clients.clear();  // This doesn't help...
    std::cout << __func__ << " - This is never printed." << std::endl;
  }

public:
  static std::shared_ptr<MockServer> create()
  {
    return std::make_shared<testing::NiceMock<MockServer>>();
  }
};
struct MockClient : virtual Client
{
  MOCK_METHOD0(getServer, std::shared_ptr<Server>());

protected:
  MockClient(std::shared_ptr<Server> server)
  {
    ON_CALL(*this, getServer()).WillByDefault(testing::Return(server));
  }
  ~MockClient()
  {
    std::cout << __func__ << " - This is never printed." << std::endl;
  }

public:
  static std::shared_ptr<MockClient> create(std::shared_ptr<Server> server)
  {
    return std::make_shared<testing::NiceMock<MockClient>>(server);
  }
};

TEST(ExampleOfLeak, testLeakedMockObjects)
{
  auto server = MockServer::create();
  auto client1 = MockClient::create(server);
  auto client2 = MockClient::create(server);
  EXPECT_EQ(server, client1->getServer());
  EXPECT_EQ(server, client2->getServer());
  EXPECT_TRUE(server->getClients().empty());
  server->clients.push_back(client1);  // This causes leaked mock objects!
  server->clients.push_back(client2);  // And this too...
  EXPECT_EQ(client1, server->getClients().front().lock());
  EXPECT_EQ(client2, server->getClients().back().lock());
  // server->clients.clear();  // This prevents mock objects from leaking, but doing this manually everywhere is highly unfeasible. 
}

Running main() from gmock_main.cc
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from ExampleOfLeak
[ RUN      ] ExampleOfLeak.testLeakedMockObjects
~MockClient - This is never printed.
~MockClient - This is never printed.
~MockServer - This is never printed.
[       OK ] ExampleOfLeak.testLeakedMockObjects (0 ms)
[----------] 1 test from ExampleOfLeak (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.