Разница между @Before, @BeforeClass, @BeforeEach и @BeforeAll
В чем главное отличие
@Beforeа также@BeforeClass- и в Юнит 5
@BeforeEachа также@BeforeAll
- и в Юнит 5
@Afterа также@AfterClass
Согласно JUnit Api @Before используется в следующем случае:
При написании тестов часто обнаруживается, что нескольким тестам нужны похожие объекты, созданные до того, как они смогут работать.
В то время как @BeforeClass может использоваться для установления соединения с базой данных. Но не мог @Before делать то же самое?
8 ответов
Код помечен @Before выполняется перед каждым тестом, а @BeforeClass запускается один раз перед всем испытательным приспособлением. Если ваш тестовый класс имеет десять тестов, @Before код будет выполнен десять раз, но @BeforeClass будет выполнен только один раз.
В общем, вы используете @BeforeClass когда несколько тестов должны использовать один и тот же дорогостоящий код установки. Установление соединения с базой данных попадает в эту категорию. Вы можете переместить код из @BeforeClass в @Before, но ваш тестовый запуск может занять больше времени. Обратите внимание, что код помечен @BeforeClass запускается как статический инициализатор, поэтому он будет работать до создания экземпляра класса вашего тестового устройства.
В JUnit 5 теги @BeforeEach а также @BeforeAll являются эквивалентами @Before а также @BeforeClass в JUnit 4. Их имена немного более показательны, когда они запускаются, в некоторой степени интерпретируются: "перед каждым тестом" и "один раз перед всеми тестами".
Разница между каждой аннотацией:
+-------------------------------------------------------------------------------------------------------+
¦ 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. ¦ ¦ ¦
+-------------------------------------------------------------------------------------------------------+
Большинство аннотаций в обеих версиях одинаковы, но мало отличаются.
Порядок исполнения.
Штриховая рамка -> дополнительная аннотация.
До и Перед Классом в 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
@Before(JUnit4) ->
@BeforeEach(JUnit5) - метод вызывается перед каждым тестом
@After(JUnit4) ->
@AfterEach(JUnit5) - метод вызывается после каждого теста
@BeforeClass(JUnit4) ->
@BeforeAll(JUnit5) - статический метод вызывается перед выполнением всех тестов в этом классе. Это может быть большая задача, например, запуск сервера, чтение файла, подключение к базе данных ...
@AfterClass(JUnit4) ->
@AfterAll(JUnit5) - статический метод вызывается после выполнения всех тестов в этом классе.
import org.junit.Assert
import org.junit.Before
import org.junit.BeforeClass
import org.junit.Test
class FeatureTest {
companion object {
private lateinit var heavyFeature: HeavyFeature
@BeforeClass
@JvmStatic
fun beforeHeavy() {
heavyFeature = HeavyFeature()
}
}
private lateinit var feature: Feature
@Before
fun before() {
feature = Feature()
}
@Test
fun testCool() {
Assert.assertTrue(heavyFeature.cool())
Assert.assertTrue(feature.cool())
}
@Test
fun testWow() {
Assert.assertTrue(heavyFeature.wow())
Assert.assertTrue(feature.wow())
}
}
Такой же как
import org.junit.Assert
import org.junit.Test
class FeatureTest {
companion object {
private val heavyFeature = HeavyFeature()
}
private val feature = Feature()
@Test
fun testCool() {
Assert.assertTrue(heavyFeature.cool())
Assert.assertTrue(feature.cool())
}
@Test
fun testWow() {
Assert.assertTrue(heavyFeature.wow())
Assert.assertTrue(feature.wow())
}
}
Основное различие между всеми этими аннотациями заключается в следующем:
- @BeforeEach - используется для запуска общего кода (например, setUp) перед каждым выполнением тестового метода. аналогично JUnit 4 @Before.
- @AfterEach - используется для запуска общего кода после (например, tearDown) выполнения каждого метода тестирования. аналогично @After из JUnit 4.
- @BeforeAll - используется для однократного запуска каждого класса перед выполнением любого теста. аналогично JUnit 4 @BeforeClass.
- @AfterAll - используется для однократного запуска для каждого класса после выполнения всех тестов. аналогично @AfterClass из JUnit 4.
Все эти аннотации вместе с использованием определены в Codingeek - Junit5 Test Lifecycle.
будет запускаться перед всеми тестовыми костюмами, тогда как будет выполняться выполняется перед каждым тестом, а запускается один раз перед всем тестовым устройством. Если в вашем тестовом классе десять тестов,
@Before код будет выполнен десять раз, но
@BeforeClass будет выполняться только один раз.
Тестовый пример JUnit 5 должен пройти несколько жизненных циклов. В первую очередь существует 4 основных жизненных цикла Junit 5, то есть @BeforeAll, @BeforeEach, @AfterEach и @AfterAll.
public class AppleCalculator {
public int addApple(int apple1, int apple2) {
return apple1 + apple2;
}
}
прецедент
class AppleCalculatorTest {
@BeforeAll
static void beforeAll() {
System.out.println("AppleCalculatorTest.beforeAll");
}
@BeforeEach
void beforeEach() {
System.out.println("AppleCalculatorTest.beforeEach");
}
@Test
void test() {
System.out.println("AppleCalculatorTest.test");
}
@AfterEach
void afterEach() {
System.out.println("AppleCalculatorTest.afterEach");
}
@AfterAll
static void afterAll() {
System.out.println("AppleCalculatorTest.afterAll");
}
}
@BeforeAll
JUnit 4 @BeforeClass = JUnit 5 @BeforeAll
@BeforeAll суперкласс
@AfterAll Суперкласс
JUnit 4 @AfterClass = JUnit 5 @AfterAll
@BeforeEach
@BeforeEach Суперкласс
@AfterEach
@AfterEach Суперкласс
большинство аннотаций здесь довольно четко объяснено, но если у вас все еще есть сомнения, вы можете меня приколоть.