Аннотации в JUnit тестах

Last updated: 9 мая 2025 г.

Далее пройдемся по основным аннотациям junit.

В скобках у аннотации Test можно указать число. Это число – это количество миллисекунд. Если метод будет выполняться больше этого количества миллисекунд, то программа сообщит об этом.

Таким образом можно протестировать производительность тестируемого метода.

Пример программы:

1import org.junit.Assert;
2import org.junit.Test;
3
4public class TestCalc {
5    // проверяет, что метод исполняется
6    // не более 100 миллисекунд
7    @Test(timeout = 100)
8    public void testPow2() throws Exception {
9        Calc calc = new Calc();
10        int result = 0;
11        // Сделаем так чтобы тестовый
12        // метод длился более 100 миллисекунд.
13        // Хотя этот цикл было бы логичнее разместить
14        // в тестируемом методе pow, так как мы тестируем его
15        // производительность, а не тестового метода.
16        for (int i = 0; i < 1000000; i++) {
17            result = calc.pow(2, 4);
18        }
19        Assert.assertEquals(16, result);
20    }
21}

Скомпилируем и запустим:

Видим, что программа сообщает нам о том, что метод выполнялся более 100 миллисекунд. Значит очевидно нужно налаживать производительность.

Аннотация @Ignore

Если в тестовом классе несколько тестовых методов, то мы можем отключать какие-либо из них с помощью аннотации Ignore

Пример программы:

1import org.junit.Assert;
2import org.junit.Test;
3import org.junit.Ignore;
4
5public class TestCalc {
6    @Test
7    public void testPow() throws Exception{
8        Calc calc = new Calc();
9        int result = calc.pow(2, 4);
10        Assert.assertEquals(14, result);
11    }
12    //Также какой-либо тест можно отключить
13    //(следующий тест за этой
14    //аннотацией не запуститься).
15    @Ignore
16    @Test
17    public void testPow1() throws Exception{
18        Calc calc = new Calc();
19        int result = calc.pow(2, 4);
20        Assert.assertEquals(16, result);
21    }
22    @Test(timeout=100)
23    public void testPow2() throws Exception{
24        Calc calc = new Calc();
25        int result = 0;
26        for(int i=0;i<1000000;i++){
27            result = calc.pow(2, 4);
28        }
29        Assert.assertEquals(16, result);
30    }
31}

Компилируем и запускаем:

Как видим, хоть тестовых метода у нас три, а тестировалось всего два – Tests run: 2. Так как второй тестовый метод мы отключили.

Аннотации @BeforeClass, @AfterClass

С помощью аннотации @BeforeClass можно создать метод, который будет выполнен единожды перед тем, как начнут выполняться тестовые методы, а с помощью аннотации @AfterClass можно создать метод, который будет выполнен единожды после того, как выполняться все тестовые методы.

Зачем же нужны эти методы?

В случае с BeforeClass, чтобы, например, инициализировать какие-то данные, которые будут использоваться во всех тестах, в случае с AfterClass освободить какие-то ресурсы.

Пример программы:

1import org.junit.Assert;
2import org.junit.Test;
3import org.junit.BeforeClass;
4import org.junit.AfterClass;
5
6public class TestCalc {
7    //этот метод запускается перед тестовыми
8    @BeforeClass
9    public static void testBeforeClass() throws Exception{
10        System.out.println("before all classes");
11    }
12    //этот метод запускается после всех тестовых
13    @AfterClass
14    public static void testAfterClass() throws Exception{
15        System.out.println("after all classes");
16    }
17    @Test
18    public void testPow() throws Exception{
19        System.out.println("Test method 1");
20        Calc calc = new Calc();
21        int result = calc.pow(2, 4);
22        Assert.assertEquals(14, result);
23    }
24    @Test
25    public void testPow1() throws Exception{
26        System.out.println("Test method 2");
27        Calc calc = new Calc();
28        int result = calc.pow(2, 4);
29        Assert.assertEquals(16, result);
30    }
31    @Test(timeout=100)
32    public void testPow2() throws Exception{
33        System.out.println("Test method 3");
34        Calc calc = new Calc();
35        int result = calc.pow(2, 4);
36        Assert.assertEquals(16, result);
37    }
38}

Компилируем и запускаем.

Видим, что сразу вывелось сообщение из метода помеченного @BeforeClass, потом сообщения тестовых методов, потом сообщение из метода помеченного @AfterClass.

Аннотации @Before, @After

С помощью аннотации @Before можно создать метод, который будет выполняться перед каждым тестовым методом, а с помощью аннотации @After можно создать метод, который будет выполняться после каждого тестового метода

Пример программы:

1import org.junit.Assert;
2import org.junit.Test;
3import org.junit.Before;
4import org.junit.After;
5
6public class TestCalc {
7    //этот метод запускается перед каждым тестовым
8    @Before
9    public void testBefore() throws Exception{
10        System.out.println("before every class");
11    }
12
13    //этот метод запускается после каждого тестового
14    @After
15    public void testAfter() throws Exception{
16        System.out.println("after every class");
17    }
18
19    @Test
20    public void testPow() throws Exception{
21        System.out.println("Test method 1");
22        Calc calc = new Calc();
23        int result = calc.pow(2, 4);
24        Assert.assertEquals(14, result);
25    }
26
27    @Test
28    public void testPow1() throws Exception{
29        System.out.println("Test method 2");
30        Calc calc = new Calc();
31        int result = calc.pow(2, 4);
32        Assert.assertEquals(16, result);
33    }
34
35    @Test(timeout=100)
36    public void testPow2() throws Exception{
37        System.out.println("Test method 3");
38        Calc calc = new Calc();
39        int result = calc.pow(2, 4);
40        Assert.assertEquals(16, result);
41    }
42}

Компилируем и запускаем.

Видим, что перед каждым сообщением из тестового метода выводилось сообщение из метода помеченного @Before, и также после каждого сообщения тестового метода выводилось сообщение из метода помеченного аннотацией @After.