如何在java中测试本地内部类方法？

Question

在许多应用程序中，我经常使用专用子算法（或简单定义良好的代码段）的算法。

到目前为止，当我编写主算法时，我为每个子算法创建了一个私有方法，如下例所示（OldStyle）：

public class OldStyle {

    public int mainAlg() {
        int x = subAlg01();
        int y = subAlg02();
        int z = x * y;
        return z;
    }

    private int subAlg01() {
        return 3;
    }

    private int subAlg02() {
        return 5;
    }
}

这工作得很好，但我不喜欢有大量的方法（subAlg01 和 subAlg02），即使是私有的，也仅由一种方法（mainAlg）使用。

最近我发现了本地内部类的使用，现在我的例子是（NewStyle）：

public class NewStyle {

    public int mainAlg() {
        class Nested {

            public int subAlg01() {
                return 3;
            }

            public int subAlg02() {
                return 5;
            }
        }
        Nested n = new Nested();
        int x = n.subAlg01();
        int y = n.subAlg02();
        int z = x * y;
        return z;
    }
}

我非常喜欢它，但现在我有以下问题：如何使用 JUnit 测试 subAlg01 和 subAlg02？

顺便说一句：我正在使用 Eclipse。

谢谢你的帮助。

编辑：我尝试更好地解释：我有一个排序算法，我想测试它以确保它按预期运行。这种排序算法仅由类 X 的方法 m 使用。我可以将其设为类 X 的私有方法，但类 X 通常与排序无关，那么为什么要使用排序方法“破坏”类 X 呢？所以我把它放在方法 m 中。一段时间后，我想改进我的排序算法（我让它更快），但我想确保它的行为符合预期，所以我想用原始测试重新测试它。

这就是我想做的，也许没有解决办法，我希望有人可以帮助我。

选择答案后进行编辑。我选择罗德尼的答案是因为他的解决方案是我采用的：一个独立的帮助器类帮助我（它是一个帮助器！）清楚地了解子方法是什么，并且它还使我能够测试它们。

Answer 1

您应该只测试类的公共接口，而不是私有成员或私有内部类。私有成员是实现细节，仅由类的公共方法（直接或间接）使用。因此，您可以通过它们的调用者方法间接对它们进行单元测试。如果您觉得这些单元测试没有足够的粒度，或者您无法感知您感兴趣的（某些）结果，这可能表明您的设计存在问题：类可能太大，尝试要做的事情太多，因此它的一些功能可能需要提取到一个单独的类中，然后可以直接在其中进行单元测试。

在当前的例子中，如果内部类本身包含很多代码，你可以简单地将它变成一个顶级类，然后你可以直接对其方法进行单元测试。

（顺便说一句，如果您的内部类不需要引用封闭的类实例，则它应该是static。）

Answer 2

Filippo，我理解您对这个问题和一些答案的沮丧。许多年前，当我第一次开始使用 JUnit 时，我也想测试私有代码，我认为专家们说这是一个坏主意，这是愚蠢的。

事实证明他们是对的（惊讶！），但只有在编写了相当多的测试之后我才明白为什么。您可能需要经历相同的过程，但您最终会得出相同的结论;-)

无论如何，在您的情况下，我会将 Nested 制作成一个适当的独立类，可能在一个单独的包中以表明它是一个辅助类。然后我会直接为其编写测试，独立于任何其他测试。

然后我会为 NewStyle 编写测试，并仅关注 NewStyle 的行为。

（很可能我也会将 Nested 注入 NewStyle 中，而不是在 NewStyle 中实例化它 - 即使其成为 NewStyle< 的参数 然后，当我在测试中编写 NewStyle 的测试时，

我会传入 Nested 的实例并继续，如果我觉得特别棘手，我将从 Nested 创建一个接口并创建第二个实现，并用它来测试 NewStyle。）

Answer 3

您应该避免仅仅因为您而使代码过度复杂化

不喜欢有大量的
方法

在您的情况下，您可以测试这些方法，如果它们是外部类的方法，或者如果您绝对需要内部类，则将其放置在 mainAlg() 方法之外，以便它在全局范围内可见。

public class NewStyle {

    public int mainAlg() {

        Nested n = new Nested();
        int x = n.subAlg01();
        int y = n.subAlg02();

        int z = x * y;
        return z;
    }

    class Nested {

        public int subAlg01() {
            return 3;

        }

        public int subAlg02() {
            return 5;
        }
    }
}

然后可以使用 new NewStyle().new Nested().subAlg01(); 来调用它

Answer 4

您无法从外部访问这些类，因此 junit 无法测试它们。你必须公开一些东西来测试它们。

Answer 5

嗯，我知道像 Groovy 这样的语言经常用于在 Java 上进行单元测试，并且能够透明地访问私有字段和方法......但我不确定嵌套类。我可以理解为什么你可能想做这种事情，但我对测试 getter 和 setter 采取同样的立场，应该将它们作为测试公共方法的副作用进行测试，如果它们不这样做以这种方式进行测试，那么他们为什么会在那里呢？

Answer 6

当您的内部类的行为恰好是方法功能的核心部分时，问题就出现了：假设您有一个方法应该将可运行对象传递给第三个对象，而该对象恰好是一个实际上不应该的内部类一个单独的实体：在这种情况下，正确的单元测试几乎需要通过模拟第三个对象来练习所述内部类，并使用参数捕获来测试它应该做什么。

此类问题在对函数式编程有更多支持的语言中非常常见，其中测试传递给第三方的 lambda 几乎是必需的。

但是，正如前面所说，如果外部类从未使用过您的内部类，那么它只是一个实现细节，单独测试它是没有用的。

Answer 7

其实你可以测试一下你本地的内部类。但它需要实现一个接口。这样，您可以通过反射创建本地类的实例并将其转换为它的接口。一旦你有了接口类型，你就可以毫无问题地测试你的实现代码：

接口：

public interface Algorithm {
    int subAlg01();
    int subAlg02();
}

类：

public class NewStyle {
    public int mainAlg() {
        class Nested implements Algorithm {

            public int subAlg01() {
                return 3;
            }

            public int subAlg02() {
                return 5;
            }
        }
        Nested n = new Nested();
        int x = n.subAlg01();
        int y = n.subAlg02();
        int z = x * y;
        return z;
    }
}

测试：

public class NewStyleTest {

    @Test
    public void testLocal() throws ClassNotFoundException,
            NoSuchMethodException, SecurityException, InstantiationException,
            IllegalAccessException, IllegalArgumentException,
            InvocationTargetException {
        Class<?> forName = Class.forName("NewStyle$1Nested");
        Constructor<?> declaredConstructor = forName
                .getDeclaredConstructor(NewStyle.class);
        declaredConstructor.setAccessible(true);
        Algorithm algorithm = (Algorithm) declaredConstructor
                .newInstance(new NewStyle());

        assertEquals(algorithm.subAlg01(), 3);
        assertEquals(algorithm.subAlg02(), 5);
    }
}