Testando com Spring

Testes Parametrizados com Kotlin e JUnit 6: Parte 1

📦 Pacote Master 📝 Aula 138 🕒 Atualizado em 02/11/2026 às 16:23 (4ff6d32)

Ao concluirmos este webinar, nós:

  • Saberemos como obter as dependências necessárias com Maven e Gradle.
  • Conseguiremos escrever testes parametrizados com JUnit 6 e Kotlin.
  • Saberemos como customizar o nome de cada invocação da função de teste.
  • Entenderemos como podemos utilizar diferentes fontes de argumentos (argument sources).

Este webinar assume que:

  • Você sabe escrever classes de teste com JUnit 6 e Kotlin (veja a aula anterior deste módulo).

Obtendo as Dependências Necessárias

Antes de podermos escrever testes parametrizados com o JUnit 6 (JUnit Jupiter 6.0.3), precisamos adicionar a dependência junit-jupiter-params ao nosso build (em projetos Spring Boot 4.1.2, o spring-boot-starter-test já gerencia e inclui essa dependência automaticamente, mas em projetos puros ou customizados podemos declará-la explicitamente).

Se estivermos utilizando o Maven, podemos adicionar essa dependência ao nosso build adicionando o seguinte trecho à seção dependencies do nosso arquivo pom.xml:

1
2
3
4
5
6

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

Se estivermos utilizando o Gradle 9.8.2 (com Kotlin DSL), precisamos adicionar a dependência junit-jupiter-params à configuração de dependências testImplementation. Podemos fazer isso adicionando o seguinte trecho ao nosso arquivo build.gradle.kts:

1
2
3

testImplementation(
    "org.junit.jupiter:junit-jupiter-params:6.0.3"
)

Nota sobre o Gradle:

A configuração de dependências testImplementation substituiu a antiga configuração testCompile do Gradle legado, garantindo melhor isolamento do classpath de compilação e execução de testes.

Vamos avançar e escrever o nosso primeiro teste parametrizado com JUnit 6.

Escrevendo Nosso Primeiro Teste Parametrizado com JUnit 6

Podemos escrever um teste parametrizado simples com JUnit 6 seguindo estes passos:

  1. Adicionar uma nova função de teste à nossa classe de teste e especificar os parâmetros da função que devem ser repassados para a nossa função de teste.
  2. Anotar a função de teste com a anotação @DisplayName e especificar o nome de exibição.
  3. Anotar a função de teste com a anotação @ParameterizedTest. Esta anotação identifica funções de teste parametrizadas.
  4. Fornecer os parâmetros que serão passados para a nossa função de teste. Como a nossa função de teste recebe um único objeto String como parâmetro, podemos fornecer os parâmetros anotando a nossa função de teste com a anotação @ValueSource.

Depois de escrevermos o nosso primeiro teste parametrizado, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource

@Tag("unitTest")
@DisplayName("@ValueSource example")
class ValueSourceExampleTest {

    @DisplayName("Use the parameters provided by the @ValueSource annotation")
    @ParameterizedTest
    @ValueSource(strings = ["Hello", "World"])
    fun shouldPassNotNullMessageAsFunctionParameter(message: String) {
        assertThat(message).isNotNull()
    }
}

Nota:

A anotação @ValueSource nos permite especificar os parâmetros da função utilizando um array que pode conter valores literais (strings, ints, longs, doubles, booleans, chars, bytes, shorts, floats ou classes). Além disso, só podemos utilizar esta anotação se a nossa função de teste receber apenas um único parâmetro de função por invocação.

Leitura Adicional:

Quando executamos o nosso teste parametrizado, devemos ver uma saída semelhante a esta:

1
2
3
4

@ValueSource example
|_   Use the parameters provided by the @ValueSource annotation
 |_  [1] Hello
 |_  [2] World

Embora essa saída pareça bastante limpa, às vezes queremos fornecer o nosso próprio nome de exibição (display name) para cada invocação da função. Vamos descobrir como podemos fazer isso.

Customizando o Nome de Exibição de Cada Invocação de Função

