我感觉完全一样。。。更改一个方法的访问修饰符，以便能够运行测试，这对我来说是个坏主意。在我们公司，我们也进行了很多讨论，在我看来，测试私有方法的好方法是使用Java反射或其他框架，使方法可测试。对于复杂的私有方法，我多次这样做，这有助于保持测试的小型性、可读性和可维护性。

在我阅读了这里的所有答案之后，我只是不同意那些说“如果你需要测试私有方法，那么会有代码气味”或甚至“不要测试私有方法”的人。。。所以我给你举个小例子：

假设我有一个带有一个公共方法和两个私有方法的类：

public class ConwaysGameOfLife {

    private boolean[][] generationData = new boolean[128][128];

    /**
     * Compute the next generation and return the new state
     * Also saving the new state in generationData
     */
    public boolean[][] computeNextGeneration() {
        boolean[][] tempData = new boolean[128][128];

        for (int yPos=0; yPos<=generationData.length; yPos++) {
            for (int xPos=0; xPos<=generationData[yPos].length; xPos++) {
                int neighbors = countNeighbors(yPos, xPos);
                tempData[yPos][xPos] = determineCellState(neighbors, yPos, xPos);
            }
        }

        generationData = tempData;
        return generationData;
    }

    /**
     * Counting the neighbors for a cell on given position considering all the edge cases
     *
     * @return the amount of found neighbors for a cell
     */
    private int countNeighbors(int yPos, int xPos) {}

    /**
     * Determine the cell state depending on the amount of neighbors of a cell and on a current state of the cell
     *
     * @return the new cell state
     */
    private boolean determineCellState(int neighborsAmount, int yPos, int xPos) {}
}

因此，至少对于“countNeighbors”方法，我需要测试八个边缘情况和一些一般情况（直接位于角落的单元格、直接位于矩阵边缘的单元格和位于中间的单元格）。因此，如果我只是试图通过“computeNextGeneration”方法覆盖所有的情况，并且在重构之后，一些测试是红色的，那么识别错误所在的位置可能需要花费时间。

如果我分别测试“determineCellState”和“countNeighbors”，并且在重构和优化之后，“computeNextGeneration”和“determine CellState”的测试是红色的，那么我很确定错误将出现在“determiseCellState”方法中。

此外，如果您从一开始就为这些方法编写单元测试，这些测试将帮助您开发方法/算法，而无需考虑和包装公共方法中的其他方法调用和案例。你只需要在方法中编写快速的小测试来覆盖你的案例。。。例如，如果名为“countNeighbors_should_return_right_amount_of_noughbors_for_the_right_top_corner_cell（）”的测试失败，那么很清楚在哪里查找错误。

我不确定这是否是一种好的技术，但我开发了以下模式来单元测试私有方法：

我不修改要测试的方法的可见性，也不添加其他方法。相反，我为要测试的每个私有方法添加了一个额外的公共方法。我调用这个额外的方法TestPort，并用前缀t_表示它们。然后，此测试端口方法只需访问相应的私有方法。

此外，我向测试端口方法添加了一个布尔标志，以决定是否从外部通过测试端口方法授予对私有方法的访问权。然后在静态类中全局设置该标志，在该类中我放置了例如应用程序的其他全局设置。因此，我可以在一个地方打开和关闭对私有方法的访问，例如，在相应的单元测试中。

对于C++（从C++11开始），将测试类添加为好友非常有效，不会破坏生产封装。

让我们假设我们有一些类Foo和一些真正需要测试的私有函数，还有一些类FooTest应该可以访问Foo的私有成员。然后我们应该写下以下内容：

// prod.h: some production code header

// forward declaration is enough
// we should not include testing headers into production code
class FooTest;

class Foo
{
  // that does not affect Foo's functionality
  // but now we have access to Foo's members from FooTest
  friend FooTest;
public:
  Foo();
private:
  bool veryComplicatedPrivateFuncThatReallyRequiresTesting();
}

// test.cpp: some test
#include <prod.h>

class FooTest
{
public:
  void complicatedFisture() {
    Foo foo;
    ASSERT_TRUE(foo.veryComplicatedPrivateFuncThatReallyRequiresTesting());
  }
}

