Как насчет этого: поймайте очень общее исключение, убедитесь, что оно выходит из блока catch, а затем подтвердите, что класс исключения такой, каким вы его ожидаете. Это утверждение не будет выполнено, если а) исключение неправильного типа (например, если вместо этого вы получили нулевой указатель) и б) исключение не было создано.

public void testFooThrowsIndexOutOfBoundsException() {
  Throwable e = null;

  try {
    foo.doStuff();
  } catch (Throwable ex) {
    e = ex;
  }

  assertTrue(e instanceof IndexOutOfBoundsException);
}

JUnit имеет встроенную поддержку для этого с "ожидаемый" атрибут.

Это зависит от версии JUnit и используемых вами assert-библиотек.

• Для JUnit5 и 4.13 см. Ответ https://stackoverflow.com/a/2935935/2986984
• Если вы используете assertJ или google-true, см. Ответ https://stackoverflow.com/a/41019785/2986984

Первоначальный ответ для JUnit <= 4.12 был:

@Test(expected = IndexOutOfBoundsException.class)
public void testIndexOutOfBoundsException() {

    ArrayList emptyList = new ArrayList();
    Object o = emptyList.get(0);

}

Хотя ответ https://stackoverflow.com/a/31826781/2986984 имеет больше вариантов для JUnit <= 4.12.

Справка :

• JUnit Test-FAQ

Будьте осторожны при использовании ожидаемого исключения, потому что оно только утверждает, что метод сгенерировало это исключение, а не конкретная строка кода в тесте.

Я обычно использую это для проверки параметров проверки, потому что такие методы обычно очень просты, но для более сложных тестов лучше использовать:

try {
    methodThatShouldThrow();
    fail( "My method didn't throw when I expected it to" );
} catch (MyException expectedException) {
}

Применяйте суждение.

Редактировать: Теперь, когда выпущены JUnit 5 и JUnit 4.13, лучшим вариантом было бы использовать Assertions.assertThrows() (для JUnit 5) и Assert.assertThrows() (для JUnit 4.13+). Подробнее см. мой другой ответ.

Если вы не перешли на JUnit 5, но можете использовать JUnit 4.7, вы можете использовать правило ExpectedException:

public class FooTest {
  @Rule
  public final ExpectedException exception = ExpectedException.none();

  @Test
  public void doStuffThrowsIndexOutOfBoundsException() {
    Foo foo = new Foo();

    exception.expect(IndexOutOfBoundsException.class);
    foo.doStuff();
  }
}

Это намного лучше, чем @Test(expected=IndexOutOfBoundsException.class), потому что тест завершится неудачно, если IndexOutOfBoundsException будет брошен до foo.doStuff().

Подробнее см. эта статья.

Чтобы решить ту же проблему, я создал небольшой проект: http://code.google.com/p/catch-exception/

Используя этот маленький помощник, вы могли бы написать

verifyException(foo, IndexOutOfBoundsException.class).doStuff();

Это менее подробное правило, чем правило ExpectedException в JUnit 4.7. По сравнению с решением, предоставленным skaffman, вы можете указать, в какой строке кода вы ожидаете исключение. Надеюсь, это поможет.

Я пробовал здесь многие методы, но они были либо сложными, либо не совсем соответствовали моим требованиям. Фактически, можно довольно просто написать вспомогательный метод:

public class ExceptionAssertions {
    public static void assertException(BlastContainer blastContainer ) {
        boolean caughtException = false;
        try {
            blastContainer.test();
        } catch( Exception e ) {
            caughtException = true;
        }
        if ( !caughtException ) {
            throw new AssertionFailedError("exception expected to be thrown, but was not");
        }
    }
    public static interface BlastContainer {
        public void test() throws Exception;
    }
}

Используйте это так:

assertException(new BlastContainer() {
    @Override
    public void test() throws Exception {
        doSomethingThatShouldExceptHere();
    }
});

Отсутствие зависимостей: нет необходимости в mockito, нет необходимости в powermock; и отлично работает с финальными классами.

Вы также можете сделать это:

@Test
public void testFooThrowsIndexOutOfBoundsException() {
    try {
        foo.doStuff();
        assert false;
    } catch (IndexOutOfBoundsException e) {
        assert true;
    }
}

Просто сделайте Матчер, который можно включать и выключать, например:

