Разное

Тесты java junit: Тестирование в Java. JUnit / Хабр

Содержание

Тестирование с помощью JUnit 5 на Kotlin / Хабр

В этой статье будут рассмотрены основные возможности платформы JUnit 5 и приведены примеры их использования на Kotlin. Материал ориентирован на новичков в Kotlin и/или JUnit, однако, и более опытные разработчики найдут интересные вещи.

Официальный user guide
Исходный код тестов из этой статьи: GitHub

Перед созданием первого теста укажем в pom.xml зависимость:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.0.2</version>
    <scope>test</scope>
</dependency>

Создадим первый тест:

import org.junit.jupiter.api.Test

class HelloJunit5Test {

    @Test
    fun `First test`() {
        print("Hello, JUnit5!")
    }
}

Тест проходит успешно:

Перейдём к обзору основных фич JUnit 5 и различных технических нюансов.

Отображаемое название теста

В значении аннотации @DisplayName, как и в названии функции Kotlin, помимо удобочитаемого отображаемого названия теста можно указать спецсимволы и emoji:

import org. junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test

class HelloJunit5Test {

    @DisplayName("\uD83D\uDC4D")
    @Test
    fun `First test ╯°□°)╯`() {
        print("Hello, JUnit5!")
    }
}

Как видно, значение аннотации имеет приоритет перед названием функции:

Аннотация применима и к классу:

@DisplayName("Override class name")
class HelloJunit5Test {

Assertions

Assertion’ы находятся в классе org.junit.jupiter.Assertions и являются статическими методами.

Базовые assertion’ы

JUnit включает несколько вариантов проверки ожидаемого и реального значений. В одном из них последним аргументом является сообщение, выводимое в случае ошибки, а в другом — лямбда-выражение, реализующее функциональный интерфейс Supplier, что позволяет вычислять значение строки только в случае неудачного прохождения теста:

import org.junit.jupiter.api.Assertions.assertEquals
import org. junit.jupiter.api.Test

class HelloJunit5Test {

    @Test
    fun `Base assertions`() {
        assertEquals("a", "a")
        assertEquals(2, 1 + 1, "Optional message")
        assertEquals(2, 1 + 1, { "Assertion message " + "can be lazily evaluated" })
    }
}

Групповые assertion’ы

Для тестирования групповых assertion’ов предварительно создадим класс Person с двумя свойствами:

class Person(val firstName: String, val lastName: String)

Будут выполнены оба assertion’а:

import org.junit.jupiter.api.Assertions.assertAll
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.function.Executable

class HelloJunit5Test {

    @Test
    fun `Grouped assertions`() {
        val person = Person("John", "Doe")
        assertAll("person",
                Executable { assertEquals("John", person.firstName) },
                Executable { assertEquals("Doe", person. lastName) }
        )
    }
}

Передача лямбд и ссылок на методы в проверках на true/false

    @Test
    fun `Test assertTrue with reference and lambda`() {
        val list = listOf("")
        assertTrue(list::isNotEmpty)
        assertTrue {
            !list.contains("a")
        }
    }

Exceptions

Более прозрачная по сравнению с JUnit 4 работа с исключениями:

    @Test
    fun `Test exception`() {
        val exception: Exception = assertThrows(IllegalArgumentException::class.java, {
            throw IllegalArgumentException("exception message")
        })
        assertEquals("exception message", exception.message)
    }

Проверка времени выполнения тестов

Как и в остальных примерах, всё делается просто:

    @Test
    fun `Timeout not exceeded`() {
        // Тест упадёт после выполнения лямбда-выражения, если оно превысит 1000 мс
        assertTimeout(ofMillis(1000)) {
            print("Выполняется операция, которая займёт не больше 1 секунды")
            Thread. sleep(3)
        }
    }

При этом лямбда-выражение выполняется полностью, даже когда время выполнения уже превысило допустимое. Для того, чтобы тест падал сразу после истечения отведённого времени, нужно использовать метод assertTimeoutPreemptively:

    @Test
    fun `Timeout not exceeded with preemptively exit`() {
        // Тест упадёт, как только время выполнения превысит 1000 мс
        assertTimeoutPreemptively(ofMillis(1000)) {
            print("Выполняется операция, которая займёт не больше 1 секунды")
            Thread.sleep(3)
        }
    }

Внешние assertion-библиотеки

Некоторые библиотеки предоставляют более мощные и выразительные средства использования assertion’ов, чем JUnit. В частности, Hamcrest, помимо прочих, предоставляет множество возможностей для проверки массивов и коллекций. Несколько примеров:

import org.hamcrest.MatcherAssert.assertThat
import org.hamcrest.Matchers.containsInAnyOrder
import org. hamcrest.Matchers.greaterThanOrEqualTo
import org.hamcrest.Matchers.hasItem
import org.hamcrest.Matchers.notNullValue
import org.junit.jupiter.api.Test

class HamcrestExample {

    @Test
    fun `Some examples`() {
        val list = listOf("s1", "s2", "s3")
        assertThat(list, containsInAnyOrder("s3", "s1", "s2"))
        assertThat(list, hasItem("s1"))
        assertThat(list.size, greaterThanOrEqualTo(3))
        assertThat(list[0], notNullValue())
    }
}

Assumptions

Assumption’ы предоставляют возможность выполнения тестов только в случае выполнения определённых условий:

import org.junit.jupiter.api.Assumptions.assumeTrue
import org.junit.jupiter.api.Test

class AssumptionTest {

    @Test
    fun `Test Java 8 installed`() {
        assumeTrue(System.getProperty("java.version").startsWith("1.8"))
        print("Not too old version")
    }

    @Test
    fun `Test Java 7 installed`() {
        assumeTrue(System.getProperty("java.version"). startsWith("1.7")) {
            "Assumption doesn't hold"
        }
        print("Need to update")
    }
}

При этом тест с невыполнившимся assumption’ом не падает, а прерывается:

Data driven тестирование

Одной из главных фич JUnit 5 является поддержка data driven тестирования.

Test factory

Перед генерацией тестов для большей наглядности сделаем класс Person data-классом, что, помимо прочего, переопределит метод toString(), и добавим свойства birthDate и age:

import java.time.LocalDate
import java.time.Period

data class Person(val firstName: String, val lastName: String, val birthDate: LocalDate?) {

    val age
        get() = Period.between(this.birthDate, LocalDate.now()).years
}

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

import org.junit.jupiter.api.Assertions.assertTrue
import org. junit.jupiter.api.DynamicTest
import org.junit.jupiter.api.DynamicTest.dynamicTest
import org.junit.jupiter.api.TestFactory
import java.time.LocalDate

class TestFactoryExample {

    @TestFactory
    fun `Run multiple tests`(): Collection<DynamicTest> {
        val persons = listOf(
                Person("John", "Doe", LocalDate.of(1969, 5, 20)),
                Person("Jane", "Smith", LocalDate.of(1997, 11, 21)),
                Person("Ivan", "Ivanov", LocalDate.of(1994, 2, 12))
        )

        val minAgeFilter = 18
        return persons.map {
            dynamicTest("Check person $it on age greater or equals $minAgeFilter") {
                assertTrue(it.age >= minAgeFilter)
            }
        }.toList()
    }
}

Помимо коллекций DynamicTest, в методе, аннотированном @TestFactory, можно возвращать Stream, Iterable, Iterator.

Жизненный цикл выполнения динамических тестов отличается от @Test методов тем, что метод, аннотированный @BeforeEach выполнится только для @TestFactory метода, а не для каждого динамического теста. Например, при выполнении следующего кода функция Reset some var будет вызвана только один раз, в чём можно убедиться, используя переменную someVar:

    private var someVar: Int? = null

    @BeforeEach
    fun `Reset some var`() {
        someVar = 0
    }

    @TestFactory
    fun `Test factory`(): Collection<DynamicTest> {
        val ints = 0..5
        return ints.map {
            dynamicTest("Test №$it incrementing some var") {
                someVar = someVar?.inc()
                print(someVar)
            }
        }.toList()
    }

Параметризованные тесты

Параметризованные тесты, как и динамические, позволяют создавать набор тестов на основе одного метода, но делают это отличным от @TestFactory образом. Для иллюстрации работы этого способа предварительно добавим в pom.xml зависимость:

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-params</artifactId>
            <version>5. 0.2</version>
            <scope>test</scope>
        </dependency>

Код теста, проверяющего, что поступающие на вход даты уже в прошлом:

class ParameterizedTestExample {

