Разница между @Before, @BeforeClass, @BeforeEach и @BeforeAll

В чем основное отличие между

@Before и @BeforeClass
- и в JUnit 5 @BeforeEach и @BeforeAll
@After и @AfterClass

В соответствии с JUnit Api @Before используется в следующем случае:

При написании тестов обычно обнаруживается, что для нескольких тестов нужны похожие объекты, созданные до их запуска.

В то время как @BeforeClass может использоваться для установления соединения с базой данных. Но не мог ли @Before сделать то же самое?

Ответ 1

Код, отмеченный @Before, выполняется перед каждым тестом, а @BeforeClass выполняется один раз перед всем тестированием. Если ваш тестовый класс имеет десять тестов, код @Before будет выполняться десять раз, но @BeforeClass будет выполняться только один раз.

В общем, вы используете @BeforeClass, когда несколько тестов должны использовать один и тот же вычислительный дорогой код установки. Установление соединения с базой данных относится к этой категории. Вы можете перемещать код из @BeforeClass в @Before, но ваш тестовый прогон может занять больше времени. Обратите внимание, что код, отмеченный @BeforeClass, запускается как статический инициализатор, поэтому он запускается до создания экземпляра класса вашего тестового устройства.

В JUnit 5 теги @BeforeEach и @BeforeAll являются эквивалентами @Before и @BeforeClass в JUnit 4. Их имена немного более показательно, когда они запускаются, слабо интерпретируются: "перед каждым тестом" и "один раз перед всеми тестами".

Ответ 2

Разница между каждой аннотацией:

+-------------------------------------------------------------------------------------------------------+
¦                                       Feature                            ¦   Junit 4    ¦   Junit 5   ¦
¦--------------------------------------------------------------------------+--------------+-------------¦
¦ Execute before all test methods of the class are executed.               ¦ @BeforeClass ¦ @BeforeAll  ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some initialization code          ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after all test methods in the current class.                     ¦ @AfterClass  ¦ @AfterAll   ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some cleanup code.                ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute before each test method.                                         ¦ @Before      ¦ @BeforeEach ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to reinitialize some class attributes used by the methods.  ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after each test method.                                          ¦ @After       ¦ @AfterEach  ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to roll back database modifications.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

Большинство аннотаций в обеих версиях одинаковы, но немногие отличаются.

Справка

Порядок исполнения.

Пунктирная рамка → дополнительная аннотация.

Ответ 3

До и BeforeClass в JUnit

Функция @Before аннотации будет выполняться перед каждой из тестовых функций в классе с аннотацией @Test но функция с @BeforeClass будет выполняться только за один раз до всех тестовых функций в классе.

Аналогично функция @After аннотации будет выполняться после каждой из тестовых функций в классе с аннотацией @Test но функция с @AfterClass будет выполняться только один раз после всех тестовых функций в классе.

SampleClass

public class SampleClass {
    public String initializeData(){
        return "Initialize";
    }

    public String processDate(){
        return "Process";
    }
 }

Образец теста

public class SampleTest {

    private SampleClass sampleClass;

    @BeforeClass
    public static void beforeClassFunction(){
        System.out.println("Before Class");
    }

    @Before
    public void beforeFunction(){
        sampleClass=new SampleClass();
        System.out.println("Before Function");
    }

    @After
    public void afterFunction(){
        System.out.println("After Function");
    }

    @AfterClass
    public static void afterClassFunction(){
        System.out.println("After Class");
    }

    @Test
    public void initializeTest(){
        Assert.assertEquals("Initailization check", "Initialize", sampleClass.initializeData() );
    }

    @Test
    public void processTest(){
        Assert.assertEquals("Process check", "Process", sampleClass.processDate() );
    }

}

Вывод

Before Class
Before Function
After Function
Before Function
After Function
After Class

В июне 5

@Before = @BeforeEach
@BeforeClass = @BeforeAll
@After = @AfterEach
@AfterClass = @AfterAll