int main(int /*argc*/, char* argv[])
{
  FooTest test;
  test.complicatedFixture();  // and it really works!
}

我感觉完全一样。。。更改一个方法的访问修饰符，以便能够运行测试，这对我来说是个坏主意。在我们公司，我们也进行了很多讨论，在我看来，测试私有方法的好方法是使用Java反射或其他框架，使方法可测试。对于复杂的私有方法，我多次这样做，这有助于保持测试的小型性、可读性和可维护性。

在我阅读了这里的所有答案之后，我只是不同意那些说“如果你需要测试私有方法，那么会有代码气味”或甚至“不要测试私有方法”的人。。。所以我给你举个小例子：

假设我有一个带有一个公共方法和两个私有方法的类：

public class ConwaysGameOfLife {

    private boolean[][] generationData = new boolean[128][128];

    /**
     * Compute the next generation and return the new state
     * Also saving the new state in generationData
     */
    public boolean[][] computeNextGeneration() {
        boolean[][] tempData = new boolean[128][128];

        for (int yPos=0; yPos<=generationData.length; yPos++) {
            for (int xPos=0; xPos<=generationData[yPos].length; xPos++) {
                int neighbors = countNeighbors(yPos, xPos);
                tempData[yPos][xPos] = determineCellState(neighbors, yPos, xPos);
            }
        }

        generationData = tempData;
        return generationData;
    }

    /**
     * Counting the neighbors for a cell on given position considering all the edge cases
     *
     * @return the amount of found neighbors for a cell
     */
    private int countNeighbors(int yPos, int xPos) {}

    /**
     * Determine the cell state depending on the amount of neighbors of a cell and on a current state of the cell
     *
     * @return the new cell state
     */
    private boolean determineCellState(int neighborsAmount, int yPos, int xPos) {}
}

因此，至少对于“countNeighbors”方法，我需要测试八个边缘情况和一些一般情况（直接位于角落的单元格、直接位于矩阵边缘的单元格和位于中间的单元格）。因此，如果我只是试图通过“computeNextGeneration”方法覆盖所有的情况，并且在重构之后，一些测试是红色的，那么识别错误所在的位置可能需要花费时间。

如果我分别测试“determineCellState”和“countNeighbors”，并且在重构和优化之后，“computeNextGeneration”和“determine CellState”的测试是红色的，那么我很确定错误将出现在“determiseCellState”方法中。

此外，如果您从一开始就为这些方法编写单元测试，这些测试将帮助您开发方法/算法，而无需考虑和包装公共方法中的其他方法调用和案例。你只需要在方法中编写快速的小测试来覆盖你的案例。。。例如，如果名为“countNeighbors_should_return_right_amount_of_noughbors_for_the_right_top_corner_cell（）”的测试失败，那么很清楚在哪里查找错误。

首先，我要抛出一个问题：为什么你的私人成员需要隔离测试？它们是否如此复杂，提供了如此复杂的行为，以至于需要在公共表面之外进行测试？这是单元测试，而不是“代码行”测试。别为小事操心。

如果它们是那么大，足够大，以至于这些私有成员都是一个复杂度很大的“单元”，那么考虑将这些私有成员从这个类中重构出来。

如果重构不合适或不可行，在进行单元测试时，是否可以使用策略模式来替换对这些私有成员函数/成员类的访问？在单元测试中，该策略将提供额外的验证，但在发布版本中，它将是简单的传递。

在您的课堂上：

namespace my_namespace {
    #ifdef UNIT_TEST
        class test_class;
    #endif

    class my_class {
        public:
            #ifdef UNIT_TEST
                friend class test_class;
            #endif
        private:
            void fun() { cout << "I am private" << endl; }
    }
}

在单元测试类中：

#ifndef UNIT_TEST
    #define UNIT_TEST
#endif

#include "my_class.h"

class my_namespace::test_class {
    public:
        void fun() { my_obj.fun(); }
    private:
        my_class my_obj;
}

void my_unit_test() {
    test_class test_obj;
    test_obj.fun(); // here you accessed the private function ;)
}