    @ParameterizedTest
    @ValueSource(strings = ["2002-01-23", "1956-03-14", "1503-07-19"])
    fun `Check date in past`(date: LocalDate) {
        assertTrue(date.isBefore(LocalDate.now()))
    }
}

Значениями аннотации @ValueSource могут быть массивы int, long, double и String. В случае массива строк, как видно из примера выше, будет использовано неявное преобразование к типу входного параметра, если оно возможно. @ValueSource позволяет передавать только один входной параметр для каждого вызова теста.

@EnumSource позволяет тестовому методу принимать константы перечислений:

    @ParameterizedTest
    @EnumSource(TimeUnit::class)
    fun `Test enum`(timeUnit: TimeUnit) {
        assertNotNull(timeUnit)
    }

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

    @ParameterizedTest
    @EnumSource(TimeUnit::class, mode = EnumSource. Mode.EXCLUDE, names = ["SECONDS", "MINUTES"])
    fun `Test enum without days and milliseconds`(timeUnit: TimeUnit) {
        print(timeUnit)
    }

Есть возможность указать метод, который будет использован как источник данных:

    @ParameterizedTest
    @MethodSource("intProvider")
    fun `Test with custom arguments provider`(argument: Int) {
        assertNotNull(argument)
    }

    companion object {
        @JvmStatic
        fun intProvider(): Stream<Int> = Stream.of(0, 42, 9000)
    }

В java-коде этот метод должен быть статическим, в Kotlin это достигается его объявлянием в объекте-компаньоне и аннотированием @JvmStatic. Чтобы использовать не статический метод, нужно изменить жизненный цикл экземпляра теста, точнее, создавать один инстанс теста на класс, вместо одного инстанса на метод, как делается по умолчанию:

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class ParameterizedTestExample {

    @ParameterizedTest
    @MethodSource("intProvider")
    fun `Test with custom arguments provider`(argument: Int) {
        assertNotNull(argument)
    }

    fun intProvider(): Stream<Int> = Stream. of(0, 42, 9000)
}

Повторяемые тесты

Число повторений теста указывается следующим образом:

    @RepeatedTest(10)
    fun `Повторяемый тест`() {

    }

Есть возможность настроить выводимое название теста:

    @RepeatedTest(10, name = "{displayName} {currentRepetition} из {totalRepetitions}")
    fun `Повторяемый тест`() {

    }

Доступ к информации о текущем тесте и о группе повторяемых тестов можно получить через соответствующие объекты:

    @RepeatedTest(5)
    fun `Repeated test with repetition info and test info`(repetitionInfo: RepetitionInfo, testInfo: TestInfo) {
        assertEquals(5, repetitionInfo.totalRepetitions)
        val testDisplayNameRegex = """repetition \d of 5""".toRegex()
        assertTrue(testInfo.displayName.matches(testDisplayNameRegex))
    }

Вложенные тесты

JUnit 5 позволяет писать вложенные тесты для большей наглядности и выделения взаимосвязей между ними. Создадим пример, используя класс Person и собственный провайдер аргументов для тестов, возвращающий стрим объектов Person:

class NestedTestExample {

    @Nested
    inner class `Check age of person` {

        @ParameterizedTest
        @ArgumentsSource(PersonProvider::class)
        fun `Check age greater or equals 18`(person: Person) {
            assertTrue(person.age >= 18)
        }

        @ParameterizedTest
        @ArgumentsSource(PersonProvider::class)
        fun `Check birth date is after 1950`(person: Person) {
            assertTrue(LocalDate.of(1950, 12, 31).isBefore(person.birthDate))
        }
    }

    @Nested
    inner class `Check name of person` {

        @ParameterizedTest
        @ArgumentsSource(PersonProvider::class)
        fun `Check first name length is 4`(person: Person) {
            assertEquals(4, person.firstName.length)
        }
    }

