Тестирование Java при помощи JUnit: примеры и советы по тестированию
На курсе QA от Mate academy мы учим, что тестирование является важной частью разработки программного обеспечения, поскольку оно помогает обеспечить качество и надежность кода.
Использование тестовых фреймворков, таких как JUnit, позволяет разработчикам легко создавать и запускать тесты для кода написанного на языке программирования Java. В этой статье мы рассмотрим, как создавать и запускать тесты с помощью JUnit, рассмотрим некоторые практические примеры и дадим советы относительно написания эффективных тестов.
Что такое JUnit
JUnit — это открытый фреймворк для написания и запуска тестов на языке программирования Java. Он разработан с целью поддержки автоматизированных тестов, особенно модульных тестов (unit tests), и обеспечивает удобные аннотации, утверждения и утилиты, которые позволяют легко писать и запускать тесты для Java-кода.
Настройка тестовой среды JUnit
Для начала вам необходимо установить JUnit в ваш проект. Если вы используете Maven или Gradle, добавьте зависимость JUnit в ваш файл настроек. Ниже приведен пример для Maven:
Основы и примеры написания тестов с JUnit
Структура теста
Тестовый класс создается отдельно от основного кода. Он содержит один или несколько тестовых методов, каждый из которых проверяет отдельный аспект работы кода. Тестовые методы помечаются аннотацией @Test.
import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest < @Test public void testAddition() < Calculator calculator = new Calculator(); int result = calculator.add(2, 3); assertEquals(5, result, "2 + 3 should equal 5"); >>
Использование утверждений
Утверждения в JUnit позволяют проверять, соответствует ли результат работы вашего кода ожидаемому. Если утверждение не проходит, тест считается неудачным. Для утверждений используйте класс org.junit.jupiter.api.Assertions .
@Test public void testSubtraction()
Тестирование исключений
JUnit позволяет проверять, возникают ли соответствующие исключения при исполнении кода. Используйте метод assertThrows() для этого.
@Test public void testDivisionByZero() < Calculator calculator = new Calculator(); assertThrows(ArithmeticException.class, () ->calculator.divide(10, 0), "Division by zero should throw ArithmeticException"); >
Использование параметризированных тестов
Параметризованные тесты позволяют запускать один тестовый метод с разными наборами данных. Они полезны для проверки многих случаев, использующих одну и ту же логику. Для этого используйте аннотации @ParameterizedTest и @ValueSource , @CsvSource или @MethodSource .
import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; public class PrimeNumberTest < private PrimeNumberChecker checker = new PrimeNumberChecker(); @ParameterizedTest @ValueSource(ints = ) public void testPrimeNumbers(int number) < assertTrue(checker.isPrime(number), number + " should be a prime number"); >>
Использование тестовых жизненных циклов
JUnit позволяет использовать методы, которые вызываются перед и после каждого теста или всего тестового класса. Они полезны для инициализации и очистки ресурсов. Для этого используйте аннотации @BeforeEach , @AfterEach , @BeforeAll и @AfterAll .
import org.junit.jupiter.api.*; public class DatabaseTest < private DatabaseConnection connection; @BeforeAll public static void setupClass() < // Выполнить действия перед всеми тестами в классе >@BeforeEach public void setup() < connection = new DatabaseConnection(); connection.connect(); // Выполнить действия перед каждым тестом >@Test public void testDatabaseQuery() < // Тестирование запроса к базе данных >@AfterEach public void tearDown() < connection.disconnect(); // Выполнить действия после каждого теста >@AfterAll public static void tearDownClass() < // Выполнить действия после всех тестов в классе >>
Использование отложенных тестов
Вложенные тесты позволяют группировать тесты во вложенных классах. Это полезно для структурирования тестов и предотвращения дублирования кода.
import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; public class ShoppingCartTest < @Nested class AddingItems < @Test public void testAddSingleItem() < // Тестирование добавления одного товара >@Test public void testAddMultipleItems() < // Тестирование добавления нескольких товаров >> @Nested class RemovingItems < @Test public void testRemoveItem() < // Тестирование удаления товара >@Test public void testRemoveNonExistingItem() < // Тестирование удаления несуществующего товара >> >
Настройка и отладка тестов
JUnit позволяет настраивать и настраивать тесты с помощью аннотаций @Timeout , @Disabled и @DisplayName .
@Test @Timeout(5) // Установить временной лимит выполнения теста @DisplayName("Кастомное текстовое описание теста") public void testLongRunningOperation() < // Тестирование длительной операции >@Test @Disabled("Причина отключения теста") public void testDisabled() < // Тест, который временно отключен >
Заключение
Тестирование Java-кода с помощью JUnit – важный и полезный процесс, который помогает обеспечить качество и стабильность вашего программного обеспечения. Используя тестовые методы, утверждения, параметризованные тесты, жизненные циклы, вложенные тесты и настройки, вы можете создавать тщательно протестированные и надежные программы на языке Java.
Приведенные примеры и советы помогут вам быстро начать работу с JUnit и повысить эффективность вашего процесса разработки. Помните, что регулярное тестирование и написание модульных тестов являются важными составляющими успешного разработчика программного обеспечения.
Как правильно писать unit тесты java
Для написания тестов на Java с использованием фреймворка JUnit и автоматической сборки с помощью Gradle , необходимо выполнить несколько шагов:
- Создать проект Gradle в IDE (например, в IntelliJ IDEA ).
- Добавить зависимость JUnit в файл build.gradle :
- Создать тестовый класс, который будет содержать методы с аннотацией @Test :
import org.junit.Test; import static org.junit.Assert.*; public class MyTest @Test public void testSum() assertEquals(4, 2 + 2); > @Test public void testMax() int[] numbers = 1, 2, 3, 4, 5>; int max = numbers[0]; for (int i = 1; i numbers.length; i++) if (numbers[i] > max) max = numbers[i]; > > assertEquals(5, max); > > - Запустить тесты с помощью команды gradle test в терминале или из IDE.
После выполнения этих шагов, Gradle автоматически соберет и запустит все тесты, которые находятся в пакете src/test/java . Результаты тестирования будут отображены в консоли или в специальной вкладке в IDE, и вы сможете увидеть, прошли ли все тесты успешно или есть ошибки.
08 апреля 2023
Для написания теста на Java необходимо использовать какой-либо фреймворк для тестирования, например, JUnit . Рассмотрим пример написания теста на JUnit.
- Подключите зависимость JUnit в свой проект. Если вы используете Maven , добавьте следующий код в pom.xml :
junit junit 4.13.2 test - Создайте класс для тестирования. Например, если вы хотите протестировать класс Calculator , создайте класс CalculatorTest :
import org.junit.Test; import static org.junit.Assert.*; public class CalculatorTest @Test public void testAddition() Calculator calculator = new Calculator(); int result = calculator.add(2, 3); assertEquals(5, result); > @Test public void testSubtraction() Calculator calculator = new Calculator(); int result = calculator.subtract(5, 3); assertEquals(2, result); > > - Создайте методы тестирования. Каждый метод должен быть аннотирован аннотацией @Test . Внутри метода вызывайте методы, которые вы хотите протестировать, и сравнивайте ожидаемый результат с фактическим. В этом примере мы тестируем методы add и subtract класса Calculator
- Запустите тесты. В большинстве сред разработки можно запустить тесты, нажав на кнопку «запустить тесты». Вы также можете запустить тесты из командной строки с помощью команды mvn test (если вы используете Maven ) или java -cp org.junit.runner.JUnitCore
Это только основы, но они помогут вам начать написание юнит-тестов в Java
Изучаем J-Юнит в Джаве: тестирование и возможные его аннотации
В программировании для написания всевозможных программ и игр разработчик может использовать разнообразные функции и инструменты. Java является одним из самых простых и эффективных языков программирования, пользующихся спросом в 21 веке. У него есть средства, которые значительно упрощают процесс работы с создаваемыми утилитами. Одна из них носит название JUnit. Ей будет уделено основное внимание в данной статье.
Java – почему стоит использовать этот язык
Но перед тем, как изучать соответствующий элемент, программист должен определиться – действительно ли нужно работать с Джавой. Может, другой язык программирования подойдет в большей степени для решения той или иной задачи.
Java не просто так пользуется спросом у разработчиков. Данный язык обладает немалым количеством сильных сторон. К ним относят:
- функциональность;
- наличие библиотек и фреймворков;
- наличие собственной виртуальной машины, необходимой для успешной работы программного кода – контент способен работать «обособлено», без дополнительных расширений и драйверов;
- скорость работы;
- простой для понимания синтаксис, особенно если знать английский язык;
- поддержку ООП;
- возможность тестировать софт без существенных хлопот и лишних вмешательств со стороны.
Также Джава обладает высоким уровнем безопасности и наделен кроссплатформенностью. Переносить контент с одной операционной системы на другую удается без дополнительных корректировок.
Java активно применяется при создании:
- сложных серьезных проектов;
- веб-контента (но здесь чаще применяют JavaScript);
- игр;
- консольных утилит.
Универсальный вариант как для начинающих разработчиков, так и для тех, кто долгое время занимается программированием. Но после того, как программный код составлен, нужно провести его тест. Может быть, в процессе реализации соответствующей операции будут обнаружены какие-нибудь ошибки. Их придется исправлять, иначе софт не сможет нормально функционировать. Только не всегда ручной подход оказывается эффективным.
Фреймворк – это…
Фреймворк – слово, произошедшее от английского «framework» — остров, рама, структура. В программировании имеет несколько иное определение. Это программная платформа, отвечающая за определение структуры программной системы. Облегчает разработку, а также объединение компонентов имеющегося составленного кода.
Фреймворки – блоки заранее написанного программного кода, которые могут быть добавлены программистом для того, чтобы решать разнообразные задачи и проблемы. Включают в себя:
- дополнительные утилиты;
- библиотечные кодификации;
- сценарии;
иное программное обеспечение, которое помогает объединять разнообразные компоненты проекта немалых масштабов.
В основном фреймворки работают при помощи API. С их помощью удается проводить тест имеющейся кодификации. Особенно если речь идет о Java. Здесь данный вопрос решается несколькими способами – не только вручную, но и автоматически.
JUnit – определение
JUnit – специальная библиотека, необходимая для проведения модульного тестирования в Java. Портирована на разнообразные языки программирования. Активно используется разработчиками на практике.
Представляет собой фреймворк, который отвечает за реализацию отдельных «самостоятельных» элементов имеющейся кодификации. Помогает разработчикам при продумывании концепций собственных схем теста программного обеспечения.
JUnit представлена средой тестирования, обладающей открытым исходным кодом. Применяется для:
- написания автоматического теста;
- запуска соответствующей проверки.
Применяется и в качестве отдельной Джава-программы, и в IDE среде. Пример – Eclipse.
Ключевые особенности
Для того, чтобы проверить работоспособность программного кода, нужно провести тест. Вручную это делать не всегда удобно. Поэтому на помощь приходит JUnit. Он отвечает за обеспечение:
- утверждения результатов, получаемых в ходе «анализа»;
- тестовых функций, применяемых при обмене общими полученными показателями;
- наборов тестов, способных облегчить организацию и запуск проверки;
- графические и текстовые тесты бегунов.
Применяется на практике для того, чтобы осуществить проверку всего объекта, а также его части (методов или нескольких их групп, взаимодействующих между собой). Дополнительно JUnit проверяет слаженность и правильность работы нескольких объектов программного кода между собой.
Важно: с использованием JUnit можно значительно упростить проверку работоспособности имеющейся утилиты. Данный «инструмент» довольно легко использовать на практике.
Свойства JUnit
JUnit в Java имеет следующие свойства:
- открытый исходный код;
- ускорение написания итоговой кодификации (даже самой сложной);
- поддержка аннотаций для того, чтобы можно было идентифицировать методы;
- поддержка утверждений для тестов;
- возможность организации тестов в их связке;
- визуальная удобная индикация.
Пример последнего свойства можно увидеть, когда осуществляется непосредственный тест. Красным цветом выделяются текущие ошибки. Зеленым – те, что уже исправлены. Это очень удобно не только новичкам, но и продвинутым программерам.
Тестирование – каким бывает и при чем тут JUnit
Если хотите получить программу, которая работает исправно и без ошибок, важно проводить перед началом активной работы с ней так называемый тест. Он бывает нескольких видов:
- тест черного ящика;
- тест белого ящика.
В первом случае предстоит работать с учетом того, что внутренняя структура утилиты не принимается в расчет. Ключевой упор делается на функциональность, которую должен обеспечивать соответствующий контент. Если же говорить о тесте белого ящика, во внимание принимаются методы и классы внутреннего характера.
Также тесты условно разделяют на несколько уровней:
- юнит – отдельные участки имеющегося кода;
- интеграционный – проверка взаимодействия и совместной работы компонентов контента;
- системный – тест всей системы в качестве единого целого;
- прием – конечная проверка на соответствие заданным изначально требованиям.
Первый вариант – это всегда тестирование белого ящика. Других вариантов развития событий нет. JUnit здесь играет немаловажную роль. За счет него обеспечивается целостная проверка создаваемого контента.
Элементарный пример
Ниже представлен пример теста, проведенного в JUnit:
import org.junit.Test; import junit.framework.Assert; public class MathTest < @Test public void testEquals() < Assert.assertEquals(4, 2 + 2); Assert.assertTrue(4 == 2 + 2); >@Test public void testNotEquals() < Assert.assertFalse(5 == 2 + 2); >>Далее тест будет рассматриваться на примере версия JUnit 3 и JUnit4.
Версия JUnit 3
При определенных обстоятельствах требуется проводить итоговое тестирование через JUnit 3. Реализация предусматривает следующие нюансы:
- Нужно провести наследование тест-класса, который называется TestCase.
- Осуществить предопределение методов setup и tearDown, если это необходимо.
- Разработать тестовые методы, которые начинаются со слова «test».
Именно такие задачи будут рассматриваться в приведенном примере. После запуска тестов:
- создается экземпляр тест-класса;
- обрабатывается и выполняется setUp;
- проводится запуск теста;
- под конец реализовывается tearDown.
Когда тестовый метод влечет за собой исключение, вся проверка проваливается. Разработчик сможет увидеть ошибки, чтобы далее исправить их.
Тесты jUnit в Java включают в себя выполнение определенного кода, а также непосредственные проверки. Последние выполняются при помощи класса Assert. Иногда для их применения задействовано соответствующее ключевое слово.
Наглядный пример
Для того, чтобы лучше разбираться в выбранной теме, создадим утилиту, которая нужна для работы со строками. Она включает в себя:
- методы проверки строчки на пустоту;
- представления последовательности байт в шестнадцатеричном строчке.
Вот пример кода:
public class JUnit3StringUtilsTest extends TestCase < private final Map toHexStringData = new HashMap(); protected void setUp() throws Exception < toHexStringData.put("", new byte[0]); toHexStringData.put("01020d112d7f", new byte[]); toHexStringData.put("00fff21180" , new byte[]); //. > protected void tearDown() throws Exception < toHexStringData.clear(); >public void testToHexString() < for (Iterator iterator = toHexStringData.keySet().iterator(); iterator.hasNext();) < final String expected = (String)iterator.next(); final byte[] testData = (byte[])toHexStringData.get(expected); final String actual = StringUtils.toHexString(testData); assertEquals(expected, actual); >> //. >
Дополнительные возможности
После выполнения теста можно смотреть на результат. Но сначала важно учесть то, что JUnit 3 имеет дополнительные возможности:
- Тесты могут быть сгруппированы. Для этого применяется отдельный класс под названием TestSuite.
2. Выполнение проверки разрешено повторять по несколько раз. Чтобы справиться с задачей, предстоит использовать RepetedTest.
3. Присутствует возможность проверки кода. Если ожидаете вывод результата относительно выброса исключения, нужно задать наследование тест-класса от ExceptionTestCase.
Приведенные примеры наглядно показывают – для проведения проверки в Джаве требуется минимум программного кода.
Продолжение статьи смотрите здесь.
Тестирование JUnit. Примеры
В системах программирования на языке Java, в том числе Java Eclipse, введены средства тестирования, которые предусматривают создание и использование автоматических тестов для разработанных программ. Правильно построенное тестирование позволяет свести количество ошибок в программе к нулю.
При разработке современных программных систем популярна методология TDD (Test Driven Development). Основная идея применения TDD заключается в том, что сначала разрабатываются тесты на желаемое поведение программы (системы), а затем пишется рабочий программный код, который с помощью средств рефакторинга проверяется уже созданными тестами. Как следствие, заранее подготовленные тесты позволяют избежать сдачи в эксплуатацию программы, содержащей ошибки.
Для проведения тестирования в Java Eclipse применяется так называемое JUnit-тестирование, которое является фактическим стандартом для тестирования Java-приложений. JUnit — это обычная среда (framework), позволяющая писать тесты в виде классов Java. Эти классы могут запускаться как единое целое с помощью средства выполнения тестов.
JUnit имеет много расширений, которые внедрены во всех современных средах разработки на языке Java. На сегодняшний день JUnit используется в таких направлениях как:
- модульное тестирование;
- тестирование веб-сайтов;
- автоматическая подстановка интерфейсов для тестирования;
- тестирование параллельного выполнения приложений;
- тестирование производительности.
JUnit-тестирование используется многими группами тестировщиков (quality assurance) на специально-разработанных веб-сайтах, обеспечивающих автоматизацию применения сквозных функциональных тестов.
В Java Eclipse использование механизма JUnit не требует работающего сервера приложений или действующей базы данных.
2. Понятие тестового примера ( Test Case ). Класс, содержащий тестовые примеры (методы). Запуск теста
При использовании механизма JUnit, рассматриваются две основные единицы (классы):
- класс, методы которого нужно протестировать;
- класс, который представляет собой JUnit тест. Этот класс построен по специальным правилам.
Значит, JUnit-тест представляет собой специально разработанный класс, содержащий методы, которые тестируют программный код других классов. В системе Java Eclipse этот класс создается с помощью команды JUnit Test Case (смотрите примеры далее).
Класс содержит ряд методов. Каждый из методов тестирующего класса рассматривается как отдельный тестовый пример — Test Case .
Тестовые примеры (методы) JUnit-класса могут быть объявлены с использованием следующих аннотаций (рассматривается версия Java Eclipse 2018-09):
- @BeforeAll — статический метод (тестовый пример), объявленный с этой инструкцией, вызывается в начале тестирования;
- @AfterAll — статический метод, объявленный с этой инструкцией, вызывается в конце тестирования. Здесь можно задавать, например, освобождение ресурсов используемых при тестировании;
- @Test — метод, который объявлен с этой инструкцией, является тестовым примером. Он содержит непосредственно код тестирования. Этот метод использует методы класса org.junit.jupiter.api.Assertions . В этом методе используются методы сравнения, которые начинаются с префикса assert*() . Например, для сравнения двух значений любого примитивного типа используется перегруженный метод assertEquals() . В одном тестовой классе JUnit может быть произвольное количество методов (примеров) тестирования, которые объявлены с аннотацией @Test ;
- @BeforeEach — вызывается перед вызовом каждого тестового примера (метода), который объявлен с аннотацией @Test ;
- @AfterEach — вызывается после завершения каждого тестового примера (метода), который объявлен с аннотацией @Test .
Допускается произвольное количество методов со всеми вышеприведенными аннотациями.
В наиболее общем случае, примерный вид класса, сгенерированный системой Java Eclipse, может быть таким
class TestClass < @BeforeAll static void setUpBeforeClass() throws Exception < >@AfterAll static void tearDownAfterClass() throws Exception < >@BeforeEach void setUp() throws Exception < >@AfterEach void tearDown() throws Exception < >@Test void testMethod() < fail("Not yet implemented"); > >
В методе testMethod() нужно вставить собственный код работы методов другого класса (смотрите примеры ниже). После этого, можно запускать тест с помощью специальной команды Java Eclipse.
3. Пример, демонстрирующий использование JUnit для проверки правильности решения квадратного уравнения. Пошаговая инструкция
3.1. Условие задачи
Используя технологию JUnit разработать Unit-тест для проверки работы класса SquareEquation , который содержит средства решения квадратного уравнения.
Тест должен размещаться в классе SquareEquationTest и содержать соответствующие методы проверки правильности полученного решения.
Корни квадратного уравнения возвращаются в виде экземпляра класса Roots .
Класс SquareEquationTest содержит соответствующие средства решения квадратного уравнения.
3.2. Решение
3.2.1. Создание классов SquareEquation и Roots
Перед созданием классов создается проект стандартным для Java Eclipse способом. В проект добавляются два класса с именами SquareEquation и Roots и формируется код этих классов. Соответственно создается файл SquareEquation.java . После выполненных действий, окно Java Eclipse имеет вид как показано на рисунке 1.
Рисунок 1. Окно Java Eclipse. Классы Roots и SquareEquation
Классы имеют следующее назначение:
- Roots — используется для сохранения корней квадратного уравнения (x1, x2) в случае, если уравнение имеет эти корни;
- SquareEquation — реализует методы решения квадратного уравнения.
- Класс SquareEquation имеет следующие составляющие:
- внутренние переменные a , b , c что являются коэффициентами квадратного уравнения;
- конструктор, инициализирует значения внутренних полей a , b , c ;
- метод Solution() , который возвращает экземпляр класса Roots в случае, если уравнение имеет корни. Если уравнение не имеет корней, то генерируется исключение типа ArithmeticException .
Полный текст классов Roots и SquareEquation выглядит так
// Корни уравнения class Roots < public double x1; public double x2; > // Класс, решающий квадратное уравнение - этот класс будет протестирован другим классом. // a*x^2 + b*x + c = 0 public class SquareEquation < // Коэффициенты уравнения private double a, b, c; // Конструктор public SquareEquation(double a, double b, double c) < this.a = a; this.b = b; this.c = c; > // Метод, решающий квадратное уравнение public Roots Solution() < // Дискриминант double d = b*b - 4*a*c; // Проверка, имеет ли уравнение корни if (d<0) throw new ArithmeticException("Solution has no roots."); // Вычислить результат Roots result = new Roots(); result.x1 = (-b - Math.sqrt(d)) / (2*a); result.x2 = (-b + Math.sqrt(d)) / (2*a); // Вернуть результат return result; > >
После создания классов можно переходить к созданию Unit-теста.
3.2.2. Создание класса, необходимого для реализации JUnit тестирования
Для создания Unit-теста в Java Eclipse нужно выбрать последовательность команд
File->New->JUnit Test Case
как показано на рисунке 2.
Рисунок 2. Команда создания Unit-теста в Java
В результате откроется окно «New JUnit Test Case» (рисунок 3) в котором нужно указать необходимую информацию о тесте.
Рисунок 3. Окно создания нового теста. Указание параметров теста
При создании окна система автоматически заполнит некоторые поля. В окне указывается следующая информация.
- В поле Source Folder указывается имя папки с исходными файлами проекта. Система автоматически «подтягивает» имя папки с текущим проектом.
- В поле Name — задается имя класса, в котором будут размещаться методы тестирования (с аннотациями @BeforeAll , @Test т.д.). В нашем случае предлагается SquareEquationTest (к имени класса SquareEquation добавляется окончание Test ). Предложенное имя можно оставить без изменений.
- В поле «Which method stubs would you like to create?» с помощью опций указываются методы, которые нужно сформировать в классе. Согласно выбранной опции формируются следующие методы:
- setUpBeforeClass() — имя метода аннотации @BeforeAll (см п.2);
- setUp() — имя метода аннотации @BeforeEach ;
- tearDownAfterClass() — имя метода аннотации @AfterAll ;
- tearDown() — имя метода аннотации @AfterEach .
Для нашего теста достаточно активировать только одно поле setUp() . Это позволит добавить метод аннотации @BeforeEach , что будет вызываться перед тестом. В этом методе будет создаваться экземпляр класса SquareEquation (смотрите коды ниже).
- В поле «Class under test:» указывается имя класса SquareEquation , методы которого нужно протестировать.
- Дополнительно задаются другие опции:
- выбор модели тестирования «New JUnit Jupiter test» ;
- возможность добавления комментариев;
- другое.
В нашем случае можно оставить все без изменений.
После выбора кнопки «Next >» откроется следующее окно «New JUnit Test Case» в котором нужно задать перечень методов, которые будут тестироваться. Вид окна показан на рисунке 4. Избранные методы будут объявляться с аннотацией @Test . Это непосредственно тестовые примеры. Все остальные опции в окне можно оставить по умолчанию и перейти далее с помощью кнопки Finish .
Рисунок 4. Выбор методов которые будут тестироваться. Выбран метод Solution()
3.2.3. Код класса SquareEquationTest
После создания JUnit теста с помощью оконного интерфейса Java Eclipse сгенерирует код класса SquareEquationTest
import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; class SquareEquationTest < @BeforeEach void setUp() throws Exception < >@Test void testSolution() < fail("Not yet implemented"); > >
В этом коде сформированы два метода:
- метод setUp() с аннотацией @BeforeEach . Этот метод будет вызываться первым при тестировании;
- метод testSolution() с аннотацией @Test . В этом методе будет помещен непосредственно тест функции Solution() класса SquareEquation .
3.2.4. Модификация класса SquareEquationTest . Программирование теста
Чтобы протестировать работу класса SquareEquation нужно создать экземпляр этого класса. Поэтому, в текст класса SquareEquationTest дополнительно вводится ссылка на класс SquareEquation
class SquareEquationTest < private SquareEquation se; . >
Затем в методе setUp() создается экземпляр класса SquareEquation , на который указывает ссылка se
@BeforeEach void setUp() throws Exception < // Этот метод вызывается первым. // Создать экземпляр класса SquareEquation. se = new SquareEquation(2, 1, -3); // 2*x^2 + x - 3 = 0 >
После этого, в методе TestSolution() вписывается код проверки правильности полученного решения для заданных коэффициентов
a = 2 b = 1 c = -3
в экземпляре se
@Test void testSolution() < // Объявить экземпляр класса Roots Roots rt = se.Solution(); // Проверка решения x1 assertEquals(rt.x1, -1.5); // Проверка решения x2 assertEquals(rt.x2, 1.0); >
Проверка решения осуществляется с помощью перегруженного метода assertEquals() класса org.junit.jupiter.api.Assertions . Происходит сравнение решения в переменных rt.x1 и rt.x2 с заранее вычисленным (вручную) решением текущего варианта (a = 2, b = 1, c = -3) квадратного уравнения. Если есть совпадение, то решение правильное. О том, что решение правильное, нужна сказать система после запуска теста (следующий пункт).
В целом текст всего модуля тестирования следующий
import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; class SquareEquationTest < // Ссылка на класс SquareEquation private SquareEquation se; @BeforeEach void setUp() throws Exception < // Этот метод вызывается первым. // Создать экземпляр класса SquareEquation se = new SquareEquation(2, 1, -3); // 2*x^2 + x - 3 = 0 > @Test void testSolution() < // Объявить экземпляр класса Roots Roots rt = se.Solution(); // Проверка решения x1 assertEquals(rt.x1, -1.5); // Проверка решения x2 assertEquals(rt.x2, 1.0); > >
3.3. Запуск теста средствами Java Eclipse. Просмотр результата тестирования
После того, как сформирован код класса SquareEquationTest , разработанный тест можно запускать на выполнение. Это осуществляется командами
Run -> Run As -> JUnit Test
или вызовом последовательности комбинаций клавиш Alt + Shift + X, T как показано на рисунке 5.
Рисунок 5. Запуск JUnit-теста
Существует другой способ с помощью команды быстрого меню (рисунок 6).
Рисунок 6. Команда запуска JUnit-теста
После запуска в левой части Java Eclipse в окне JUnit отобразится результат тестирования (рисунок 7).
Рисунок 7. Результат тестирования
Как видно из результата, получено подтверждение правильного решения, то есть тест сдан. Значит, метод Solution() класса SquareEquation дает правильный результат для случая когда a = 2, b = 1, c = -3.
Если в методе TestSolution() при вызове assertEquals() специально указать неверный ответ, например
assertEquals(rt.x2, 777.777);
то после повторного запуска теста, в окне JUnit отобразится ошибка как видно на рисунке 8. Хотя это не ошибка программы, а умышленная ошибка в тесте.
Рисунок 8. Демонстрация провала теста
4. Пример, демонстрирующий последовательность вызова методов в JUnit-тесте
Пусть в системе Java Eclipse создан класс с именем TestClass для проведения тестирования некоторого другого класса. В данном примере, суть тестируемого класса не имеет значения.
Программный код класса следующий
import static org.junit.jupiter.api.Assertions.*; import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; class TestClass < @BeforeAll static void setUpBeforeClass() throws Exception < System.out.println("BeforeAll"); > @BeforeAll static void setUpBeforeClass2() throws Exception < System.out.println("BeforeAll2"); > @AfterAll static void tearDownAfterClass() throws Exception < System.out.println("AfterAll"); > @BeforeEach void setUp() throws Exception < System.out.println("BeforeEach"); > @BeforeEach void setUp2() throws Exception < System.out.println("BeforeEach2"); > @AfterEach void tearDown() throws Exception < System.out.println("AfterEach"); > @Test void testSolution() < System.out.println("Test"); > @Test void testSolution2() < System.out.println("Test2"); > >
После запуска теста на выполнение, программа выдаст следующий результат
BeforeAll BeforeAll2 BeforeEach2 BeforeEach Test AfterEach BeforeEach2 BeforeEach Test2 AfterEach AfterAll
Проанализировав этот результат, можно прийти к выводу, что методы в тестовом классе вызываются в порядке, определяемом их аннотациями. Первыми вызываются методы аннотации @BeforeAll .
Следующими рассматриваются тестовые примеры, объявленные с аннотацией @Test . Перед каждым тестовым примером вызываются все методы с аннотацией @BeforeEach . После каждого тестового примера вызываются все методы с аннотацией @AfterEach .
Последними вызываются все методы с аннотацией @AfterAll .