public class ExceptionMatcher extends BaseMatcher<Throwable> {
    private boolean active = true;
    private Class<? extends Throwable> throwable;

    public ExceptionMatcher(Class<? extends Throwable> throwable) {
        this.throwable = throwable;
    }

    public void on() {
        this.active = true;
    }

    public void off() {
        this.active = false;
    }

    @Override
    public boolean matches(Object object) {
        return active && throwable.isAssignableFrom(object.getClass());
    }

    @Override
    public void describeTo(Description description) {
        description.appendText("not the covered exception type");
    }
}

Чтобы использовать это:

добавить public ExpectedException exception = ExpectedException.none();, потом:

ExceptionMatcher exMatch = new ExceptionMatcher(MyException.class);
exception.expect(exMatch);
someObject.somethingThatThrowsMyException();
exMatch.off();

В моем случае я всегда получаю RuntimeException от db, но сообщения различаются. И исключение необходимо обрабатывать соответственно. Вот как я это тестировал:

@Test
public void testThrowsExceptionWhenWrongSku() {

    // Given
    String articleSimpleSku = "999-999";
    int amountOfTransactions = 1;
    Exception exception = null;

    // When
    try {
        createNInboundTransactionsForSku(amountOfTransactions, articleSimpleSku);
    } catch (RuntimeException e) {
        exception = e;
    }

    // Then
    shouldValidateThrowsExceptionWithMessage(exception, MESSAGE_NON_EXISTENT_SKU);
}

private void shouldValidateThrowsExceptionWithMessage(final Exception e, final String message) {
    assertNotNull(e);
    assertTrue(e.getMessage().contains(message));
}

Решение стиля BDD: JUnit 4 + Поймать исключение + AssertJ

import static com.googlecode.catchexception.apis.BDDCatchException.*;

@Test
public void testFooThrowsIndexOutOfBoundsException() {

    when(() -> foo.doStuff());

    then(caughtException()).isInstanceOf(IndexOutOfBoundsException.class);

}

Зависимости

eu.codearte.catch-exception:catch-exception:2.0

Как уже было сказано ранее, в JUnit есть много способов работы с исключениями. Но с Java 8 есть еще один: использование лямбда-выражений. С помощью лямбда-выражений мы можем добиться такого синтаксиса:

@Test
public void verifiesTypeAndMessage() {
    assertThrown(new DummyService()::someMethod)
            .isInstanceOf(RuntimeException.class)
            .hasMessage("Runtime exception occurred")
            .hasMessageStartingWith("Runtime")
            .hasMessageEndingWith("occurred")
            .hasMessageContaining("exception")
            .hasNoCause();
}

assertThrown принимает функциональный интерфейс, экземпляры которого могут быть созданы с помощью лямбда-выражений, ссылок на методы или ссылок на конструкторы. assertThrown, принимающий этот интерфейс, будет ожидать и готов обработать исключение.

Это относительно простой, но мощный метод.

Взгляните на это сообщение в блоге, описывающее эту технику: http://blog.codeleak.pl/2014/07/junit-testing-exception-with-java-8-and-lambda-expressions.html

Исходный код можно найти здесь: https://github.com/kolorobot/unit-testing-demo/tree/master/src/test/java/com/github/kolorobot/exceptions/java8

Раскрытие информации: я являюсь автором блога и проекта.

Мы можем использовать ошибку утверждения после метода, который должен возвращать исключение:

try{
   methodThatThrowMyException();
   Assert.fail("MyException is not thrown !");
} catch (final Exception exception) {
   // Verify if the thrown exception is instance of MyException, otherwise throws an assert failure
   assertTrue(exception instanceof MyException, "An exception other than MyException is thrown !");
   // In case of verifying the error message
   MyException myException = (MyException) exception;
   assertEquals("EXPECTED ERROR MESSAGE", myException.getMessage());
}

IMHO, лучший способ проверить исключения в JUnit - это шаблон try / catch / fail / assert:

// this try block should be as small as possible,
// as you want to make sure you only catch exceptions from your code
try {
    sut.doThing();
    fail(); // fail if this does not throw any exception
} catch(MyException e) { // only catch the exception you expect,
                         // otherwise you may catch an exception for a dependency unexpectedly
    // a strong assertion on the message, 
    // in case the exception comes from anywhere an unexpected line of code,
    // especially important if your checking IllegalArgumentExceptions
    assertEquals("the message I get", e.getMessage()); 
}

