44

我正在尝试对名为VariableImpl. 这是详细信息。

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调用另一个类的方法，然后清除向量。

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

我应该怎么做？

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

4

8 回答 8

62

好吧，单元测试应该测试单元，理想情况下每个类都是一个独立的单元——这直接遵循单一责任原则。

所以测试一个类的私有成员不应该是必要的——这个类是一个黑盒子，可以在单元测试中被覆盖。

另一方面，这并不总是正确的，有时是有充分理由的（例如，类的几个方法可能依赖于应该测试的私有实用程序函数）。一个非常简单，非常笨拙但最终成功的解决方案是将以下内容放入您的单元测试文件中，然后包含定义您的类的标头：

#define private public

当然，这会破坏封装并且是邪恶的。但是对于测试，它可以达到目的。

于 2011-07-21T15:36:31.723 回答
14

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

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

或者这个黑客

#define private public
于 2011-07-21T15:28:51.780 回答
8

总的来说，我同意其他人在这里所说的 - 只有公共接口应该进行单元测试。尽管如此，我刚刚遇到了一个案例，我必须首先调用一个受保护的方法，为特定的测试用例做准备。我首先尝试了#define protected public上面提到的方法；这适用于 Linux/gcc，但适用于 Windows/VisualStudio。原因是更改protected为public也更改了损坏的符号名称，因此给了我链接器错误：库提供了一个受保护 __declspec(dllexport) void Foo::bar()的方法，但是#define在适当的位置，我的测试程序需要一个公共 __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。

于 2014-04-24T11:16:34.827 回答
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/

于 2012-10-30T11:56:43.190 回答
1

单元测试 VariableImpl ，如果它的行为得到保证，那么变量也是如此。

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

如果这看起来很多，请考虑实现继承不会产生很好的关注点分离。如果很难进行单元测试，那么这对我来说是一种非常明显的代码味道。

于 2011-07-21T15:34:13.573 回答
1

虽然在我看来，测试类的私有成员/方法的需要是一种代码味道，但我认为这在 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的来源。

免责声明：感谢其他聪明人的见解，我组装了上述“库”，能够访问给定 C++ 类的私有成员和方法，而无需更改其定义或行为。为了使其工作，（显然）需要了解并包含该类的实现。

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

于 2017-06-25T09:25:18.577 回答
0

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

如果功能需要一个子类，要么对真正的派生类进行单元测试，要么创建你自己的具有适当实现的测试派生类。

于 2011-07-21T15:36:15.570 回答
0

来自谷歌测试框架的例子：

// 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().
}

主要思想是使用friend 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
于 2014-10-14T13:25:25.317 回答