Como baixar e usar o JUnit 5 em projetos Java
JUnit é uma das estruturas de teste de unidade mais populares para aplicativos Java. Ele ajuda os desenvolvedores a escrever e executar testes automatizados que verificam a funcionalidade e a qualidade de seu código. JUnit 5 é a versão mais recente do JUnit, que traz muitas novidades e melhorias em relação ao seu antecessor, o JUnit 4. Neste artigo, aprenderemos como baixar e usar o JUnit 5 em projetos Java.
download junit 5 jar
O que é JUnit 5 e por que é útil para projetos Java
JUnit 5 é a próxima geração do JUnit, que visa criar uma base atualizada para testes do lado do desenvolvedor na JVM. Ele oferece suporte a novos recursos no Java 8 e superior, como expressões lambda e fluxos, além de permitir muitos estilos diferentes de teste. O JUnit 5 é composto por vários módulos de três subprojetos: JUnit Platform, JUnit Jupiter e JUnit Vintage.
A plataforma JUnit fornece uma interface comum para iniciar estruturas de teste na JVM. Ele também define a API TestEngine para desenvolver novas estruturas de teste executadas na plataforma. O módulo JUnit Jupiter contém os novos modelos de programação e extensão para escrever testes no JUnit 5. Ele inclui novas anotações, asserções e extensões que tornam os testes mais fáceis e expressivos. O módulo JUnit Vintage fornece suporte de compatibilidade para execução de testes JUnit 3 e JUnit 4 na Plataforma JUnit.
Algumas das principais características e benefícios do JUnit 5 são:
Ele oferece suporte a testes aninhados, testes parametrizados, testes dinâmicos, testes repetidos, modelos de teste e nomes de exibição personalizados.
Ele permite injeção de dependência para construtores e métodos, bem como gerenciamento de ciclo de vida de instância de teste personalizado.
Ele fornece um poderoso mecanismo de extensão que permite aos desenvolvedores personalizar o comportamento de execução do teste.
Ele oferece suporte à execução de teste condicional com base no sistema operacional, variáveis de ambiente, propriedades do sistema ou condições personalizadas.
Ele suporta marcação e filtragem de testes com base em expressões ou categorias.
Ele oferece suporte à execução de testes paralelos com estratégias configuráveis.
Ele se integra bem com IDEs, ferramentas de construção e outras estruturas de teste.
Como baixar arquivos jar do JUnit 5
Para usar o JUnit 5 em seus projetos Java, você precisa ter o Java instalado em seu PC. Você também precisa baixar os arquivos jar que contêm os módulos do JUnit 5. Aqui estão as etapas para fazer isso:
Como verificar se o Java já está instalado no seu PC
Para verificar se você possui o Java instalado no seu PC, você pode usar o prompt de comando ou terminal. No Windows, pressione Windows+R para abrir a caixa Executar, digite cmd e pressione Enter. No Linux ou Mac OS X, abra uma janela de terminal. Em seguida, digite o seguinte comando e pressione Enter:
java -versão
Se você tiver o Java instalado em seu PC, verá sua versão do Java exibida. Por exemplo:
java versão "1.8.0_301" Java(TM) SE Runtime Environment (build 1.8.0_301-b09) Java HotSpot(TM) Client VM (build 25.301-b09, modo misto)
Se você não tiver o Java instalado no seu PC, verá uma mensagem de erro dizendo que o Java não é reconhecido como um comando interno ou externo. Nesse caso, você precisa baixar e instalar o Java no seu PC. Como baixar e instalar o Java no Windows
Para baixar e instalar o Java no Windows, siga estas etapas:
Vou ao e clique no botão Download para obter a versão mais recente do Java SE.
Na próxima página, aceite o contrato de licença e clique no link do instalador do Windows para a arquitetura do seu sistema (32 bits ou 64 bits).
Salve o arquivo em seu PC e execute-o como administrador.
Siga as instruções na tela para concluir o processo de instalação.
Reinicie o seu PC para aplicar as alterações.
Depois de instalar o Java, você pode verificar se ele está funcionando abrindo um prompt de comando e digitando java -versão de novo. Você deve ver sua versão do Java exibida.
Como usar o wget para baixar arquivos JAR no Linux
Para usar o wget para baixar arquivos JAR no Linux, você pode seguir estas etapas:
Abra uma janela de terminal e navegue até o diretório onde deseja salvar os arquivos JAR.
Digite o seguinte comando e pressione Enter:
wget
Isso fará o download do arquivo JAR independente do console da plataforma JUnit, que contém todos os módulos do JUnit 5 em um único arquivo.
Se você deseja baixar os arquivos JAR individuais para cada módulo do JUnit 5, pode usar os seguintes comandos:
wget wget wget wget wget https ://repo1.maven.org/maven2/org/junit/platform/junit-platform-suite-api/1.8.1/junit-platform-suite-api-1.8.1.jar wget wget https:// repo1.maven.org/maven2/org/junit/jupiter/junit-jupiter-api/5.8.1/junit-jupiter-api-5.8.1.jar wget wget ven.org/maven2/org/junit/jupiter/junit-jupiter-params/5.8.1/junit-jupiter-params-5.8.1.jar wget wget j/opentest4j/0.9/opentest4j-0.9.jar
Como usar o JUnit 5 em projetos Java
Para usar o JUnit 5 em seus projetos Java, você precisa adicionar as dependências do JUnit 5 em sua ferramenta de construção, como Maven ou Gradle, ou em seu IDE, como Eclipse ou IntelliJ IDEA. Você também precisa escrever e executar testes JUnit 5 usando as novas anotações, asserções e extensões fornecidas pelo JUnit 5.
Como adicionar dependências do JUnit 5 no Maven ou Gradle
Se você estiver usando Maven ou Gradle como sua ferramenta de compilação, poderá adicionar as dependências do JUnit 5 em seu arquivo pom.xml ou build.gradle, respectivamente.
Para o Maven, você pode usar a seguinte dependência:
org.junit.jupiter
junit-júpiter
5.8.1
teste
Para Gradle, você pode usar a seguinte dependência:
testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'
Isso incluirá todos os módulos do JUnit 5 em seu projeto. Como alternativa, você pode adicionar os módulos individuais de acordo com suas necessidades.
Como executar testes JUnit 5 em IDEs ou ferramentas de construção
Se você estiver usando um IDE, como Eclipse ou IntelliJ IDEA, poderá executar testes JUnit 5 clicando com o botão direito do mouse na classe ou método de teste e selecionando Run As -> JUnit Test ou Run -> Run With -> JUnit 5, respectivamente. Você também pode usar os atalhos de teclado Ctrl+F11 ou Shift+F10, respectivamente.
Se você estiver usando uma ferramenta de compilação, como Maven ou Gradle, poderá executar testes JUnit 5 usando os seguintes comandos:
teste mvn
teste gradle
Isso executará todos os testes em seu projeto. Você também pode especificar a classe de teste ou o nome do método como um parâmetro para executar um teste específico.
Como escrever testes JUnit 5 usando anotações, asserções e extensões
Para escrever testes JUnit 5, você precisa usar as novas anotações, asserções e extensões fornecidas pelo JUnit 5. Aqui estão alguns exemplos de como usá-los:
Para criar uma classe de teste, você precisa anotá-la com @TestInstance e @TestMethodOrder anotações. O @TestInstance A anotação especifica o ciclo de vida da instância da classe de teste, que pode ser por classe ou por método. O @TestMethodOrder anotação especifica a ordem de execução dos métodos de teste, que pode ser baseada em seus nomes, anotações ou aleatória.
@TestInstance(TestInstance.Lifecycle.PER_CLASS) @TestMethodOrder(MethodOrderer.OrderAnnotation.class) public class CalculatorTest // ...
Para criar um método de teste, você precisa anotá-lo com @Teste anotação. Você também pode usar @Nome de exibição, @Marcação, @Ordem, e @Desabilitado anotações para fornecer um nome personalizado, uma tag, um pedido e uma condição para desabilitar o método de teste, respectivamente.
@Test @DisplayName("Teste de Adição") @Tag("Matemática") @Order(1) public void testAdd() // ...
Para criar uma classe de teste aninhada, você precisa anotá-la com @Nested anotação. Isso permite que você agrupe testes relacionados e compartilhe métodos comuns de configuração e desmontagem.
@Nested @DisplayName("Testes de subtração") class SubtractionTest // ...
Para criar um método de teste parametrizado, você precisa anotá-lo com @ParameterizedTest anotação. Você também precisa fornecer uma fonte de argumentos para o método de teste usando anotações como @ValueSource, @CsvSource, @MethodSource, ou @ArgumentsSource.
(#mensagem) Continue escrevendo o artigo. @ParameterizedTest @DisplayName("Teste de Multiplicação") @CsvSource("2, 3, 6", "4, 5, 20", "6, 7, 42") public void testMultiply(int a, int b, int esperado) // ...
Para criar um método de teste dinâmico, você precisa anotá-lo com @TestFactory anotação. Você também precisa retornar um fluxo de testes dinâmicos usando o Teste Dinâmico aula.
@TestFactory @DisplayName("Teste de Divisão") Transmissão pública testDivide() // ...
Para criar um método de teste repetido, você precisa anotá-lo com @RepeatedTest anotação. Você também precisa fornecer o número de repetições e um nome de exibição opcional.
@RepeatedTest(5) @DisplayName("Teste de raiz quadrada") public void testSqrt() // ...
Para criar um método de modelo de teste, você precisa anotá-lo com @TestTemplate anotação.Você também precisa registrar um ou mais contextos de invocação de modelo de teste usando anotações como @ExtendWith ou @EnabledIf.
@TestTemplate @ExtendWith(MyCustomExtension.class) @DisplayName("Power Test") public void testPow(int base, int expoente, int esperado) // ...
Para criar asserções para seus testes, você precisa usar o Asserções classe fornecida pelo JUnit 5. Ele contém vários métodos para declarar diferentes tipos de condições, como igualdade, nulidade, exceção, tempo limite, etc.
Assertions.assertEquals(esperado, real); Assertions.assertNotNull(objeto); Assertions.assertThrows(Exception.class, () -> throw new Exception();); Assertions.assertTimeout(Duration.ofSeconds(1), () -> Thread.sleep(2000););
Para criar extensões para seus testes, você precisa implementar uma ou mais interfaces de extensão fornecidas pelo JUnit 5. Essas interfaces definem vários pontos do ciclo de vida de execução do teste onde você pode customizar o comportamento. Por exemplo, você pode implementar o BeforeEachCallback, AfterEachCallback, BeforeAllCallback, ou AfterAllCallback interfaces para executar algumas ações antes ou depois de cada ou todos os testes.
public class MyCustomExtension implements BeforeEachCallback @Override public void beforeEach(ExtensionContext context) throws Exception // fazer algo antes de cada teste
Conclusão
Neste artigo, aprendemos como baixar e usar o JUnit 5 em projetos Java. Vimos como verificar se o Java está instalado em nosso PC, como baixar e instalar o Java no Windows e como usar o wget para baixar arquivos JAR no Linux. Também vimos como adicionar dependências do JUnit 5 no Maven ou Gradle, como executar testes do JUnit 5 em IDEs ou ferramentas de compilação e como escrever testes do JUnit 5 usando anotações, asserções e extensões. JUnit 5 é uma estrutura de teste poderosa e flexível que pode nos ajudar a escrever aplicativos Java melhores e mais confiáveis.
Se você quiser saber mais sobre o JUnit 5, pode conferir os seguintes recursos:
, que contém a documentação, guias e exemplos do JUnit 5.
, que contém as últimas notícias e atualizações sobre o JUnit 5.
, que contém o código-fonte e os problemas do JUnit 5.
, que contém tutoriais em vídeo e apresentações sobre o JUnit 5.
, que contém tweets e retweets sobre o JUnit 5.
perguntas frequentes
Quais são as diferenças entre JUnit 4 e JUnit 5?
As principais diferenças entre JUnit 4 e JUnit 5 são:
O JUnit 4 é baseado em um único módulo, enquanto o JUnit 5 é baseado em vários módulos de três subprojetos.
JUnit 4 usa anotações do org.junit pacote, enquanto o JUnit 5 usa anotações do org.junit.jupiter.api pacote.
JUnit 4 suporta apenas um tipo de método de teste: @Teste, enquanto JUnit @TestFactory @DisplayName("Teste Palindrome") Transmissão pública testIsPalindrome() Lista strings = Arrays.asList("carro de corrida", "senhora", "caiaque", "olá", "mundo"); return strings.stream() .map(str -> DynamicTest.dynamicTest(str + " is palindrome", () -> Assertions.assertTrue(isPalindrome(str)))); private boolean isPalindrome(String str) return str.equals(new StringBuilder(str).reverse().toString());
Como posso usar a execução paralela no JUnit 5?
Para usar a execução paralela no JUnit 5, você precisa habilitá-la em seu arquivo de configuração, como junit-platform.properties. Você também precisa especificar o modo de execução paralela e a estratégia para seus testes. O modo de execução paralela determina se uma classe ou método de teste pode ser executado em paralelo com outros. A estratégia de execução paralela determina como os recursos disponíveis são alocados para os testes.Por exemplo, você pode usar a seguinte configuração para habilitar a execução paralela com estratégia de fator dinâmico:
junit.jupiter.execution.parallel.enabled = verdadeiro junit.jupiter.execution.parallel.mode.default = simultâneo junit.jupiter.execution.parallel.mode.classes.default = simultâneo junit.jupiter.execution.parallel.config.strategy = dinâmico junit.jupiter.execution.parallel.config.dynamic.factor = 1
Isso executará todas as classes e métodos de teste em paralelo, usando um número de threads igual ao número de processadores disponíveis multiplicado pelo fator dinâmico.
0517a86e26