assertTrue может показаться немного сильным для некоторых, поэтому assertThat(e.getMessage(), containsString("the message"); может быть предпочтительнее.

В дополнение к тому, что сказал NamShubWriter, убедитесь, что:

• Экземпляр ExpectedException - общественный (Связанный вопрос)
• ExpectedException не создается, скажем, в методе @Before. Этот Почта ясно объясняет все тонкости порядка выполнения JUnit.

Сделайте нет так:

@Rule    
public ExpectedException expectedException;

@Before
public void setup()
{
    expectedException = ExpectedException.none();
}

Наконец, сообщение в блоге это ясно показывает, как утверждать, что возникло определенное исключение.

В junit есть четыре способа проверить исключение.

junit5.x

• для junit5.x вы можете использовать assertThrows следующим образом

  @Test
  public void testFooThrowsIndexOutOfBoundsException() {
      Throwable exception = assertThrows(IndexOutOfBoundsException.class, () -> foo.doStuff());
      assertEquals("expected messages", exception.getMessage());
  }
  

junit4.x

• для junit4.x используйте необязательный атрибут 'expected' аннотации Test

  @Test(expected = IndexOutOfBoundsException.class)
  public void testFooThrowsIndexOutOfBoundsException() {
      foo.doStuff();
  }
  

• для junit4.x используйте правило ExpectedException

  public class XxxTest {
      @Rule
      public ExpectedException thrown = ExpectedException.none();
  
      @Test
      public void testFooThrowsIndexOutOfBoundsException() {
          thrown.expect(IndexOutOfBoundsException.class)
          //you can test the exception message like
          thrown.expectMessage("expected messages");
          foo.doStuff();
      }
  }
  

• вы также можете использовать классический способ try / catch, широко используемый в рамках junit 3

  @Test
  public void testFooThrowsIndexOutOfBoundsException() {
      try {
          foo.doStuff();
          fail("expected exception was not occured.");
      } catch(IndexOutOfBoundsException e) {
          //if execution reaches here, 
          //it indicates this exception was occured.
          //so we need not handle it.
      }
  }
  

• так

  • если вам нравится junit 5, то вам понравится 1-й
  • 2-й способ используется, когда вы хотите проверить только тип исключения
  • первые и последние два используются, когда вы хотите получить сообщение об исключении теста.
  • если вы используете junit 3, то предпочтительнее 4-й

• для получения дополнительной информации вы можете прочитать этот документ и junit5 руководство пользователя для подробностей.

Решение Java 8

Если вам нужно решение, которое:

• Использует лямбды Java 8
• Зависит ли нет от какой-либо магии JUnit
• Позволяет проверять наличие нескольких исключений в рамках одного метода тестирования.
• Проверяет наличие исключения, создаваемого определенным набором строк в вашем методе тестирования, а не любой неизвестной строкой во всем методе тестирования.
• Выдает фактический объект исключения, который был сгенерирован, чтобы вы могли его дополнительно изучить.

Вот служебная функция, которую я написал:

public final <T extends Throwable> T expectException( Class<T> exceptionClass, Runnable runnable )
{
    try
    {
        runnable.run();
    }
    catch( Throwable throwable )
    {
        if ( throwable instanceof AssertionError && throwable.getCause() != null )
            throwable = throwable.getCause(); //allows "assert x != null : new IllegalArgumentException();"
        assert exceptionClass.isInstance( throwable ) : throwable; //exception of the wrong kind was thrown.
        assert throwable.getClass() == exceptionClass : throwable; //exception thrown was a subclass, but not the exact class, expected.
        @SuppressWarnings( "unchecked" )
        T result = (T)throwable;
        return result;
    }
    assert false; //expected exception was not thrown.
    return null; //to keep the compiler happy.
}

(взято из моего блога)

Используйте его следующим образом:

@Test
public void testThrows()
{
    RuntimeException e = expectException( RuntimeException.class, () -> 
        {
            throw new RuntimeException( "fail!" );
        } );
    assert e.getMessage().equals( "fail!" );
}

Использование утверждения AssertJ, которое можно использовать вместе с JUnit:

import static org.assertj.core.api.Assertions.*;

@Test
public void testFooThrowsIndexOutOfBoundsException() {
  Foo foo = new Foo();

  assertThatThrownBy(() -> foo.doStuff())
        .isInstanceOf(IndexOutOfBoundsException.class);
}

Это лучше, чем @Test(expected=IndexOutOfBoundsException.class), потому что он гарантирует, что ожидаемая строка в тесте вызвала исключение, и позволяет вам проверить более подробную информацию об исключении, например сообщение, проще:

assertThatThrownBy(() ->
       {
         throw new Exception("boom!");
       })
    .isInstanceOf(Exception.class)
    .hasMessageContaining("boom");

Инструкции Maven / Gradle здесь.

Я хотел прокомментировать свое решение этой проблемы, чтобы избежать необходимости в коде JUnit, связанном с исключениями.

Я использовал assertTrue (boolean) в сочетании с try / catch, чтобы найти ожидаемое исключение, которое должно быть сгенерировано. Вот пример:

public void testConstructor() {
    boolean expectedExceptionThrown;
    try {
        // Call constructor with bad arguments
        double a = 1;
        double b = 2;
        double c = a + b; // In my example, this is an invalid option for c
        new Triangle(a, b, c);
        expectedExceptionThrown = false; // because it successfully constructed the object
    }
    catch(IllegalArgumentException e) {
        expectedExceptionThrown = true; // because I'm in this catch block
    }
    catch(Exception e) {
        expectedExceptionThrown = false; // because it threw an exception but not the one expected
    }
    assertTrue(expectedExceptionThrown);
}

Решение JUnit 5

@Test
void testFooThrowsIndexOutOfBoundsException() {    
  Throwable exception = expectThrows( IndexOutOfBoundsException.class, foo::doStuff );

  assertEquals( "some message", exception.getMessage() );
}

Дополнительная информация о JUnit 5 на http://junit.org/junit5/docs/current/user-guide/#writing-tests-assertions

Возьмем, к примеру, вы хотите написать Junit для указанного ниже фрагмента кода.

public int divideByZeroDemo(int a,int b){

    return a/b;
}

public void exceptionWithMessage(String [] arr){

    throw new ArrayIndexOutOfBoundsException("Array is out of bound");
}

Приведенный выше код предназначен для проверки того, что может произойти какое-то неизвестное исключение, а приведенный ниже - для подтверждения некоторого исключения с помощью настраиваемого сообщения.

 @Rule
public ExpectedException exception=ExpectedException.none();

private Demo demo;
@Before
public void setup(){

    demo=new Demo();
}
@Test(expected=ArithmeticException.class)
public void testIfItThrowsAnyException() {

    demo.divideByZeroDemo(5, 0);

}

@Test
public void testExceptionWithMessage(){


    exception.expectMessage("Array is out of bound");
    exception.expect(ArrayIndexOutOfBoundsException.class);
    demo.exceptionWithMessage(new String[]{"This","is","a","demo"});
}

В JUnit 4 или новее вы можете протестировать исключения следующим образом

@Rule
public ExpectedException exceptions = ExpectedException.none();

предоставляет множество функций, которые можно использовать для улучшения наших тестов JUnit.
Если вы видите пример ниже, я тестирую 3 вещи на исключение.

1. Тип выброшенного исключения
2. Сообщение об исключении
3. Причина исключения

public class MyTest {

    @Rule
    public ExpectedException exceptions = ExpectedException.none();

    ClassUnderTest classUnderTest;

    @Before
    public void setUp() throws Exception {
        classUnderTest = new ClassUnderTest();
    }

    @Test
    public void testAppleisSweetAndRed() throws Exception {

        exceptions.expect(Exception.class);
        exceptions.expectMessage("this is the exception message");
        exceptions.expectCause(Matchers.<Throwable>equalTo(exceptionCause));

        classUnderTest.methodUnderTest("param1", "param2");
    }

}

Обновлять: JUnit5 имеет улучшение для тестирования исключений: assertThrows.

Следующий пример взят из: Руководство пользователя Junit 5

 @Test
void exceptionTesting() {
    Throwable exception = assertThrows(IllegalArgumentException.class, () -> 
    {
        throw new IllegalArgumentException("a message");
    });
    assertEquals("a message", exception.getMessage());
}

Оригинальный ответ с использованием JUnit 4.

Есть несколько способов проверить возникновение исключения. Я также обсудил следующие варианты в моем сообщении Как писать отличные модульные тесты с JUnit

Установите параметр expected@Test(expected = FileNotFoundException.class).

@Test(expected = FileNotFoundException.class) 
public void testReadFile() { 
    myClass.readFile("test.txt");
}

Использование trycatch

public void testReadFile() { 
    try {
        myClass.readFile("test.txt");
        fail("Expected a FileNotFoundException to be thrown");
    } catch (FileNotFoundException e) {
        assertThat(e.getMessage(), is("The file test.txt does not exist!"));
    }
     
}

Тестирование по правилу ExpectedException.

@Rule
public ExpectedException thrown = ExpectedException.none();

@Test
public void testReadFile() throws FileNotFoundException {
    
    thrown.expect(FileNotFoundException.class);
    thrown.expectMessage(startsWith("The file test.txt"));
    myClass.readFile("test.txt");
}

Вы можете узнать больше о тестировании исключений в JUnit4 wiki для тестирования исключений и bad.robot - Ожидание исключений Правило JUnit.

В Java 8 вы можете создать метод, принимающий код для проверки и ожидаемое исключение в качестве параметров:

private void expectException(Runnable r, Class<?> clazz) { 
    try {
      r.run();
      fail("Expected: " + clazz.getSimpleName() + " but not thrown");
    } catch (Exception e) {
      if (!clazz.isInstance(e)) fail("Expected: " + clazz.getSimpleName() + " but " + e.getClass().getSimpleName() + " found", e);
    }
  }

а затем внутри вашего теста:

expectException(() -> list.sublist(0, 2).get(2), IndexOutOfBoundsException.class);

Выгоды:

• не полагаться на какую-либо библиотеку
• локализованная проверка - более точная и позволяет при необходимости иметь несколько таких утверждений в одном тесте
• легко использовать

Теперь, когда выпущены JUnit 5 и JUnit 4.13, лучшим вариантом будет использование Assertions.assertThrows() (для JUnit 5) и Assert.assertThrows() (для JUnit 4.13). Видеть файл Руководство пользователя Junit 5.

Вот пример, который проверяет возникновение исключения и использует Правда для утверждения сообщения об исключении:

public class FooTest {
  @Test
  public void doStuffThrowsIndexOutOfBoundsException() {
    Foo foo = new Foo();

    IndexOutOfBoundsException e = assertThrows(
        IndexOutOfBoundsException.class, foo::doStuff);

    assertThat(e).hasMessageThat().contains("woops!");
  }
}

Преимущества перед подходами в других ответах:

1. Встроенный в JUnit
2. Вы получаете полезное сообщение об исключении, если код в лямбда-выражении не генерирует исключение, и трассировку стека, если он генерирует другое исключение.
3. Краткий
4. Позволяет вашим тестам следовать Arrange-Act-Assert
5. Вы можете точно указать, какой код вы ожидаете выбросить исключение.
6. Вам не нужно указывать ожидаемое исключение в предложении throws.
7. Вы можете использовать выбранную вами структуру утверждений, чтобы делать утверждения об обнаруженном исключении.

Аналогичный метод будет добавлен в org.junit Assert в JUnit 4.13.

Мое решение с использованием лямбда-выражений Java 8:

public static <T extends Throwable> T assertThrows(Class<T> expected, ThrowingRunnable action) throws Throwable {
    try {
        action.run();
        Assert.fail("Did not throw expected " + expected.getSimpleName());
        return null; // never actually
    } catch (Throwable actual) {
        if (!expected.isAssignableFrom(actual.getClass())) { // runtime '!(actual instanceof expected)'
            System.err.println("Threw " + actual.getClass().getSimpleName() 
                               + ", which is not a subtype of expected " 
                               + expected.getSimpleName());
            throw actual; // throw the unexpected Throwable for maximum transparency
        } else {
            return (T) actual; // return the expected Throwable for further examination
        }
    }
}

Вы должны определить FunctionalInterface, потому что Runnable не объявляет требуемый throws.

@FunctionalInterface
public interface ThrowingRunnable {
    void run() throws Throwable;
}

Метод можно использовать следующим образом:

class CustomException extends Exception {
    public final String message;
    public CustomException(final String message) { this.message = message;}
}
CustomException e = assertThrows(CustomException.class, () -> {
    throw new CustomException("Lorem Ipsum");
});
assertEquals("Lorem Ipsum", e.message);

Есть два способа написать тестовый пример

1. Аннотируйте тест с исключением, которое генерируется методом. Что-то вроде этого @Test(expected = IndexOutOfBoundsException.class)

2. Вы можете просто перехватить исключение в тестовом классе с помощью блока try catch и подтвердить сообщение, которое генерируется методом в тестовом классе.

   try{
   }
   catch(exception to be thrown from method e)
   {
        assertEquals("message", e.getmessage());
   }
   

Я надеюсь это ответит на ваш вопрос Удачного обучения ...

Самый гибкий и элегантный ответ для Junit 4 я нашел в Блог Mkyong. Он имеет гибкость try/catch с использованием аннотации @Rule. Мне нравится этот подход, потому что вы можете читать определенные атрибуты настроенного исключения.

package com.mkyong;

import com.mkyong.examples.CustomerService;
import com.mkyong.examples.exception.NameNotFoundException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.Matchers.hasProperty;

public class Exception3Test {

    @Rule
    public ExpectedException thrown = ExpectedException.none();

    @Test
    public void testNameNotFoundException() throws NameNotFoundException {

        //test specific type of exception
        thrown.expect(NameNotFoundException.class);

        //test message
        thrown.expectMessage(is("Name is empty!"));

        //test detail
        thrown.expect(hasProperty("errCode"));  //make sure getters n setters are defined.
        thrown.expect(hasProperty("errCode", is(666)));

        CustomerService cust = new CustomerService();
        cust.findByName("");

    }

}

Решение Junit4 с Java8 должно использовать эту функцию:

public Throwable assertThrows(Class<? extends Throwable> expectedException, java.util.concurrent.Callable<?> funky) {
    try {
        funky.call();
    } catch (Throwable e) {
        if (expectedException.isInstance(e)) {
            return e;
        }
        throw new AssertionError(
                String.format("Expected [%s] to be thrown, but was [%s]", expectedException, e));
    }
    throw new AssertionError(
            String.format("Expected [%s] to be thrown, but nothing was thrown.", expectedException));
}

Тогда использование:

    assertThrows(ValidationException.class,
            () -> finalObject.checkSomething(null));

Обратите внимание, что единственным ограничением является использование ссылки на объект final в лямбда-выражении. Это решение позволяет продолжить тестовые утверждения вместо ожидания возможности показать на уровне метода с использованием решения @Test(expected = IndexOutOfBoundsException.class).

Я рекомендую библиотеку assertj-core для обработки исключений в тесте junit

В java 8 вот так:

//given

//when
Throwable throwable = catchThrowable(() -> anyService.anyMethod(object));

//then
AnyException anyException = (AnyException) throwable;
assertThat(anyException.getMessage()).isEqualTo("........");
assertThat(exception.getCode()).isEqualTo(".......);

try {
    my method();
    fail( "This method must thrwo" );
} catch (Exception ex) {
    assertThat(ex.getMessage()).isEqual(myErrormsg);
}

    @Test(expectedException=IndexOutOfBoundsException.class) 
    public void  testFooThrowsIndexOutOfBoundsException() throws Exception {
         doThrow(IndexOutOfBoundsException.class).when(foo).doStuff();  
         try {
             foo.doStuff(); 
            } catch (IndexOutOfBoundsException e) {
                       assertEquals(IndexOutOfBoundsException .class, ex.getCause().getClass());
                      throw e;

               }

    }

Вот еще один способ проверить, вызвал ли метод правильное исключение.

Фреймворк JUnit имеет метод assertThrows():

ArithmeticException exception = assertThrows(ArithmeticException.class, () ->
    calculator.divide(1, 0));
assertEquals("/ by zero", exception.getMessage());

• для JUnit 5 это класс org.junit.jupiter.api.Assertions;
• для JUnit 4.13 это класс org.junit.Assert;
• для более ранних версий JUnit 4: просто добавьте ссылку на org.junit.jupiter:junit-jupiter-api в свой проект, и вы получите отлично работающую версию из JUnit 5.