使用相同的异常测试多行代码

Question

I have a code segment like shown below. Each line of code throw same exception. However, in practice, when first line throws an exception, testFoo finishes its job and does not continue, as expected. But, I want a bit more different thing; since they are throwing same exception, I want to continue and check these three lines wrt the exception which they all throw. If they throw, test should be continue.

How can I test these three line wrt same exception?

  @test
   void testFoo(){

       assertNull( /*errorMessage*/, ClassFoo.foo(null));    // foo will throw `AssertionError` due to null parameter
       assertNull( /*errorMessage*/, ClassBar.bar(null));    // foo will throw `AssertionError` due to null parameter
       assertNull( /*errorMessage*/, ClassGbr.gbr(null));   // foo will throw `AssertionError` due to null parameter
    }

Answer 1

I have tried to implement precondition for each parameters to a method with Java built-in Assert.assertTrue...

This is not built into java, this is from junit: void junit.framework.Assert.assertTrue(...) . You are confusing Java Assertions with Junit assertions.

Junit assertions should be used in your unit tests. They look like Assert.assertEquals(result, "expected result"); They are intended to test the validity of the methods under test in your unit tests.

Java assertions should be used when verifying assumptions. They look like assert param!=null:"param should not be null!"; They are part of the java language and can be turned on and off at compile time. They are intended to double check assumptions in your code and to produce zero overhead when turned off.

Programming with assertions is a great thing. Using Junit assertions outside of unit tests is dubious.

Answer 2

My interpretation of this question is that you are expecting an AssertFailedError in your unit test and this is meant to be part of this test. If that is the case, you can use the following junit method structure:

@Test(expected = AssertFailedError.class)
public void testFoo() throws AssertFailedError
{
  assertNotNull(null);
}

You can use this when you are testing a block of code that you know will throw an exception.

Answer 3

Just catch the exception yourself:

@Test
void testFoo() {
    boolean fooHasThrownException = false;
    boolean barHasThrownException = false;
    boolean gbrHasThrownException = false;

    try {
        ClassFoo.foo(null);
        fail();
    } catch (AssertionError e) {
        fooHasThrownException = true;
    }

    try {
        ClassBar.bar(null);
        fail();
    } catch (AssertionError e) {
        barHasThrownException = true;
    }

    try {
        ClassGbr.gbr(null);
        fail();
    } catch (AssertionError e) {
        gbrHasThrownException = true;
    }

    assertThat(true, equalTo(fooHasThrownException),
                     equalTo(barHasThrownException),
                     equalTo(gbrHasThrownException));
}

Note that your assertNull() is redundant. If a method throws an exception, it will not return anything.

On the side, this is a very weird scenario to be testing. If a method throws an exception, it just seems more logical to stop any further processing, if those processes down the line are going to also throw exceptions anyway.