Podemos customizar o nome de exibição de cada invocação da função definindo o valor do atributo name da anotação @ParameterizedTest. Este atributo suporta os seguintes placeholders:

  • {index}: O índice da invocação atual. Note que o índice da primeira invocação é 1.
  • {arguments}: Uma lista separada por vírgulas contendo todos os parâmetros da função.
  • {i}: O índice do parâmetro específico da função (por exemplo, {0}, {1}). Note que o índice do primeiro parâmetro da função é 0.

Vamos fornecer um nome de exibição customizado para a nossa função de teste. Esse nome de exibição deve mostrar o índice da invocação atual e o parâmetro de função utilizado.

Depois de customizarmos o nome de exibição da nossa função de teste, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource

@Tag("unitTest")
@DisplayName("@ValueSource example")
class ValueSourceExampleTest {

    @DisplayName("Use the parameters provided by the @ValueSource annotation")
    @ParameterizedTest(name = "{index} => message=''{0}''")
    @ValueSource(strings = ["Hello", "World"])
    fun shouldPassNotNullMessageAsFunctionParameter(message: String) {
        assertThat(message).isNotNull()
    }
}

Quando executamos o nosso teste parametrizado, devemos ver uma saída semelhante a esta:

1
2
3
4

@ValueSource example
|_   Use the parameters provided by the @ValueSource annotation
 |_  1 => message='Hello'
 |_  2 => message='World'

Leitura Adicional:

Quando escrevemos nosso primeiro teste parametrizado, utilizamos uma fonte de argumentos (@ValueSource) suportada pelo JUnit Jupiter. A seguir, descobriremos como podemos utilizar as outras fontes de argumentos suportadas.

Utilizando as Outras Fontes de Argumentos

O JUnit 6 possui um suporte bastante versátil para diferentes fontes de argumentos. A seguir, analisaremos oito fontes de argumentos diferentes. Vamos começar observando a anotação @NullSource.

Utilizando a Anotação @NullSource

Se quisermos passar um único parâmetro null para a nossa função de teste, precisamos anotar a nossa função de teste com a anotação @NullSource (e declarar o tipo do parâmetro como anulável no Kotlin com ?). Depois de fazermos isso, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.NullSource

@Tag("unitTest")
@DisplayName("@NullSource and @EmptySource example")
class NullAndEmptySourceExampleTest {

    @DisplayName("Should pass a single null value as a function parameter")
    @ParameterizedTest(name = "{index} => text={0}")
    @NullSource
    fun shouldPassSingleNullValueAsFunctionParameter(text: String?) {
        assertThat(text).isNull()
    }
}

Leitura Adicional:

A seguir, descobriremos como podemos fornecer um único parâmetro vazio para a nossa função de teste.

Utilizando a Anotação @EmptySource

Se quisermos passar um único parâmetro vazio para a nossa função de teste, precisamos anotar a nossa função de teste com a anotação @EmptySource. Depois de fazermos isso, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EmptySource

@Tag("unitTest")
@DisplayName("@NullSource and @EmptySource example")
class NullAndEmptySourceExampleTest {

    @DisplayName("Should pass a single empty string as a function parameter")
    @ParameterizedTest(name = "{index} => text={0}")
    @EmptySource
    fun shouldPassSingleEmptyStringAsFunctionParameter(text: String) {
        assertThat(text).isEmpty()
    }
}

Nota:

A anotação @EmptySource suporta os seguintes tipos: java.lang.String, java.util.List, java.util.Set, java.util.Map, arrays de tipos primitivos (ex.: IntArray / int[]) e arrays de objetos (ex.: Array<Int> / Integer[]).

Leitura Adicional:

Vamos avançar e descobrir como podemos passar tanto um único parâmetro null quanto um único parâmetro vazio para a nossa função de teste.

Utilizando a Anotação @NullAndEmptySource

A anotação @NullAndEmptySource combina a funcionalidade das anotações @NullSource e @EmptySource. Em outras palavras, se quisermos passar um único parâmetro null e um único parâmetro vazio para a nossa função de teste, precisamos anotá-la com a anotação @NullAndEmptySource.

Depois de fazermos isso, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.NullAndEmptySource

@Tag("unitTest")
@DisplayName("@NullSource and @EmptySource example")
class NullAndEmptySourceExampleTest {