    internal class PersonProvider : ArgumentsProvider {
        override fun provideArguments(context: ExtensionContext): Stream<out Arguments> = Stream. of(
                Person("John", "Doe", LocalDate.of(1969, 5, 20)),
                Person("Jane", "Smith", LocalDate.of(1997, 11, 21)),
                Person("Ivan", "Ivanov", LocalDate.of(1994, 2, 12))
        ).map { Arguments.of(it) }
    }
}

Результат будет довольно наглядным:

Заключение

JUnit 5 довольно прост в использовании и предоставляет множество удобных возможностей для написания тестов. Data driven тестирование с использованием Kotlin обеспечивает удобство в разработке и лаконичность кода.

Спасибо!

Unit тесты Java: пример и краткое руководство Unit тестов Javascript

Каждая выполненная задача в программировании требует тестирования, потому что от ошибок, как известно, никто не застрахован. Зачастую на эту процедуру уходит немало времени, даже в простых задачах у новичков. Вы запускаете приложение, вводите данные для проверки и понимаете, что результат не соответствует ожиданиям. Затем вы начинаете выяснять, на каком же этапе произошла ошибка, все это у вас отнимает драгоценные минуты, которые вы могли бы потратить на разработку нового функционала. А что если ваше приложение большое и в нем много зависящих друг от друга модулей, классов и компонент, и ваша задача — изменить поведение существующего кода, при этом не повредив старое.

В чем смысл Unit-тестов?

Именно для этого придумали unit тесты, которые дают возможность автоматизировать проверку приложения. Но ведь на написание тестов тоже уходит время — возразите вы и будете правы. Дело в том, что с ростом вашего приложения это время будет сокращаться, а без тестов ситуация обратная: чем сложнее становится приложение, тем более трудоемким будет его изменение и процесс отслеживания ошибок. К тому же, не будем забывать, что интеграционное тестирование, которым пользуется большинство «смертных» программистов, требует запуска приложения, а, как известно из основ программирования Java, в Java развертывание и сборка — процесс не самый быстрый. Помнится мне один банковский проект, в котором я тратил на это 15 минут, но не будем о грустном.

Для того, чтобы проникнуться данной концепцией, предлагаю почитать об экстремальном программировании. А пока, давайте рассмотрим, какие инструменты нам предлагает Java для решения этой проблемы. Наиболее популярные — JUnit и TestNg, и речь сегодня пойдет о первом. Он является простым и гибким фреймворком для тестирования.

JUnit аннотации и их описание

Пример Unit теста. Для того, чтобы подключить JUnit, нам необходимо добавить dependency в pom.xml, на момент написания статьи самая свежая версия 4.12:

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

Unit тест для такого класса будет выглядеть так:

Размещаться данный класс должен в папке test, которая специально создана для хранения тестовых классов. Название класса должно соответствовать одной из масок: *Test, Test*, *TestCase для того, чтобы maven surefire plugin смог найти ваш тестовый класс. Методы должны иметь возвращаемый тип void в сигнатуре и аннотацию @Test, которая определяет, что метод является тестовым. Аннотация @Beforeуказываетна то, что метод будет выполняться перед каждым тестируемым методом. Также для проверки результата используется специальный проверяемый метод assertEquals, который в нашем случае может принимать сообщение, которое будет показываться при несоответствии фактического и ожидаемого результата, затем второй параметр – фактический результат и третий ожидаемый результат.

Далее открываем терминал, перейдем в папку с нашим проектом и выполним mvn test:

По выводу лога консоли видно, что тесты прошли успешно. Если же мы изменим знак в методе add c + на *, то тест будет failed и лог будет выглядеть так:

Таким образом, мы сразу видим, какой тест у нас не прошел проверку, и можем начать отладку с нужной точки.

В следующей таблице приведен обзор имеющихся в аннотации JUnit 4.x.

Аннотация Описание
@Test public void method() public void method() public void method() public static void method() public static void method() Аннотация @Test определяет что метод method() является тестовым.
@Before Аннотация @Before указывает на то, что метод будет выполнятся перед каждым тестируемым методом @Test.
@After Аннотация @After указываетна то что метод будет выполнятся после каждого тестируемого метода @Test
@BeforeClass Аннотация @BeforeClass указывает на то, что метод будет выполнятся в начале всех тестов, а точней в момент запуска тестов(перед всеми тестами @Test).
@AfterClass Аннотация @AfterClass указывает на то, что метод будет выполнятся после всех тестов.
@Ignore Аннотация @Ignore говорит, что метод будет проигнорирован в момент проведения тестирования.
@Test (expected = Exception.class) (expected = Exception. class) — указывает на то, что в данном тестовом методе вы преднамеренно ожидается Exception.
@Test (timeout=1000) (timeout=1000) — указывает, что тестируемый метод не должен занимать больше чем 1 секунду.

Проверяемые методы (основные)

Метод Описание
fail(String) Указывает на то что бы тестовый метод завалился при этом выводя текстовое сообщение.
assertTrue([message], boolean condition) Проверяет, что логическое условие истинно.
assertsEquals([String message], expected, actual) Проверяет, что два значения совпадают. Для массивов проверяются ссылки, а не содержание массивов.
assertNull([message], object) Проверяет, что объект является пустым null.
assertNotNull([message], object) Проверяет, что объект не является пустым null.
assertSame([String], expected, actual) Проверяет, что обе переменные относятся к одному объекту.
assertNotSame([String], expected, actual) Проверяет, что обе переменные относятся к разным объектам.

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

https://bitbucket.org/platon_tsy/unittest/overview

Как подключить JUnit в IntelliJ IDEA: пошаговая инструкция с примерами

От автора: установить и настроить IntelliJ IDEA — это только малая часть задачи, которую нужно совершить перед тем, как ваша работа станет полноценной. Поэтому продолжаем рассматривать некоторые важные функции, которые не включены в среду разработки по умолчанию. К примеру, многие начинающие пользователи не знают, как подключить JUnit в IntelliJ IDEA. Эту и другие трудности вы сможете преодолеть, руководствуясь коротким мануалом, который представим в сегодняшней статье.

Тесты — панацея

Конечно, нет. Но отказываться от модульного тестирования глупо. Оно позволяет проверить, насколько правильными являются элементы исходного кода. А вместе с «умной» IntelliJ IDEA этот функционал становится еще более полезным, так как система предлагает нужные исправления. При этом типе тестирования изолируем фрагмент программы и смотрим, насколько хорошо он справляется с возложенными на него задачами. Если что-то пошло не так — исправляем. Благодаря такому подходу программист знает, что «ложь» не из-за всей программы, а вызвана конкретным ее элементом.

Одной из наиболее распространённых библиотек модульного тестирования является JUnit. Она разработана специально для Java, но из-за ее крутизны была портирована на массу других языков: начиная с веб-языка PHP, заканчивая такими динозаврами, как Fortran. Из-за того, что выполнение происходит через Java Virtual Machine, инструмент является полностью кроссплатформенным, а потому популярным.

Подключить к IDEA

Это наша главная задача сегодня. Будем показывать, как происходит взаимодействие этой технологии и одной из самых популярных сред разработки — IntelliJ IDEA. Заодно по пути продемонстрируем подключение еще одной тестовой технологии — TestNG, так как они, как правило, используются в паре.

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Узнать подробнее

Библиотеки для JUnit и TestNG поставляются с IntelliJ IDEA, но по умолчанию не включены в путь к классам вашего проекта или модуля. Следовательно, при создании тестового класса ссылки на класс TestCase или текстовые аннотации не разрешаются.

Чтобы добавить необходимую библиотеку в путь к классам, вы можете использовать общую процедуру добавления зависимости к модулю. Соответствующие библиотеки расположены в следующих каталогах:

JUnit библиотеки ( junit. jar и junit-4.12.jar): <IntelliJ IDEA directory>\lib;

библиотека TestNG (testng-jdk15.jar): <IntelliJ IDEA directory>\plugins\testng\lib.

IntelliJ IDEA может автоматически добавить необходимую библиотеку в путь к классам. Соответствующие функции доступны при создании теста для класса или при написании кода для теста.

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

В редакторе поместите курсор в строку, содержащую объявление класса.

Нажмите Alt+Enter, чтобы просмотреть доступные намеренные действия.

Выберите «Создать тест».

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Узнать подробнее

В диалоговом окне «Создать тест», справа от текста, сообщающего, что соответствующая библиотека не найдена, нажмите «Исправить».

А после добавим библиотеку тестов в classpath при написании кода для теста.

В исходном коде тестового класса поместите курсор в неразрешенную ссылку TestCase или аннотацию.

Нажмите Alt+Enter, чтобы просмотреть доступные намеренные действия.

Выберите «Добавить в путь к классам».

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

Расширение для Android Developers

Теперь перейдем к инструментам для мобильных разработчиков. Дело в том, что IntelliJ IDEA c установленным Android SDK может конкурировать со средами разработки, которые созданы специально для того, чтобы делать приложения для мобильной операционной системы. Потому расскажем о том, как прокачать вашу IDE до профессионального инструмента для Android.

Для начала, необходимо скачать Android SDK с официального сайта, и это важно. Не стоит искать другие источники, когда программное обеспечение распространяется свободно. Кстати, имеется в виду установка на 64-разрядную операционную систему. Если у вас 32-разрядная, то для начала займитесь своим ПК, а после приступайте к работе с IntelliJ IDEA.

Итак, стянули Android SDK c сети, и теперь пора его установить. При скачивании выбираем пункт «…для существующей IDE». Если ранее вы работали с Java продуктами, то следующий шаг покажется знакомым: установщик не видит Java SDK. Для того, чтобы все исправить, переходим в переменные среды и вносим необходимые изменения. Создаем значение переменной «JAVA_HOME», а в значении указываем, где вы установили Java.

Теперь открываем установщик заново и ставим пакеты. Среди нужных:

установить Android SDK Tools;

Platform-tools;

версии ОС, для которых будем создавать приложения;

версия минимальной совместимости.

Далее жмем кнопку установки и просто ждем несколько минут. Соглашаемся со всеми условиями и идем дальше. Затем настраиваем все для вашей IDE: показываем, какую среду будем использовать и где расположена Java SDK. А непосредственно в IDE указываем путь к набору Android. Готово!

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Узнать подробнее

Редактор Sublime Text

Посмотрите видео по работе с редактором Sublime Text

Смотреть

Группировка JUnit тестов с помощью @Category — Блог вебразработчика

Начиная с версии 4. 8 JUnit включает в себя возможность, которая уже давно радовала пользователей TestNG — возможность группировать тесты для выполнения. Группировка тестов в JUnit осуществляется с помощью, так называемых, категорий. Каждая категория должна представлять собой интерфейс или класс. Но так как они используются исключительно для маркировки тестов, то чаще всего категории представляются именно в виде интерфейсов. Например:


public interface UnitTests {}

При создании категорий можно также использовать наследование, это даст дополнительную гибкость при организации тестов:


public interface Category1 {}
public interface Category2 extends Category1 {}

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

Созданными категориями можно маркировать тестовые классы или непосредственно тестовые методы:


@Category(Category1. class)
public class SomeTest {
   
    @Test
    public void testMethod1() {
        ...
    }
    
    @Test
    public void testMethod2() {
        ....
    }
}

или


public class SomeTest {
   
    @Test
    @Category(Category2.class)
    public void testMethod1() {
        ...
    }
    
