请参见下面的示例；

应添加以下导入语句：

import org.powermock.reflect.Whitebox;

现在，您可以直接传递具有私有方法、要调用的方法名和其他参数的对象，如下所示。

Whitebox.invokeMethod(obj, "privateMethod", "param1");

我倾向于不测试私人方法。这里有疯狂。我个人认为，你应该只测试你公开的接口（包括受保护的和内部的方法）。

对于Java，我会使用反射，因为我不喜欢仅仅为了测试而更改对声明方法的包的访问。然而，我通常只测试公共方法，这也应该确保私有方法正常工作。

不能使用反射从所有者类外部获取私有方法，私有修饰符也会影响反射

这不是真的。你当然可以，正如塞姆·卡提卡斯的回答中所提到的。

今天，我推出了一个Java库来帮助测试私有方法和字段。它的设计考虑到了Android，但它确实可以用于任何Java项目。

如果您有一些带有私有方法、字段或构造函数的代码，可以使用BoundBox。它正是你想要的。下面是一个测试示例，它访问Android活动的两个私有字段来测试它：

@UiThreadTest
public void testCompute() {

    // Given
    boundBoxOfMainActivity = new BoundBoxOfMainActivity(getActivity());

    // When
    boundBoxOfMainActivity.boundBox_getButtonMain().performClick();

    // Then
    assertEquals("42", boundBoxOfMainActivity.boundBox_getTextViewMain().getText());
}

BoundBox使测试私有/受保护的字段、方法和构造函数变得容易。你甚至可以访问被继承隐藏的东西。实际上，BoundBox打破了封装。它会让您通过反射访问所有这些内容，但在编译时会检查所有内容。

它非常适合测试一些遗留代码。小心使用。；）

对于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!
}

下面的ReflectionTestUtil可以通用地用于测试私有方法的原子性。

import com.google.common.base.Preconditions;

import org.springframework.test.util.ReflectionTestUtils;

/**
 * <p>
 * Invoker
 * </p>
 *
 * @author
 * @created Oct-10-2019
 */
public class Invoker {
    private Object target;
    private String methodName;
    private Object[] arguments;

    public <T> T invoke() {
        try {
            Preconditions.checkNotNull(target, "Target cannot be empty");
            Preconditions.checkNotNull(methodName, "MethodName cannot be empty");
            if (null == arguments) {
                return ReflectionTestUtils.invokeMethod(target, methodName);
            } else {
                return ReflectionTestUtils.invokeMethod(target, methodName, arguments);
            }
        } catch (Exception e) {
           throw e;
        }
    }

    public Invoker withTarget(Object target) {
        this.target = target;
        return this;
    }

    public Invoker withMethod(String methodName) {
        this.methodName = methodName;
        return this;
    }

    public Invoker withArguments(Object... args) {
        this.arguments = args;
        return this;
    }

}

Object privateMethodResponse = new Invoker()
  .withTarget(targetObject)
  .withMethod(PRIVATE_METHOD_NAME_TO_INVOKE)
  .withArguments(arg1, arg2, arg3)
  .invoke();
Assert.assertNotNutll(privateMethodResponse)