    @DisplayName("Should pass null and empty string as function parameters")
    @ParameterizedTest(name = "{index} => text={0}")
    @NullAndEmptySource
    fun shouldPassNullAndEmptyStringAsFunctionParameters(text: String?) {
        assertThat(text).isNullOrEmpty()
    }
}

Leitura Adicional:

A seguir, descobriremos como podemos combinar parâmetros null e vazios com parâmetros fornecidos pela anotação @ValueSource.

Combinando Parâmetros Nulos e Vazios com a Anotação @ValueSource

Podemos combinar as anotações @NullSource, @EmptySource e @NullAndEmptySource com a anotação @ValueSource. Vamos escrever um teste parametrizado e passar um único valor null, uma única String vazia e diferentes strings contendo apenas espaços em branco (whitespace) como parâmetros da função.

Depois de escrevermos o nosso teste parametrizado, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.NullAndEmptySource
import org.junit.jupiter.params.provider.ValueSource

@Tag("unitTest")
@DisplayName("@NullSource and @EmptySource example")
class NullAndEmptySourceExampleTest {

    @DisplayName("Should pass all provided values as function parameters")
    @ParameterizedTest(name = "{index} => text={0}")
    @NullAndEmptySource
    @ValueSource(strings = ["", " ", "\t", "\n"])
    fun shouldPassAllProvidedValuesAsFunctionParameters(text: String?) {
        assertThat(text?.trim()).isNullOrEmpty()
    }
}

Leitura Adicional:

Vamos avançar e descobrir como podemos passar valores de um enum para o nosso teste parametrizado.

Utilizando a Anotação @EnumSource

A anotação @EnumSource nos permite especificar os valores de um enum que serão passados para o nosso teste parametrizado. Vamos supor que precisamos escrever um teste parametrizado que recebe os valores do enum Pet como parâmetros da função. O código-fonte do enum Pet é o seguinte:

1
2
3
4

enum class Pet {
    CAT,
    DOG
}

Se quisermos passar todos os valores do enum para a nossa função de teste, precisamos anotar a nossa função de teste com a anotação @EnumSource e especificar a classe do enum cujos valores serão passados para a função. Depois de fazermos isso, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource

@Tag("unitTest")
@DisplayName("@EnumSource example")
class EnumSourceExampleTest {

    @DisplayName("Should pass all enum values as function parameters")
    @ParameterizedTest(name = "{index} => pet=''{0}''")
    @EnumSource(Pet::class)
    fun shouldPassNotNullEnumValuesAsFunctionParameters(pet: Pet) {
        assertThat(pet).isNotNull()
    }
}

Se quisermos especificar apenas determinados valores do enum que devem ser passados para a nossa função de teste, devemos configurar o valor do atributo names da anotação @EnumSource. Vamos garantir que apenas o valor Pet.CAT seja passado para a nossa função de teste.

Depois de especificarmos o valor do enum utilizado, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource

@Tag("unitTest")
@DisplayName("@EnumSource example")
class EnumSourceExampleTest {

    @DisplayName("Should pass Pet.CAT as a function parameter")
    @ParameterizedTest(name = "{index} => pet=''{0}''")
    @EnumSource(value = Pet::class, names = ["CAT"])
    fun shouldPassSpecifiedValueAsFunctionParameter(pet: Pet) {
        assertThat(pet).isEqualTo(Pet.CAT)
    }
}

Leitura Adicional:

A seguir, descobriremos como podemos passar múltiplos parâmetros para a nossa função de teste.

Utilizando a Anotação @CsvSource

Se os nossos dados de teste forem utilizados por apenas um teste parametrizado, podemos configurar nossos dados de teste utilizando a anotação @CsvSource. Quando adicionamos esta anotação a uma função de teste, configuramos os dados de teste usando um array de objetos String. Cada string contém uma lista separada por vírgulas que define os parâmetros de função daquela invocação do nosso teste.

Vamos configurar os parâmetros de função que são passados para a função sum(). Depois de fazermos isso, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource

@Tag("unitTest")
@DisplayName("@CsvSource example")
internal class CsvSourceExampleTest {

    @DisplayName("Use the parameters provided by the @CsvSource annotation")
    @ParameterizedTest(name = "{index} => a={0}, b={1}, sum={2}")
    @CsvSource("1, 1, 2", "2, 3, 5")
    fun sum(a: Int, b: Int, sum: Int) {
        assertThat(a + b).isEqualByComparingTo(sum)
    }
}

Leitura Adicional:

Embora isso pareça bastante limpo, existem duas situações nas quais utilizar a anotação @CsvSource não faz sentido:

  • Temos tantos dados de teste que não podemos adicioná-los diretamente à nossa classe de teste porque ela se tornaria ilegível.
  • Os mesmos dados de teste são utilizados por múltiplas funções de teste.

Vamos avançar e descobrir como resolvemos esses dois problemas carregando os nossos dados de teste a partir de um arquivo CSV.

Utilizando a Anotação @CsvFileSource

Podemos carregar nossos dados de teste a partir de um arquivo CSV seguindo estes passos:

Primeiro, precisamos criar um arquivo CSV que contenha os nossos dados de teste e colocá-lo no classpath. Ao adicionarmos nossos dados de teste ao arquivo CSV criado, devemos seguir estas regras:

  • Uma linha deve conter todos os parâmetros de função de uma única invocação.
  • Os valores encontrados em cada linha devem seguir a mesma ordem que os parâmetros da nossa função de teste.

O arquivo test-data.csv configura os dados de teste que são passados para a nossa função de teste. Este arquivo encontra-se no diretório src/test/resources, e o seu conteúdo é o seguinte:

1
2
3

1,1,2
2,3,5
3,5,8

Segundo, precisamos anotar a nossa função de teste com a anotação @CsvFileSource e configurar a localização do nosso arquivo CSV. Depois de fazermos isso, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvFileSource

@Tag("unitTest")
@DisplayName("@CsvFileSource example")
internal class CsvFileSourceExampleTest {

    @DisplayName("Use the parameters provided by the test-data.csv file")
    @ParameterizedTest(name = "{index} => a={0}, b={1}, sum={2}")
    @CsvFileSource(resources = ["/test-data.csv"])
    fun sum(a: Int, b: Int, sum: Int) {
        assertThat(a + b).isEqualByComparingTo(sum)
    }
}

Leitura Adicional:

A seguir, aprenderemos a fornecer os nossos dados de teste utilizando uma função de fábrica (factory function).

Utilizando a Anotação @MethodSource

Se quisermos fornecer os nossos dados de teste utilizando uma função de fábrica, precisamos seguir estes passos:

  1. Adicionar uma função static (em Kotlin, dentro de um companion object anotada com @JvmStatic) à nossa classe de teste. Esta função retorna um Stream de objetos Arguments e não recebe nenhum parâmetro de função.
  2. Implementar esta função retornando os nossos dados de teste.
  3. Anotar a nossa função de teste com a anotação @MethodSource e configurar o nome da função que retorna os nossos dados de teste.

Depois de implementarmos a nossa função provedora de argumentos, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.Arguments
import org.junit.jupiter.params.provider.MethodSource
import java.util.stream.Stream

@Tag("unitTest")
@DisplayName("@MethodSource example")
class MethodSourceExampleTest {

    companion object {

        @JvmStatic
        private fun sumProvider(): Stream<Arguments> {
            return Stream.of(
                Arguments.of(1, 1, 2),
                Arguments.of(2, 3, 5)
            )
        }
    }

    @DisplayName("Use the parameters provided by the sumProvider() function")
    @ParameterizedTest(name = "{index} => a={0}, b={1}, sum={2}")
    @MethodSource("sumProvider")
    fun sum(a: Int, b: Int, sum: Int) {
        assertThat(a + b).isEqualByComparingTo(sum)
    }
}

Nota:

Há cinco pontos importantes que vale destacar:

  • A função provedora de argumentos deve retornar um Stream, Iterable, Iterator ou um array de argumentos.
  • A função provedora de argumentos também pode retornar streams de tipos primitivos (IntStream, LongStream, DoubleStream).
  • Os argumentos retornados devem seguir a mesma ordem que os parâmetros da nossa função de teste.
  • A função provedora de argumentos não deve receber nenhum parâmetro de função.
  • Se utilizarmos a configuração padrão de ciclo de vida do JUnit (TestInstance.Lifecycle.PER_METHOD), a função provedora de argumentos precisa ser static (@JvmStatic no companion object). Caso a classe de teste esteja anotada com @TestInstance(TestInstance.Lifecycle.PER_CLASS), a função provedora pode ser um método regular da própria classe de teste sem necessidade de companion object ou @JvmStatic.

Leitura Adicional:

Vamos avançar e descobrir como podemos implementar uma classe ArgumentsProvider customizada.

Utilizando a Anotação @ArgumentsSource

Se precisarmos de flexibilidade máxima (por exemplo, para reutilizar provedores de argumentos complexos entre diversas classes de teste), podemos utilizar um ArgumentsProvider customizado seguindo estes passos:

Primeiro, precisamos escrever uma classe ArgumentsProvider customizada seguindo estes passos:

  1. Criar uma classe que implemente a interface ArgumentsProvider.
  2. Implementar a função provideArguments() retornando os nossos dados de teste. Lembre-se de que os dados de teste retornados devem seguir a mesma ordem que os parâmetros da nossa função de teste.

Depois de criarmos uma classe ArgumentsProvider customizada, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.Arguments
import org.junit.jupiter.params.provider.ArgumentsProvider
import java.util.stream.Stream

@Tag("unitTest")
@DisplayName("@ArgumentsSource example")
class ArgumentsSourceExampleTest {

    @DisplayName("Should use the provided function parameters")
    @ParameterizedTest(name = "{index} => a={0}, b={1}, sum={2}")
    fun sum(a: Int, b: Int, sum: Int) {
        assertThat(a + b).isEqualByComparingTo(sum)
    }

    internal class CustomArgumentProvider : ArgumentsProvider {

        @Throws(Exception::class)
        override fun provideArguments(context: ExtensionContext): Stream<out Arguments> {
            return Stream.of(
                Arguments.of(1, 1, 2),
                Arguments.of(2, 3, 5)
            )
        }
    }
}

Nota:

A propósito, se a nossa classe ArgumentsProvider for utilizada por múltiplas classes de teste, não devemos declará-la como uma classe interna (nested class). Utilizamos uma classe aninhada aqui apenas para fins de exemplo.

Segundo, precisamos configurar o ArgumentsProvider utilizado anotando a nossa função de teste com a anotação @ArgumentsSource. Depois de fazermos isso, o código-fonte da nossa classe de teste fica da seguinte forma:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.Arguments
import org.junit.jupiter.params.provider.ArgumentsProvider
import org.junit.jupiter.params.provider.ArgumentsSource
import java.util.stream.Stream

@Tag("unitTest")
@DisplayName("@ArgumentsSource example")
class ArgumentsSourceExampleTest {

    @DisplayName("Should use the provided function parameters")
    @ParameterizedTest(name = "{index} => a={0}, b={1}, sum={2}")
    @ArgumentsSource(CustomArgumentProvider::class)
    fun sum(a: Int, b: Int, sum: Int) {
        assertThat(a + b).isEqualByComparingTo(sum)
    }

    internal class CustomArgumentProvider : ArgumentsProvider {

        @Throws(Exception::class)
        override fun provideArguments(context: ExtensionContext): Stream<out Arguments> {
            return Stream.of(
                Arguments.of(1, 1, 2),
                Arguments.of(2, 3, 5)
            )
        }
    }
}

Leitura Adicional:

Agora sabemos como obter as dependências necessárias e escrever testes parametrizados com JUnit 6 e Kotlin. Vamos resumir o que aprendemos neste webinar.

Resumo

Este webinar nos ensinou quatro coisas fundamentais:

  • Antes de podermos escrever testes parametrizados com JUnit 6 e Kotlin, precisamos garantir que a dependência junit-jupiter-params esteja declarada no nosso script de build.
  • Devemos anotar a nossa função de teste parametrizada com a anotação @ParameterizedTest.
  • Podemos customizar o nome de exibição de cada invocação do método definindo o valor do atributo name da anotação @ParameterizedTest.
  • Ao configurarmos os nossos dados de teste, eles devem sempre seguir a mesma ordem que os parâmetros da nossa função de teste.