Question

我对单元测试很新，我有点困惑。

我正在尝试在名为VariableImpl的C ++类上进行单元测试（使用Boost单元测试框架）。以下是详细信息。

class Variable
{
public:
  void UpdateStatistics (void) {
    // compute mean based on m_val and update m_mean;
    OtherClass::SendData (m_mean);
    m_val.clear ();
  }
  virtual void RecordData (double) = 0;

protected:
  std::vector<double> m_val;

private:
  double m_mean;
};

class VariableImpl : public Variable
{
public:
  virtual void RecordData (double d) {
    // put data in m_val
  }
};

我的问题是如何检查均值是否正确计算？请注意1）m_mean受到保护，2）UpdateStatistics调用另一个类的方法，然后清除向量。

我能看到的唯一方法是添加一个getter（例如，GetMean），但我根本不喜欢这个解决方案，也不认为它是最优雅的。

我该怎么办？

如果我要测试私有方法而不是私有变量，我该怎么办？

TIA，

JIR

Answer 1

那么，单元测试应该测试单位，理想情况下每个类都是一个独立的单元 - 这直接来自单一责任原则。

因此，测试类的私有成员不是必需的 - 该类是一个黑盒子，可以在单元测试中按原样覆盖。

另一方面，这并不总是正确的，有时还有充分的理由（例如，类的几个方法可能依赖于应该测试的私有效用函数）。一个非常简单，非常苛刻但最终成功的解决方案是将以下内容放入您的单元测试文件之前，包括定义您的类的标题：

#define private public

当然，这会破坏封装并且 evil 。但是为了测试，它就是为了这个目的。

Answer 2

对于受保护的方法/变量，从类继承Test类并进行测试。

对于私人，介绍朋友类。它不是最好的解决方案，但可以为您完成工作。

或者这个黑客

#define private public

Answer 3

总的来说，我同意其他人在这里所说的内容 - 只有公共界面应该进行单元测试。不过，我刚才有一个案例，我必须首先调用受保护的方法，为特定的测试用例做准备。我首先尝试了上面提到的#define protected public方法;这适用于Linux / gcc，但在Windows / VisualStudio中失败了。原因是将protected更改为public也会更改损坏的符号名称，从而给出了链接器错误：库提供了受保护的 __declspec(dllexport) void Foo::bar()方法，但是#define已到位，我的测试程序需要一个 public __declspec(dllimport) void Foo::bar()方法，它给了我一个未解决的符号错误。

出于这个原因，我切换到基于friend的解决方案，在我的类标题中执行以下操作：

// This goes in Foo.h
namespace unit_test {   // Name this anything you like
struct FooTester; // Forward declaration for befriending
}

// Class to be tested
class Foo 
{
  ...
private:
  bool somePrivateMethod(int bar);
  // Unit test access
  friend struct ::unit_test::FooTester;
};

在我的实际测试案例中，我这样做了：

#include <Foo.h>
#include <boost/test/unit_test.hpp>
namespace unit_test {
// Static wrappers for private/protected methods
struct FooTester
{
  static bool somePrivateMethod(Foo& foo, int bar)
  {
    return foo.somePrivateMethod(bar);
  }
};
}

BOOST_AUTO_TEST_SUITE(FooTest);
BOOST_AUTO_TEST_CASE(TestSomePrivateMethod)
{
  // Just a silly example
  Foo foo;
  BOOST_CHECK_EQUAL(unit_test::FooTester::somePrivateMethod(foo, 42), true);
}
BOOST_AUTO_TEST_SUITE_END();

这适用于Linux / gcc以及Windows / VisualStudio。

Answer 4

在c + +中测试受保护数据的好方法是分配朋友代理类：

#define FRIEND_TEST(test_case_name, test_name)\
friend class test_case_name##_##test_name##_Test

class MyClass 
{
private:
  int MyMethod();
  FRIEND_TEST(MyClassTest, MyMethod);
};

class MyClassTest : public testing::Test 
{
public:
  // ...
  void Test1()
  {
    MyClass obj1;
    ASSERT_TRUE(obj1.MyMethod() == 0);
  }

  void Test2()
  {
    ASSERT_TRUE(obj2.MyMethod() == 0);
  }

  MyClass obj2;
};

TEST_F(MyClassTest, PrivateTests) 
{
 Test1();
 Test2(); 
}