    @Test
    @Category({Category1.class, Category3.class})
    public void testMethod2() {
        ....
    }
}

Категорию нельзя применить к Suite, это не даст никакого эффекта.

Теперь самое интересное — запуск категорий на выполнение. Сделать это можно как с помощью Suite, так и с помощью Maven.

Suite

Напомню, что в JUnit4 Suite — это по существу пустой аннотированный класс. Чтобы запустить на выполнение тесты в определенной категории, нужно использовать аннотацию @RunWith (Categories.class) и с помощью другой аннотации @IncludeCategory указать какую именно категорию тестов нужно выполнить:


@RunWith(Categories.class)
@IncludeCategory(Unit.class)
@SuiteClasses( { Test1.class, Test2.class })
public class UnitTestSuite {}

Используя аннотацию @ExcludeCategory можно инвертировать запуск и выполнить все тесты кроме категории, указанной в аннотации:


@RunWith(Categories.class)
@ExcludeCategory(Unit.class)
@SuiteClasses( { Test1.class, Test2.class })
public class IntegrationTestSuite {}

Аннотации @IncludeCategory и @ExcludeCategory можно использовать одновременно. Но нельзя объявлять одну и туже аннотацию несколько раз, также как и нельзя указать несколько категорий в одной аннотации. Поэтому запуск тестов из нескольких категорий можно урегулировать только через их наследование. Что опять же указывает на плюс использования интерфейсов, в отличии от классов интерфейсы позволяют выполнять множественное наследование. Скажем, Ваши тесты промаркированы следующими категориями:


public interface Category1 {}
public interface Category2 {}
public interface Category3 {}
public interface Category4 {}

и Вы хотите запускать тесты из категорий попарно Category1, Category2 и Category1,Category3. Для этого нужно сделать следующее:


public interface Category12 {}
public interface Category13 {}
public interface Category1 extends Category12,Category13 {}
public interface Category2 extends Category12 {}
public interface Category3 extends Category13 {}
public interface Category4 {}

Теперь категории Category12 и Category13 можно передавать в аннотацию @IncludeCategory. Создание таких родительских категорий, конечно, отнимает время, зато позволяет не изменять существующую маркировку тестовых методов или классов.

Правда, с увеличением количества классов в Suite и возможных вариантов запуска, конфигурация получается достаточно громоздкой. И самый большой недостаток, на мой взгляд, это добавление тестовых классов в Suite, об этом нужно постоянно помнить при создании новых классов.

Maven

Запуск категорий тестов с помощью Maven представляет собой более гибкий и удобный в использовании вариант. Для этого понадобится настроить maven-surefire-plugin:


			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-surefire-plugin</artifactId>
				<version>2.12</version>
				<dependencies>
					<dependency>
						<groupId>org.apache.maven.surefire</groupId>
						<artifactId>surefire-junit47</artifactId>
						<version>2.12</version>
					</dependency>
				</dependencies>
				<configuration>
					<groups>com.example.cat.Category1</groups>
				</configuration>
			</plugin>

Внутренняя зависимость в плагине surefire-junit47 обязательно должна присутствовать, иначе Maven будет игнорировать аннотации @Category.
Для того, чтобы исключить запуск каких-либо категорий, используется свойство excludedGroups:


<configuration>
	<excludedGroups>com.example.cat.Category2</excludedGroups>
</configuration>

Чтобы указать несколько категорий для запуска достаточно внести их через запятую:


<configuration>
	<groups>com.example.cat.Category1,com.example.cat.Category2</groups>
</configuration>

При запуске с помощью Maven наследование среди категорий не учитывается, все категории должны быть указаны явно. В связи с этим использование одновременно свойств groups и excludedGroups не имеет смысла, на выполнение будут запущены только тесты категорий, перечисленных в groups.

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

Как запустить тесты JUnit с Gradle?

В настоящее время у меня есть следующее построить.Gradle в:

apply plugin: 'java'

sourceSets {
    main {
        java {
            srcDir 'src/model'
        }
    }
}

dependencies {
    compile files('libs/mnist-tools.jar', 'libs/gson-2.2.4.jar')
    runtime fileTree(dir: 'libs', include: '*.jar')
}    

Это построить.Gradle в файл для моего репозитория здесь. Все мои основные файлы src / model/ и их соответствующие тесты находятся в тест/модель.

Как добавить JUnit 4 зависимость правильно, а затем запустить эти тесты в папках тесты/модели?

57

автор: informatik01

3 ответов


Как правильно добавить зависимость junit 4?

предполагая, что вы решаете против стандартного Maven (или эквивалентного) РЕПО:

dependencies {
    ...
    testCompile "junit:junit:4.11"  // Or whatever version
}

запустить эти тесты в папках tests / model?

вы определяете свой тестовый источник таким же образом:

sourceSets {
    ...

    test {
        java {
            srcDirs = ["test/model"]  // Note @Peter's comment below
        }
    }
}

затем вызовите тесты как:

./gradlew test

EDIT: если вы используете JUnit 5 вместо этого, есть больше шагов для завершения, вы должны следовать в этом уроке.

61

автор: Oliver Charlesworth


Если вы настроили свой проект со структурой пакета gradle по умолчанию, т. е.:

src/main/java
src/main/resources
src/test/java
src/test/resources

тогда вам не нужно будет изменять sourceSets для запуска тестов. Gradle выяснит, что ваши тестовые классы и ресурсы находятся в src/test. Затем вы можете бежать, как говорит Оливер выше. Одно замечание: будьте осторожны при настройке файлов свойств и запуске тестовых классов как с gradle, так и с IDE. Я использую Eclipse, и при запуске JUnit из него Eclipse выбирает один путь к классам (bin каталог), тогда как gradle выбирает другой (каталог сборки). Это может привести к путанице, если вы редактируете файл ресурсов и не видите изменения, отраженного во время выполнения теста.


если вы создали свой проект с Весна Initializr, все должно быть правильно настроен и все, что вам нужно сделать, это запустить…

./gradlew clean test --info
  • падение --info Если вы не хотите видеть выход теста.
  • падение clean Если вы не хотите, чтобы повторно запустить тесты, которые уже прошли с момента последнего изменения.

зависимости, необходимые в build.gradle для тестирования в Spring Boot…

dependencies {
    compile('org.springframework.boot:spring-boot-starter')
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

для по какой-то причине тестовый бегун не говорит вам об этом, но он создает отчет HTML в build/reports/tests/test/index.html.


Как выполнить модульное тестирование с помощью JUnit 4 (учебник по Junit 4 с примерами)


JUnit4 — Базовые аннотации


Ниже приведены наиболее часто используемые аннотации и их использование в базовом модульном тесте, написанном на JUnit 4.

  • @Test — помечает метод как метод тестирования.
  • @ До и @ После бутербродов каждый метод тестирования в классе.
  • @BeforeClass и @AfterClass объединяют все методы тестирования в тестовый класс JUnit.

Ниже приведен порядок выполнения вышеупомянутых методов при запуске теста JUnit4.

  1. Метод с аннотацией @BeforeClass
  2. Метод с аннотацией @Before
  3. Первый метод аннотирован @Test , то есть test1 () .
  4. Метод с пометкой @After
  5. Метод с аннотацией @Before
  6. Второй метод с аннотацией @Test i.е. test2 () .
  7. Метод с пометкой @After
  8. Метод с аннотацией @AfterClass
  общедоступный класс SampleTest {

        @BeforeClass
        public static void setUpBeforeClass () выдает исключение {
            
            
            // Метод с пометкой `@ BeforeClass` будет выполняться один раз перед любым из тестовых методов в этом классе.

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

            // Иногда несколько тестов должны совместно использовать дорогостоящую в вычислительном отношении настройку (например, вход в базу данных). Хотя это может поставить под угрозу независимость тестов, иногда это необходимая оптимизация. Из http://junit.sourceforge.net/javadoc/org/junit/BeforeClass.html
           
        }

        @После урока
        public static void tearDownAfterClass () выдает исключение {
            
            // Метод с пометкой `@ AfterClass` будет выполняться один раз после того, как в этом классе будут выполнены все тестовые методы.// Если вы выделяете дорогостоящие внешние ресурсы в методе BeforeClass, вам необходимо освободить их после того, как все тесты в классе будут выполнены. Аннотирование общедоступного статического метода void с помощью @AfterClass приводит к тому, что этот метод запускается после того, как все тесты в классе были выполнены. Все методы @AfterClass гарантированно работают, даже если метод BeforeClass вызывает исключение. Из http://junit.sourceforge.net/javadoc/org/junit/AfterClass.html
        }

        @Перед
        public void setUp () выдает исключение {
             // Метод, помеченный знаком `@ Before`, будет выполняться перед выполнением каждого тестового метода в этом классе.// Если вы обнаружите, что нескольким тестам нужны похожие объекты, прежде чем они смогут запускаться, этот метод можно использовать для настройки этих объектов (также известных как test-fixtures).
        }
        
        @После
        public void tearDown () выдает исключение {
             
             // Метод, помеченный символом `@ After`, будет выполняться после выполнения каждого тестового метода в этом классе.

             // Если вы выделяете внешние ресурсы в методе Before, вы должны освободить их в этом методе.
        }

        @Контрольная работа
        public void test1 () { 

Запуск тестов JUnit

В этой главе объясняется, как модифицировать существующий JUnit 3.x или 4.x, чтобы они могли работать с JavaTest Harness. Эта информация также может помочь вам в создании новых тестов JUnit, которые выполняются без ограничений.

JUnit — это простая среда для написания и запуска автоматических тестов. Написанный Эрихом Гаммой и Кентом Беком в 1997 году, JUnit представил сообществу программирования Java методы разработки, основанные на тестировании, из мира Smalltalk. JUnit теперь является проектом с открытым исходным кодом на SourceForge.net ( http://sourceforge.net/projects/junit ).

Инфраструктура JUnit предоставляет быстрый и простой интерфейс для создания набора тестов и их выполнения общим методом (например, с использованием Ant или сценария оболочки).Фреймворк налагает очень мало ограничений на действия тестировщика при написании тестового класса. В базовом дистрибутиве JUnit мало средств для взаимодействия с графическим интерфейсом или создания отчетов, и у него нет надежного интерфейса для настройки.

Описанная здесь процедура позволяет запускать тесты JUnit под жгутом name = «ProductName» content = «JavaTest Harness»?>. Обвязка name = «ProductName» content = «JavaTest Harness»?> Обеспечивает надежный графический интерфейс, множество параметров отчетности и возможность создать надежную систему конфигурации для тестов.Обвязку можно настроить для настройки графического интерфейса пользователя, типов отчетов, представления результатов и т. Д. Эти сервисы могут быть полезны для пользователей, которые хотят обернуть более мощные средства вокруг своей существующей тестовой инфраструктуры.

Процесс модернизации

В этом разделе описывается процесс модификации тестов JUnit таким образом, чтобы они выполнялись на жгуте name = «ProductName» content = «JavaTest Harness»?>.

Предварительные условия для преобразования тестов

Чтобы выполнить процесс преобразования, вы должны быть знакомы с некоторыми внутренними механизмами конвертируемого набора тестов JUnit.Конкретно нужно знать:

  • Чем тесты JUnit можно отличить от других тестов.

  • Версия JUnit, которая работает с набором тестов (3.x или 4.x).

  • Где хранятся тесты. Например, находятся ли они в одном дереве каталогов?

  • Библиотеки или вспомогательные процессы, необходимые для запуска тестов.

  • Параметры конфигурации или файлы, необходимые для запуска тестов.

Тесты, написанные для работы с JUnit 3.x, обычно идентифицируются как подкласс junit.framework.TestCase . Чтобы найти тесты JUnit 3.x, используйте класс c om.sun.javatest.junit.JUnitSuperTestFinder (расположенный в архиве jt-junit.jar ) для сканирования тестовых классов. Каждый класс, который является подклассом junit.framework.TestCase , определяется как признанный тест.

Тесты стиля

JUnit 4.x не используют конкретный суперкласс, скорее, они помечают классы с помощью org.junit.Test , аннотация. Name = «ProductName» content = «JavaTest Harness»?> Библиотека упряжи jt-junit.jar предоставляет класс com.sun.javatest.junit.JUnitAnnotationTestFinder для поиска тестов стиля 4.x. Он работает так же, как класс JUnitSuperTestFinder , но ищет другие критерии.

Дополнительные сведения см. В JUnitSuperTestFinder и JUnitAnnotationTestFinder.

Процедура преобразования тестов

В этой процедуре описывается, как настроить файлы, параметры свойств и параметры конфигурации перед запуском теста JUnit.

  1. Создайте файл testsuite.jtt в корне каталога продукта.

    Например, если продукт распаковывается в каталог foo / , файл testsuite.jtt должен находиться в этом каталоге. Его не обязательно размещать вместе с тестами.

    Файл .jtt — это файл с форматированием свойств, с парами ключ = значение в каждой строке. Установка ключей name и id является обязательной.Имя — это краткое описательное имя для вашего набора тестов, идентификатор — это внутренний ключ, используемый для идентификации этого набора тестов.

  2. Выберите метод сканирования для тестов, указав TestFinder class.

    Строка для указания класса TestFinder выглядит так:

      finder = com.sun.javatest.junit.JUnitSuperTestFinder 
      - суперкласс junit.framework.TestCase 
     

    См. JUnitAnnotationTestFinder и JUnitAnnotationTestFinder для получения дополнительной информации.

  3. Выберите свой TestSuite класс, используя com.sun.javatest.junit.JUnitTestSuite , если вы не подклассифицируете его.

    Используйте полное имя класса. Этот класс должен быть доступен по пути к системному классу, предпочтительно по пути к классу, определенному в вашем файле .jtt . Например:

      testsuite = com.sun.javatest.junit.JUnitTestSuite 
     
  4. Уточняйте интервью.

    Если у вас нет собственного собеседования, используйте строку ниже по умолчанию. Этот класс должен быть доступен в пути к системному классу, предпочтительно в настройке пути к классу в вашем файле .jtt . Например:

      интервью = com.sun.javatest.junit.JUnitBaseInterview 
     
  5. Обеспечьте тестов настройку.

    Местоположение тестов важно, потому что оно перенаправляется в класс TestFinder , который вы указали на шаге 2. Это местоположение часто совпадает с местоположением файла testsuite.jtt , как описано в шаге 2. Используйте косую черту, чтобы Независимая платформа пути. Не используйте абсолютные или относительные пути к местам выше testsuite.jtt . Примером может служить одна из следующих строк:

    • Если вы сканируете .java файлы, они могут находиться ниже каталога tests / .

        тесты = тесты 
       
    • Если вы сканируете файлы классов, они могут быть расположены ниже каталога classes / :

        тесты = классы 
       

    См. JUnitSuperTestFinder и JUnitAnnotationTestFinder для получения дополнительной информации.

  6. Убедитесь, что пути к любым классам, указанным в пакете тестов .jtt назначены ключу classpath в файле testsuite.jtt .

    Так ремни безопасности размещают классы. Например, если вы укажете:

      интервью = com.sun.javatest.junit.JUnitBaseInterview 
     

    не забудьте добавить путь к файлу JAR, который содержит этот класс, в ключ classpath , как показано здесь:

      classpath = lib / jt-junit.jar lib / jt-myts.банка 
     
  7. Попробуйте запустить привязь, чтобы проверить, найдет ли она ваши тесты.

    Вы должны решить, как организовать ваши (JAR) файлы и разрешить пути. Общая форма:

    >  компакт-диск mytestsuite / 
     
    >  java -jar lib / javatest.jar -ts. 
     

    Это запускает жгут и заставляет его загрузить набор тестов, расположенный в текущем каталоге (представленном «.»). Файл testsuite.jtt должен находиться в каталоге». «.

    Когда откроется главное окно, вы должны увидеть дерево с нужными вам тестами. Проверьте счетчики на главной панели, чтобы просмотреть сводку найденных тестов. Вы можете проверить пункт меню «Вид»> «Свойства», чтобы убедиться, что классы подключаемых модулей загружаются должным образом.

Технические характеристики

В этом разделе описаны два основных набора классов, обеспечивающих поддержку JUnit.Первый — это JUnitTestFinder (подкласс com.sun.javatest.TestFinder ). Варианты классов JUnitTestFinder , JUnitSuperTestFinder и JUnitAnnotationTestFinder примерно соответствуют поддержке JUnit 3.x и 4.x. Разница объясняется ниже.

Второй вспомогательный компонент — это класс JUnitMultiTest , который отвечает за выполнение тестов.

Классы поддержки

Следующие дополнительные «клеящие» классы предоставляются для соединения всего: JUnitTestSuite , JUnitBaseInterview и JUnitTestRunner .Описание каждого вспомогательного класса приводится ниже.

  • Класс JUnitTestSuite — это очень простой класс, который инструктирует привязку использовать JUnitTestRunner для выполнения тестов. Если этого метода нет, используется DefaultTestRunner . Это традиционный способ выполнения тестов, требующих класса Script . Поскольку присутствует класс TestRunner , есть полный контроль над выполнением тестов. Например, жгут может определять, сколько тестов запускается одновременно и как они запускаются (например, с помощью exec ).Расширяя этот класс, вы получаете доступ к переопределению других аспектов подвески. См. TestRunner API для получения дополнительной информации. Обратите внимание, что многие параметры, описанные в этом документе в файле testsuite.jtt , могут быть жестко закодированы в подкласс TestSuite . Базовый класс TestSuite предоставляет функциональные возможности для создания экземпляра настроек в testsuite.jtt .

  • Класс JUnitBaseInterview — это скелетный класс интервью, не требующий ввода от пользователя.Если ваши тесты JUnit не требуют настройки от пользователя, не изменяйте ее. Попробуйте один из следующих способов получить значения от пользователя:

    • Прочтите файл конфигурации из заранее определенного места, возможно, относительно корня набора тестов ( TestSuite.getRootDir () ).

    • Спросите у пользователя значения напрямую, используя com.sun.interview API. Это основное средство, с помощью которого программа предназначена для получения значений от пользователя.В любом случае значения должны оказаться на карте Map , предоставленной в Interview.export (Map) . Карта Map — это набор значений, к которым должны иметь доступ другие классы, а именно JUnitTestRunner и классы, которые он создает ( JUnitMultiTest ). Прочтите главу 6 для получения дополнительной информации.

  • Класс JUnitTestRunner отвечает за отправку тестов. Он имеет доступ через Iterator ко всему списку тестов, которые будут выполняться во время тестового прогона.Поскольку тест представлен TestDescription , вы должны настроить средство поиска тестов, чтобы добавить любые настройки, которые вам понадобятся позже (в этом классе). Реализация по умолчанию выполняет тест с использованием JUnitBareMultiTest , если для свойства TestDescription junit.finderscantype установлено значение суперкласс . Если он не установлен на суперкласс , он использует класс JUnitAnnotationMultiTest . Вы можете изменить это поведение, используя свой собственный класс JUnitMultiTest или подкласс одного из них.

JUnitSuperTestFinder

Этот класс ищет суперкласс, который идентифицирует класс как тест JUnit. По умолчанию он ищет в предках каждого класса junit.framework.TestCase . Поскольку для набора тестов могут потребоваться дальнейшие производные от junit.framework.TestCase для поддержки своих конкретных потребностей, вы можете использовать опцию -superclass , чтобы указать более конкретный класс.

Например, рассмотрим следующую структуру классов:

Ява.lang.Object
   junit.framework.TestCase
      foo.BetterTestCase
         product.Test0002a
 

Test0002a является подклассом BetterTestCase и т. Д.

  • Если задано Test0002a , JUnitSuperFinder поднимается по цепочке наследования до тех пор, пока не достигнет либо соответствующего суперкласса, либо java.lang.Object . По умолчанию он ищет класс TestCase , поэтому, когда ему задано Test0002a , он поднимается на два уровня, находит java.lang.Object и возвращает Test0002a в жгут в качестве теста.

  • Если этому средству поиска тестов присвоено java.util.ArrayList , он поднимается, пока не достигнет java.lang.Object , после чего он решит, что класс не является тестом, и перейдет к следующему.

Чтобы изменить суперкласс, который вы просматриваете, укажите аргумент -superclass и укажите имя класса. Вы можете указать этот аргумент несколько раз, чтобы сканировать несколько суперклассов.Например, в файле testsuite.jtt вы можете указать следующее:

  finder = com.sun.javatest.junit.JUnitSuperTestFinder -суперкласс 
  foo.BetterTestCase-суперкласс foo.CustomTestCase 
 

Хотя он не выполняет тесты, средство поиска тестов пытается выбрать методы тестирования, ища общедоступные методы, которые начинаются со строки « test ». Затем он перечисляет их в списке, разделенном пробелами, без параметров (только имя метода).Список может содержать дубликаты, поскольку полная подпись не оценивается. Семантика для этого значения TestDescription на данный момент свободно определена. Общественные комментарии приветствуются (отправляйте свои комментарии на форум по интересам JT Harness по адресу http://java.net/projects/jtharness ).

Этот искатель суперкласса генерирует значения TestDescription ( com.sun.javatest.TestDescription ), показанные в таблице 12-1.

Таблица 12-1 Значения описания теста JUnitSuperTestFinder

Ключ Значение (я)

ключевых слов

юнит, юнит3

junit.finderscantype

суперкласс

junit.testmethods

(перечень идентифицированных методов испытаний)

JUnitAnnotationTestFinder

Это средство поиска тестов аннотаций сканирует классы на предмет аннотации org.junit.Test . Он использует ту же стратегию сканирования, что и JUnitSuperTestFinder .

Это средство поиска аннотаций генерирует значения TestDescription ( com.sun.javatest.TestDescription ), показанные в таблице 12-2.

Таблица 12-2 Значения описания теста JUnitAnnotationTestFinder

Ключ Значение (я)

ключевых слов

юнит, юнит4

junit.finderscantype

аннотация

junit.testmethods

(перечень идентифицированных методов испытаний)

JUnitBareMultiTest

Это класс выполнения для тестов стиля JUnit 3.x. Выполнение выполняется с использованием имени класса, предоставленного средством поиска тестов (через TestDescription ), которое используется для выполнения этого класса TestCase.runBare () метод. Этого может быть недостаточно для всех наборов тестов. Захватывается вывод stdout и stderr . Тест проходит, если не генерируются исключения, и терпит неудачу, если есть какие-либо результаты Throwable .

JUnitAnnotationMultiTest

Это класс выполнения для тестов стиля JUnit 4.x. Он берет класс, который был идентифицирован средством поиска тестов, и выполняет его с использованием частей библиотеки JUnit TestResult.Section . Кроме того, поскольку выполнение передается JUnit, он не сообщает никаких собственных отладочных данных во время выполнения.(В будущем было бы полезно использовать больше преимуществ Result API и любых доступных API наблюдателей.)

Замечания по реализации

Использование ключевых слов junit3 и junit4 может быть обобщением, поскольку оно действительно представляет, как был найден класс. Набор тестов может сочетать использование функций версии 3 и 4, что означает, что он не обязательно полностью совместим с 4.x. Тем не менее, возможно, возможность запускать тесты стиля 3.x из смешанного набора (см. com.sun.javatest.finder.ChameleonTestFinder ) может быть полезным. Не забывайте, что ключевое слово junit также добавлено, чтобы тесты JUnit можно было выбирать среди тестов, не относящихся к JUnit.

Два из наиболее вероятных изменений, которые вам следует внести, — это изменить средство поиска тестов или изменить способ выполнения теста. Чтобы изменить средство поиска тестов, просто создайте подкласс JUnitTestFinder , укажите его в пути к классам в testsuite.jtt и измените настройку поиска в testsuite.jtt .

Чтобы изменить метод выполнения теста, необходимо изменить способ его отправки в JUnitTestRunner . Чтобы изменить это, вы должны создать подкласс JUnitTestRunner и предоставить его в пути к классу testsuite.jtt . Вы также должны создать подкласс JUnitTestSuite и изменить его настройку в testsuite.jtt (см. Файл testsuite.jtt).

Области улучшения

В этом разделе перечислены функции реализации, которым могут быть полезны отзывы пользователей и дальнейшее развитие.Вы можете предоставить это на веб-сайте JT harness http://java.net/projects/jtharness .

  • В настоящее время использование пути к классам неудобно. Общая конструкция жгута заключается в том, что настройка в testsuite.jtt влияет на тесты, а не на путь к системному классу, который использует жгут. Эта область может быть более изысканной.

  • Было бы полезно несколько дополнительных базовых реализаций класса интервью. В частности, предоставление такого файла, который считывает файл свойств и выгружает его прямо в карту Map интервью Interview.export (Map) предоставит людям «быстрый и грязный» способ настройки своих наборов тестов. Возможно, расположение файла можно записать как настройку в testsuite.jtt .

    Примечание:

    Как правило, пользователей не следует рекомендовать изменять testsuite.jtt . Эти настройки статичны. Информация, которую предоставляет пользователь, должна собираться через систему интервью. Как архитектор, вы должны настроить набор тестов .jtt для общего использования в процессе модернизации. После завершения преобразования файл должен оставаться относительно нетронутым.

  • Может оказаться полезным жестко запрограммировать класс Interview и принять переопределение в файле testsuite.jtt вместо того, чтобы заставлять разработчика указывать его в файле, как описано выше. Это также относится к JUnitTestRunner (или просто к классу TestRunner ) в реализации JUnitTestSuite .

Использование JUnit 5 в IntelliJ IDEA — блог IntelliJ IDEA

Одной из новых функций в IntelliJ IDEA 2016.2 является поддержка новой среды тестирования JUnit 5. Практически все разработчики Java в какой-то момент будут использовать JUnit, поэтому довольно интересно узнать, что новейшая версия эволюционировала с течением времени и предоставляет ряд новых функций, некоторые из которых могут быть знакомы тем, кто использовал другие среды.

IntelliJ IDEA поддерживает возможность фактически запускать тесты, написанные для JUnit 5 — нет необходимости использовать дополнительные библиотеки (например, плагины Gradle или Maven), все, что вам нужно, это включить зависимость JUnit 5.Здесь мы используем Gradle, чтобы включить зависимость от версии M2:

Как только вы это сделаете, можете приступить к написанию тестов, использующих новые аннотации:

Выполнение этих тестов даст вам знакомые результаты в окне запуска IntelliJ IDEA:

Вы заметите, что JUnit Jupiter — это механизм тестирования для новых тестов JUnit, и что вы можете запускать как новые, так и старые тесты.

На первый взгляд, новые тесты JUnit 5 ничем не отличаются от тестов JUnit 4, за исключением того, что аннотации импортируются из другого пакета и показывают результаты двух типов бегунов.

Но JUnit 5 поставляется с некоторыми новыми функциями, такими как возможность добавлять читаемое имя или описание для теста, поэтому вам больше не нужно полагаться на имя метода, используя @DisplayName :

Вы можете сгруппировать утверждения, чтобы выполнялись все утверждения, независимо от того, является ли одно (или несколько) неудачным, что дает вам лучшую видимость истинного состояния отказа:

И вы можете использовать аннотацию @Nested , чтобы вы могли писать тесты в стиле BDD или группировать тесты в классе по некоторому параметру:

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

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

Это лишь некоторые из функций, доступных для использования в JUnit 5, и поддержка IntelliJ новой инфраструктуры также развивается.

Если вы думаете, что JUnit 5 выглядит интересным, загрузите IntelliJ IDEA 2016.2 и посмотрите:

И, конечно же, вы можете ознакомиться с другими функциями, доступными в IntelliJ IDEA 2016.2.

Java Unit Test — Junit_Weison-CSDN 博客 _java test

JUnit — это Java, созданная на основе xUnit.

JUnit 促进 了 “先 测试 后 编码” 的 理念 , 强调 建立 测试 数据 的 一段 代码 , 先 测试 , 然后 再 应用
这个 方法 就好 比 “测试 一点 , ……”了 程序员 的 产量 和 程序 的 稳定性 , 可以 减少 程序员 的 压力 和 花费 在 排错 的 时间。

1 JUnit 中 的 重要 的 API

核心 思想 通过 断言 来 预言 被 测试 方法 是否 按 预期 执行。
本文 基于 JUnit 4.1.2

JUnit находится в 中 的 最 重要 的 程序 包 是 junit.framework 包含 所有 的 核心 类。
一些 的 类 列示 如下 :

1

1 утверждение

Assert 的 重要 方法 列 式 如下 :

的 名称 的 功能
1 Assert assert 方法 的
2
3 TestResult TestResult 了 执行 测试 的 所有 结果
4 TestSuite TestSuite
序号 方法 描述
1 void assertEquals (логическое ожидание, логическое фактическое) void assertEquals (логическое ожидание, логическое фактическое значение) void логическое условие) 条件 是 假 的
3 void assertNotNull (Object object) 检查 对象 不是 的
4 void assert 90 9090 объект 90对象90
5 void assertTrue (булево условие) 检查 条件 为 真
6 void fail () 在 报告 的 情况 使 76322 9005代码 :

  публичный класс AssertTest {
    @Контрольная работа
    public void testAssertions () {
        
        Строка str1 = новая строка ("abc");
        Строка str2 = новая строка ("abc");
        Строка str3 = null;
        Строка str4 = "abc";
        Строка str5 = "abc";
        int val1 = 5;
        int val2 = 6;
        String [] expectedArray = {"один", "два", "три"};
        String [] resultArray = {"один", "два", "три"};

        
        assertEquals (str1, str2);

        
        assertTrue (значение1 <значение2);

        
        assertFalse (значение1> значение2);

        
        assertNotNull (str1);

        
        assertNull (str3);

        
        assertSame (str4, str5);

        
        assertNotSame (str1, str3);

        
        assertArrayEquals (ожидаемыйArray, resultArray);
    }

}
  

1.2 注解

Junit 中 的 注解 的 列表 以及 他们 的 含义 :

测试用例 执行 时 长大 于 的 毫秒 数 , 那么 自动 被 标记 为 失败。

序号 注解 描述
1 @Test 注解 说明 依附 在 JUnit JUnit public void 90 2

有些 测试 在 运行 前 需要 创造 几个 相似 的 对象 , public void 方法 加 该 注释 是 因为 方法 需要 在 test 方法 前 运行。
3 @After 如果 在 外部方法 中 分配 , 那么 你 需要 在 测试 后 释放 他们。 在 public void 方法 加 该 注释 该 方法 需要 在 test 方法 后 运行。
4 @BeforeClass public void public是 因为 该 方法 需要 在 类 中 所有 方法 前 运行。
5 @AfterClass 它将 会使 方法 测试 结束 后 执行 , 这个 进行 清理 活动

5

@Ignore 这个 注释 是 用来 不需要 执行 的 测试 的 , Junit 在 类 级别 上 使用 @Ignore 来 忽略 的 的 测试用例。
7 @Test (timeout = 100090)
8 @Test (за исключением = RuntimeException.class) 测试用例 抛出 RuntimeException 则 pass。
9 @RunWith (Parameterized.class) 注入 参数
1.2.1 @Before @After

使用 @ До , @ После JUnite 执行 过程 :

  • 1 beforeClass () 方法 首先 执行 , 并且 只 执行 一次。
  • 2 afterClass () 方法 最后 执行 , 并且 只 执行 一次。
  • 3 before () 方法 针对 每 一个 测试用例 执行 , 但是 是 在 执行 测试用例之前。
  • 4 после () 方法 针对 每 一个 测试用例 , 但是 是 在 执行 测试用例 之后。
  • 5 在 до () 方法 和 после () 方法 之间 , 执行 每 一个 测试用例。

代码如下 :

 
public class JunitAnnotation {
    
    @BeforeClass
    public static void beforeClass () {
        Система.out.println («в до класса»);
    }

    
    @После урока
    public static void afterClass () {
        System.out.println ("после занятий");
    }

    
    @Перед
    public void before () {
        System.out.println ("до");
    }

    
    @После
    public void after () {
        System.out.println ("после");
    }

    
    @Контрольная работа
    public void test () {
        System.out.println («в тесте»);
    }

    
    @ Игнорировать
    public void ignoreTest () {
        System.out.println ("в тесте игнорирования");
    }
}
  
1.2.2 @ Ожидается тест и время ожидания
  public class CalculateService {

    public Integer plus (Integer a, Integer b) {
        вернуть a + b;
    }

    public Integer subtract (Object a, Integer b) {
        return (Integer) check (a) - b;
    }

    public Integer multiply (Integer a, Integer b) {
        вернуть a * b;
    }

    общественное целочисленное деление (целое число a, целое число b) {
        возврат а / б;
    }

    общедоступная проверка объекта (объект а) {
        if (a instanceof Integer) {
            Система.out.println ("Это целое число ~");
            вернуть;
        } еще
            throw new RuntimeException («Это не целое число ~»);
    }
}
  
  общедоступный класс CaculateServiceTest {
    частный CaculateService caculateService = новый CaculateService ();

    @Контрольная работа
    public void plus () {
        
        assertEquals (новое целое число (3), caculateService.plus (1, 2));

    }

    @Test (ожидается = RuntimeException.class)
    public void subtractException () {
        
        assertEquals (новое целое число (2), caculateService.вычесть («4», 2));
    }

    @Test (тайм-аут = 100)
    public void plusTimeout () {
        пытаться {
            TimeUnit.SECONDS.sleep (10);
        } catch (InterruptedException e) {
        }
        
        assertEquals (новое целое число (3), caculateService.plus (1, 2));
    }
}
  
1.2.3 @RunWith 参数 化 测试

Junit 4 了 一个 的 参数 化 测试。
参数 化 测试 允许 开发 使用 不同 的 值 反复 运行 同 一个 测试。

你 将 遵循 5 个 步骤 来 创建 参数 化 测试。

  • 1 用 @RunWith (Parameterized.class) 来 注释 test 类。
  • 2 创建 一个 由 @Parameters 注释 的 公共 的 静态 方法 , 它 一个 对象 (数组) 来 作为 测试 集合。
  • 3公共 的 构造 函数 , 它 接受 和 数据 同 的 东西。
  • 4 每一 列 测试 创建 一个 实例 的
  • 5 作为 创建 你 测试用例
  • 一旦 每一 行 数据 出现 测试用例 将 被 调用 , 如下 :

    被 测试 类 : 用来 求 余 数

      открытый класс RemainderService {
        public Boolean validate (final Integer primeNumber) {
            если (простое число% 2 == 0)
                вернуть истину;
            вернуть ложь;
        }
    }
      

    测试 类 :

      @RunWith (параметризовано.класс)
    открытый класс RemainderServiceTest {
        частное целое число inputNumber;
        private Boolean expectedResult;
        частный RemainderService stayderService;
    
        @Перед
        public void initialize () {
            остатокСервис = новый РемайндерСервис ();
        }
    
        
        
        
        общедоступный RemainderServiceTest (Целое число inputNumber,
                                    Boolean expectedResult) {
            this.inputNumber = inputNumber;
            this.expectedResult = expectedResult;
        }
    
        @ Parameterized.Parameters
        public static Collection primeNumbers () {
            Список объектов  = массивы.asList (
                    новый объект [] [] {
                            {2, правда},
                            {3, false},
                            {4, правда},
                            {5, false},
                            {6, правда}
                    });
            возвращать объекты;
        }
    
        
        @Контрольная работа
        public void testPrimeNumberChecker () {
            System.out.println ("Параметризованное число:" + inputNumber);
            assertEquals (ожидаемый результат,
                    остатокСервис.validate (inputNumber));
        }
    }
      
    

    执行 结果 :

      Начало тестирования в 23:58...
    23:58:15: Выполнение задач ': cleanTest: test --tests "com.wxx.st.runwith.RemainderServiceTest.testPrimeNumberChecker [*]"' ...
    
    > Задача: cleanTest
    > Задача: compileJava
    > Задача: processResources NO-SOURCE
    > Задача: занятия
    > Задача: compileTestJava
    > Задача: processTestResources NO-SOURCE
    > Задача: testClasses
    > Задача: тест
    Параметризуемое число: 2
    Параметризуемое число: 3
    Параметризуемое число: 4
    Параметризуемое число: 5
    Параметризуемое число: 6
    СТРОЙТЕ УСПЕШНО за 1 секунду
    4 действенные задачи: 4 выполнены
    23:58:17: Выполнение задачи завершено ': cleanTest: test --tests "com.wxx.st.runwith.RemainderServiceTest.testPrimeNumberChecker [*] "'.
    
      

    1,3

    捆绑 几个 单元 测试用例 并且 一起 执行 他们。
    在 JUnit 中 , @ RunWith 和 @Suite 注释 用来 运行 套件 测试。

    代码 Тест1 :

      общедоступный класс Test1 {
        Строковое сообщение = "Роберт";
        MessageUtil messageUtil = новое MessageUtil (сообщение);
    
        @Контрольная работа
        public void testPrintMessage () {
            System.out.println ("Внутри testPrintMessage ()");
            assertEquals (сообщение, messageUtil.printMessage ());
        }
    }
      
      общедоступный класс Test2 {
        Строковое сообщение = "Роберт";
        MessageUtil messageUtil = новое MessageUtil (сообщение);
    
        @Контрольная работа
        public void testSalutationMessage () {
            Система.out.println ("Внутри testSalutationMessage ()");
            message = "Привет!" + «Роберт»;
            assertEquals (сообщение, messageUtil.salutationMessage ());
        }
    }
      

    代码 Test2 :

      @RunWith (Suite.class)
    @ Suite.SuiteClasses ({
            Test1.class, Test2.class, CaculateServiceTest.class, AssertTest.class, SetUpTearDownTest.class
    })
    public class TestSuite {
    }
      

    捆绑 多个 单元 测试 , 并 打印 成功 和 失败 的 案例 :

      общедоступный класс TestSuiteTest {
        public static void main (String [] args) {
            Система.out.println ("- 开始 -");
            Результат result = JUnitCore.runClasses (TestSuite.class);
            Целое число i = 1;
            for (Failure failure: result.getFailures ()) {
                System.out.println ("-" + i + "-" + failure.toString ());
                i ++;
            }
            System.out.println ("- 结束 -" + result.wasSuccessful ());
        }
    }
      

    1.4 TestCase 类

    TestCase 的 一些 重要 方法 列 式 :

    TestCase

    7

    9049

    序号 方法 描述
    1 int countTestCases () 为 被 run (TestResult result) 的 测试 案例

    2

    Используйте TestResult для
    3 String getName () Для TestCase укажите
    4 TestResult run () 的 结果
    5 void run (TestResult result) 在 TestResult 中 运行 测试 案例 结果
    6 void setName (String name) void setUp () 创建 固定 装置 , 例如 , 打开 一个 网络 连接
    8 void tearDown () 拆除 固定 装置 , 关闭 一个 网络 Строка toString () 返回 测试 案例 的 一个 字符串 表示

    T estCase 代码 :

      открытый класс SetUpTearDownTest расширяет TestCase {
    
        защищенное целое значение1, значение2;
    
        
        protected void setUp () {
            значение1 = 3;
            значение2 = 3;
        }
    
        @Контрольная работа
        public void testAdd () {
            двойной результат = значение1 + значение2;
            assertTrue (результат == 6);
        }
    
        
        @Override
        protected void tearDown () {
            Система.out.println ("--------------");
        }
    }
      

    代码 地址 : 链接

    Основы JUnit — Практическая разработка через тестирование для Java-программистов Видеоурок

    Обзор

    Стенограммы

    Файлы упражнений

    Просмотр в автономном режиме

    Детали курса

    Узнайте, как использовать тесты для написания кода, ключевого компонента гибкого программирования.Этот курс охватывает не только теорию, но и ряд практических тем, которые могут помочь разработчикам Java освоить разработку через тестирование (TDD). Инструктор Мэтт Гринкрофт помогает познакомить вас с процессом, необходимым для TDD, а также с тем, как решать реальные проблемы, с которыми вы можете столкнуться при выполнении TDD. Узнайте, как написать свой первый тест, и определите, что считается хорошим или плохим. Кроме того, вы узнаете, как тестировать код там, где есть зависимость от сторонних ресурсов, как создавать макеты и заглушки с помощью Mockito — популярной сторонней библиотеки — и многое другое.

    Инструктор

    • Мэтт Гринкрофт

      Директор Capability Training & Management Ltd

      Мэтт Гринкрофт — штатный тренер и консультант по разработке программного обеспечения.Мэтт занимается разработкой и проведением ряда учебных курсов по Java для бренда Virtual Pair Programmers. На этих курсах он помогает всем, от новичков до экспертов по Java, повысить свои навыки программирования. Помимо технического образования, Мэтт использует свой дар публичных выступлений в качестве профессионального тамадора и церемониймейстера.

      Узнать больше

      Видеть меньше

    Навыки, описанные в этом курсе

    Зрители этого курса

    13 293 человека смотрели этот курс

    Связанные курсы

    Добро пожаловать

    «

    — [Инструктор] Я не уверен, использовали ли вы раньше JUnit, поэтому, если вы этого не сделали, я просто хочу указать на пару вещей.Прежде всего, прямо над методом у нас есть аннотация @test. Неудивительно, что эта аннотация означает, что следующий метод является тестовым. Но это означает, что когда мы сообщаем eclipse, что хотим запустить все наши тесты, этот метод будет запущен. Это аннотация, которая сообщает eclipse, что этот метод является тестовым. Поэтому важно, чтобы у нас была аннотация. Если мы щелкнем правой кнопкой мыши по нашей рабочей области и выберем запуск от имени, а затем JUnit test, то мы увидим, что здесь внизу этот тест — это имя метода.Итак, поскольку у нас есть аннотация @test, этот метод был запущен. И у нас здесь красная полоса. Если вы помните, наш рабочий процесс — это красно-зеленый рефакторинг, и это красная часть. Это означает, что один или несколько тестов не прошли. Сразу над красной полосой мы можем видеть, что у нас был один запуск из одного теста, ни один тест не дал ошибок, но один тест дал сбой. Ошибка…

    Практикуйтесь во время обучения с файлами упражнений

    Загрузите файлы, которые инструктор использует для проведения курса.Следуйте инструкциям и учитесь, наблюдая, слушая и практикуя.

    Скачивайте курсы и учитесь на ходу

    Смотрите курсы на мобильном устройстве без подключения к Интернету. Загрузите курсы с помощью приложения LinkedIn Learning для iOS или Android.

    Junit3.8.1 — Документация Junit API

    Junit3.8.1 — Документация по API Junit

    Junit API

    Содержание