JUnit4的fail()在这里，但是pass()在哪里？

Question

JUnit4 库中有一个 fail() 方法。我喜欢它，但是缺少库中不存在的 pass() 方法。为什么会这样呢？

我发现我可以使用 assertTrue(true) 代替，但看起来仍然不合逻辑。

@Test
 public void testSetterForeignWord(){
  try {
   card.setForeignWord("");
   fail();
  } catch (IncorrectArgumentForSetter ex){
  }

 // assertTrue(true);
 }

Answer 1

测试完成并通过后，随时调用 return 语句。

Answer 2

只要测试不引发异常，它就会通过，除非您的 @Test 注释指定了预期的异常。我想 pass() 可能会抛出一个特殊的异常，JUnit 总是将其解释为通过，从而使测试短路，但这将违背测试的通常设计（即假设成功并且只失败如果断言失败），并且如果人们认为最好使用 pass() ，那么它将显着减慢大量通过测试的速度（由于异常创建的开销）。测试失败不应该是常态，所以如果有这样的开销也没什么大不了的。

请注意，您的示例可以像这样重写：

@Test(expected=IncorrectArgumentForSetter.class)
public void testSetterForeignWord("") throws Exception {
  card.setForeignWord("");
}

另外，您应该赞成使用标准 Java 异常。您的 In CorrectArgumentForSetter 可能应该是 IllegalArgumentException。

Answer 3

我认为这个问题需要更新答案，因为这里的大多数答案都相当过时了。

首先针对 OP 的问题：

我认为将“预期异常”概念引入 JUnit 是一个糟糕的举动，因为该异常可以在任何地方引发，并且它将通过测试。如果您抛出（并断言）非常特定于域的异常，它会起作用，但我只在处理需要绝对完美的代码时抛出此类异常，--大多数 APIS 只会抛出内置异常，例如 <代码>IllegalArgumentException 或IllegalStateException。如果您进行的两次调用可能会引发这些异常，那么 @ExpectedException 注释将为您的测试设置绿条，即使抛出异常的行是错误的！

对于这种情况，我编写了一个类，我相信这里的许多其他人都写过，这是一个 assertThrows 方法：

public class Exceptions {
    private Exceptions(){}

    public static void assertThrows(Class<? extends Exception> expectedException, Runnable actionThatShouldThrow){
        try{
            actionThatShouldThrow.run();
            fail("expected action to throw " + expectedException.getSimpleName() + " but it did not.");
        }
        catch(Exception e){
            if ( ! expectedException.isInstance(e)) {
                throw e;
            }
        }
    }
}

如果抛出异常，该方法只是返回，允许您进行进一步的断言/验证在你的测试中。

使用 java 8 语法，您的测试看起来非常好。下面是使用该方法对我们的模型进行的更简单的测试之一：

@Test
public void when_input_lower_bound_is_greater_than_upper_bound_axis_should_throw_illegal_arg() {
    //setup
    AxisRange range = new AxisRange(0,100);

    //act
    Runnable act = () -> range.setLowerBound(200);

    //assert
    assertThrows(IllegalArgumentException.class, act);
}

这些测试有点奇怪，因为“act”步骤实际上并不执行任何操作，但我认为含义仍然相当清晰。

maven 上还有一个名为 catch-exception 的小库，它使用mockito-style语法来验证是否抛出异常。它看起来很漂亮，但我不喜欢动态代理。也就是说，语法非常流畅，仍然很诱人：

// given: an empty list
List myList = new ArrayList();

// when: we try to get the first element of the list
// then: catch the exception if any is thrown 
catchException(myList).get(1);

// then: we expect an IndexOutOfBoundsException
assert caughtException() instanceof IndexOutOfBoundsException;

最后，对于我进入此线程时遇到的情况，有一种方法可以在满足某些条件时忽略测试。

现在我正在努力通过名为 JNA 的 java 本机库加载库调用一些 DLL，但我们的构建服务器位于 ubuntu 中。我喜欢尝试用 JUnit 测试来推动这种开发——尽管它们此时距离“单元”还很远——。我想做的是如果我在本地计算机上运行测试，但如果我们在 ubuntu 上则忽略测试。 JUnit 4 对此有一个规定，称为 Assume：

@Test
public void when_asking_JNA_to_load_a_dll() throws URISyntaxException {
    //this line will cause the test to be branded as "ignored" when "isCircleCI" 
    //(the machine running ubuntu is running this test) is true.
    Assume.assumeFalse(BootstrappingUtilities.isCircleCI());
    //an ignored test will typically result in some qualifier being put on the results, 
    //but will also not typically prevent a green-ton most platforms. 

    //setup
    URL url = DLLTestFixture.class.getResource("USERDLL.dll");
    String path = url.toURI().getPath();
    path = path.substring(0, path.lastIndexOf("/"));

    //act
    NativeLibrary.addSearchPath("USERDLL", path);
    Object dll = Native.loadLibrary("USERDLL", NativeCallbacks.EmptyInterface.class);

    //assert
    assertThat(dll).isNotNull();
}

Answer 4

我也在寻找 JUnit 的 pass 方法，这样我就可以短路一些在某些场景下不适用的测试（有集成测试，而不是纯粹的单元测试）。太糟糕了，它不在那里。

幸运的是，有一种方法可以有条件地忽略测试，这实际上更适合我使用 assumeTrue 方法的情况：

假设.assumeTrue(isTestApplicable);

所以这里只有当 isTestApplicable 为 true 时才会执行测试，否则测试将被忽略。

Answer 5

不需要 pass 方法，因为当测试代码中没有抛出 AssertionFailedException 时，单元测试用例就会通过。

如果控制到达该点，fail() 方法实际上会抛出 AssertionFailedException 以使 testCase 失败。

Answer 6

我认为这个问题是由于对测试执行过程的一些误解而产生的。在 JUnit（和其他测试工具）中，结果是按方法计算的，而不是按断言调用计算的。没有计数器可以跟踪执行了多少个通过/失败的 assertX。

JUnit 单独执行每个测试方法。如果该方法成功返回，则测试注册为“通过”。如果发生异常，则测试记录为“失败”。在后一种情况下，可能有两种子情况：1) JUnit 断言异常，2) 任何其他类型的异常。在第一种情况下，状态将为“失败”，在第二种情况下，状态将为“错误”。

在 Assert 类中，许多简写方法可用于引发断言异常。换句话说，Assert 是 JUnit 异常的抽象层。

例如，这是 GitHub：

/**
 * Asserts that two Strings are equal.
 */
static public void assertEquals(String message, String expected, String actual) {
    if (expected == null && actual == null) {
        return;
    }
    if (expected != null && expected.equals(actual)) {
        return;
    }
    String cleanMessage = message == null ? "" : message;
    throw new ComparisonFailure(cleanMessage, expected, actual);
}

如你所见，在相等的情况下什么也不会发生，否则会抛出异常。

所以：

assertEqual("Oh!", "Some string", "Another string!");

只是抛出一个 ComparisonFailure 异常，该异常将被 JUnit 捕获，并且

assertEqual("Oh?", "Same string", "Same string");

不执行任何操作。

总之，像 pass() 这样的东西没有任何意义，因为它没有做任何事情。