查看更多goolge测试（gtest）： http://code.google.com/p/googletest-translations/

Answer 5

虽然在我看来，测试类的私有成员/方法的需要是代码味道，但我认为在C ++中技术上是可行的。

举个例子，假设你有一个带有私有成员/方法的Dog类，除了公共构造函数：

#include <iostream>
#include <string>

using namespace std;

class Dog {
  public:
    Dog(string name) { this->name = name; };

  private:
    string name;
    string bark() { return name + ": Woof!"; };
    static string Species;
    static int Legs() { return 4; };
};

string Dog::Species = "Canis familiaris";

现在由于某种原因你想测试私人的。您可以使用privablic来实现这一目标。

包含名为privablic.h的标题以及所需的实现：

#include "privablic.h"
#include "dog.hpp"

然后根据任何实例成员的类型

映射一些存根

struct Dog_name { typedef string (Dog::*type); };
template class private_member<Dog_name, &Dog::name>;

...和实例方法;

struct Dog_bark { typedef string (Dog::*type)(); };
template class private_method<Dog_bark, &Dog::bark>;

对所有静态实例成员执行相同操作

struct Dog_Species { typedef string *type; };
template class private_member<Dog_Species, &Dog::Species>;

...和静态实例方法。

struct Dog_Legs { typedef int (*type)(); };
template class private_method<Dog_Legs, &Dog::Legs>;

现在你可以测试它们了：

#include <assert.h>

int main()
{
    string name = "Fido";
    Dog fido = Dog(name);

    string fido_name = fido.*member<Dog_name>::value;
    assert (fido_name == name);

    string fido_bark = (&fido->*func<Dog_bark>::ptr)();
    string bark = "Fido: Woof!";
    assert( fido_bark == bark);

    string fido_species = *member<Dog_Species>::value;
    string species = "Canis familiaris";
    assert(fido_species == species);

    int fido_legs = (*func<Dog_Legs>::ptr)();
    int legs = 4;
    assert(fido_legs == legs);

    printf("all assertions passed\n");
};

输出：

$ ./main
all assertions passed

您可以查看test_dog.cpp和dog.hpp的来源。

免责声明：感谢其他clever people的见解，我已经汇集了前面提到的＆＃34;库＆＃34;能够访问给定C ++类的私有成员和方法，而无需更改其定义或行为。为了使其有效，它（显然）需要知道并包含该类的实现。

注意：我修改了此答案的内容，以遵循审稿人建议的指示。

Answer 6

单元测试VariableImpl，如果确保其行为，那么Variable也是如此。

测试内部结构并不是世界上最糟糕的事情，但目标是只要确保接口合同，它们就可以是任何东西。如果这意味着要创建一堆奇怪的模拟实现来测试Variable，那么这是合理的。

如果这看起来很多，请考虑实现继承不会造成很大的关注点分离。如果单元测试很难，那对我来说就是一个非常明显的代码味道。

Answer 7

我通常建议您测试类的公共接口，不私有/受保护的实现。在这种情况下，如果通过公共方法无法从外界观察到，那么单元测试可能不需要对其进行测试。

如果功能需要子类，则单元测试实际派生类或创建具有适当实现的自己的测试派生类。

Answer 8

Example from the google testing framework:

// foo.h
#include "gtest/gtest_prod.h"
class Foo {
  ...
 private:
  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
  int Bar(void* x);
};

// foo_test.cc
...
TEST(FooTest, BarReturnsZeroOnNull) {
  Foo foo;
  EXPECT_EQ(0, foo.Bar(NULL));
  // Uses Foo's private member Bar().
}

主要想法是使用朋友 cpp关键字。您可以按如下方式扩展此示例：

// foo.h
#ifdef TEST_FOO
#include "gtest/gtest_prod.h"
#endif

class Foo {
  ...
 private:
  #ifdef TEST_FOO
  FRIEND_TEST(FooTest, BarReturnsZeroOnNull);
  #endif
  int Bar(void* x);
};

您可以通过两种方式定义TEST_FOO预处理器：

1）在CMakeLists.txt

中

option(TEST "Run test ?" ON)
if (TEST)
  add_definitions(-DTEST_FOO)
endif()

2）作为编译器的参数

g++ -D TEST $your_args

如何对C ++类的私有成员（和方法）进行单元测试

8 个答案: