junit vs testng what are differences
Uma comparação abrangente entre os frameworks JUnit Vs TestNG. Inclui comparação de anotações e comparação de recursos com exemplos:
No tutorial anterior, aprendemos a anotação DisplayName e a execução de teste condicional com base em diferentes critérios, como versão do JRE, variáveis ambientais, etc. Também abordamos algumas questões importantes sobre o tópico.
Como temos aprendido continuamente sobre o JUnit nos tutoriais anteriores, este funcionará como um descanso para o nosso público, pois por um tempo mudaremos nosso foco de JUnit como uma agenda única para a comparação entre JUnit vs TestNG.
=> Confira o Guia de treinamento JUnit perfeito aqui.
O que você aprenderá:
- JUnit Vs TestNG: uma comparação
- Conclusão
JUnit Vs TestNG: uma comparação
| Características | JUnit | TestNG |
|---|---|---|
| Tempo limite para testes | sim | sim |
| Estrutura de código aberto | sim JUnit é uma estrutura de código aberto | sim TestNG é uma estrutura de código aberto |
| Amigo do usuário | JUnit é distribuído em diferentes módulos, por exemplo: ? Para parametrização, você pode precisar do JUnit Jupiter. ? Isso torna o JUnit um pouco complicado de usar em comparação com o TestNG | Todos os recursos do TestNG vêm em um módulo. Isso torna o TestNG mais amigável. |
| Suporte IDE principal ( Exemplo: Eclipse, IntelliJ) | sim Ambos suportam a maior parte do IDE igualmente | sim Ambos suportam a maior parte do IDE igualmente |
| Implementação de Anotações | sim JUnit funciona em anotações com pequenas variações para diferentes recursos | sim TestNG funciona em anotações com pequenas variações para diferentes recursos |
| Implementação de Asserções | sim JUnit fornece afirmações suficientes para validar os resultados esperados e reais com algumas variações para afirmações no TestNG | sim TestNG também suporta uma lista enorme de afirmações para comparação de resultados esperados e reais. Além disso, TestNG fornece dois mecanismos para asserções - Soft Assertion e Hard Assertion |
| Exceções | sim JUnit fornece o recurso para teste de exceção com uma ligeira variação para TestNG | sim TestNG também fornece o recurso de teste de exceção |
| Testes parametrizados | sim JUnit suporta testes parametrizados | sim TestNG também suporta testes parametrizados |
| Suíte de teste | sim JUnit suporta o uso de suítes de teste | sim TestNG também oferece suporte a Test Suite. |
| Teste de Dependência | Não JUnit não suporta o recurso de teste de dependência | sim Este é um recurso avançado no TestNG sobre JUnit. Com este recurso, um método pode ser tornado dependente de outro, de modo que o método seja executado apenas depois que o método dependente for executado e passar, caso contrário, o teste dependente não será executado. |
| Execução de teste paralela | Não A execução paralela não está disponível no JUnit | sim TestNG oferece suporte à execução paralela de testes, mas JUnit não. Existe um xml TestNG onde a execução paralela pode ser definida |
| Integração Maven | sim Ambas as ferramentas suportam integração Maven | sim Ambas as ferramentas suportam integração Maven |
| Implementações de Suposições | sim Suposições são usadas para pular testes com base em certas suposições ou condições e isso é aplicável apenas no JUnit. | Não TestNG não suporta suposições |
| Ordem de execução do teste | sim O Junit oferece suporte à ordem de execução do teste. | sim TestNG suporta a ordem de execução do teste |
| Implementação de ouvintes | sim JUnit oferece suporte a ouvintes não por meio de anotações, mas por meio da API de ouvintes. | sim TestNG oferece suporte a ouvintes por meio de anotações. |
| Ignorar testes | sim Ambos oferecem suporte à desativação de testes, mas JUnit oferece suporte à desativação de testes para execução com base em condições diferentes | sim Ambos suportam a desativação de testes |
| Comunicando | sim JUnit deve ser integrado ao maven para gerar relatórios HTML | sim TestNG tem seus relatórios HTML embutidos. Ele também pode ser integrado ao maven ou a bibliotecas externas de relatórios, como relatórios ATU ou relatórios Extent |
Comparação de anotações
TestNG e JUnit são estruturas de teste de unidade do mundo Java. Ambos implementam recursos muito próximos e semelhantes. Nesta seção, veremos algumas semelhanças na implementação de alguns recursos, enquanto também veríamos alguns outros recursos que são implementados de maneira diferente no JUnit e no TestNG.
# 1) Anotação do método de teste
Não há diferença na maneira como especificamos um método como método de teste em JUnit e TestNG.
| JUnit 5 | TestNG |
|---|---|
| @Teste | @Teste |
# 2) Anotação relacionada à suíte
- Um método com a anotação @BeforeSuite é executado uma vez antes da execução do conjunto de testes atual.
- Esta anotação é aplicável apenas no TestNG.
| JUnit 5 | TestNG |
|---|---|
| Não aplicável | @BeforeSuite |
# 3) Anotação para um método antes da aula
Esta é a anotação para o método a ser executado uma vez, antes que o primeiro método de teste na classe seja executado.
| JUnit 5 | TestNG |
|---|---|
| @Antes de tudo | @Antes da aula |
# 4) Anotação para um método antes do teste
- Esta anotação é executada uma vez antes dos métodos declarados dentro da tag de testng.xml.
- Esta anotação está disponível apenas para TestNG.
| JUnit 5 | TestNG |
|---|---|
| Não aplicável | @BeforeTest |
# 5) Anotação para o método a ser executado antes de cada método com chamadas @Test
| JUnit 5 | TestNG |
|---|---|
| @BeforeEach | @BeforeMethod |
# 6) Anotação para o método a ser executado após cada método com chamadas de @Test
| JUnit 5 | TestNG |
|---|---|
| @Após cada | @AfterMethod |
# 7) Anotação para o método após o teste
- Essa anotação é executada uma vez após os métodos declarados dentro da tag de testng.xml.
- Esta anotação está disponível apenas para TestNG.
| JUnit 5 | TestNG |
|---|---|
| Não aplicável | @AfterTest |
# 8) Anotação para o método após a aula
Esta é a anotação para o método a ser executado uma vez após a execução do último método de teste na classe.
| JUnit 5 | TestNG |
|---|---|
| @Depois de tudo | @Depois da aula |
# 9) Anotação para desativar a execução do método de teste.
- O JUnit 5 fornece uma anotação para desabilitar a execução de um teste específico.
- TestNG fornece um atributo para @Test, ou seja, ‘ativado’ com o valor booleano que decide se a execução do método seria desativada ou ativada
| JUnit 5 | TestNG |
|---|---|
| @ignorar | @Test (ativado = falso) |
Referir-se Tutorial 7 Pulando Execução para entender como desabilitar testes em JUnit4 vs JUnit 5
# 10) Anotação de tempo limite
A anotação é a mesma para JUnit 5 e TestNG
| JUnit 5 | TestNG |
|---|---|
| @Test (tempo limite = 2000) | @Test (tempo limite = 2000) |
# 11) Atributo de exceção esperada
- A classe de exceção afirma que, quando o teste é executado, a exceção da classe fornecida é lançada.
- Isso é compatível com JUnit e TestNG com variação na forma como ambos são declarados.
| JUnit 5 | TestNG | |
|---|---|---|
| @Test (esperado = NullPointerException.class) | @Test (expectedException = NullPointerException.class) |
# 12) Anotação relacionada ao pacote
- Um método com a anotação @AfterSuite é executado uma vez após a execução do conjunto de testes atual.
- Esta anotação é aplicável apenas no TestNG.
| JUnit 5 | TestNG |
|---|---|
| Não aplicável | @AfterSuite |
# 13) Anotação relacionada ao grupo
- A anotação está disponível apenas no TestNG.
- O método com a anotação @BeforeGroups é executado antes que os métodos de teste pertencentes a um determinado grupo sejam executados.
| JUnit 5 | TestNG | |
|---|---|---|
| Não aplicável | @BeforeGroups |
- A anotação está disponível apenas no TestNG.
- O método com a anotação @BeforeGroups é executado após a execução dos métodos de teste pertencentes a um determinado grupo.
| JUnit 5 | TestNG |
|---|---|
| Não aplicável | @AfterGroups |
# 14) Notas relacionadas à ordem de execução
Tanto o JUnit quanto o TestNG suportam a configuração explícita da ordem dos testes para execução. Em outras palavras, definindo a prioridade para casos de teste.
- JUnit 5 tem a anotação @TestMethodOrder () com a classe interna do pacote MethodOrderer - Alphanumeric.class ou OrderAnnotation.class ou Random.class como um parâmetro de entrada para a anotação.
Referir-se Tutorial 9 - Ordem de execução de teste Junit para obter mais detalhes sobre como definir a ordem de execução do teste no JUnit.
- TestNG inclui o atributo ‘prioridade’ para a anotação @Test, que aceita um valor numérico.
| JUnit 5 | TestNG |
|---|---|
| @TestMethodOrder (Alphanumeric.class) | @Test (prioridade = 1) |
Programa básico para TestNG e JUnit 4
# 1) Código TestNG
package newtest.com; import org.testng.annotations.Test; import org.testng.annotations.BeforeMethod; import org.testng.annotations.AfterMethod; import org.testng.annotations.DataProvider; import org.testng.annotations.BeforeClass; import org.testng.annotations.AfterClass; import org.testng.annotations.BeforeTest; import org.testng.annotations.AfterTest; import org.testng.annotations.BeforeSuite; import org.testng.annotations.AfterSuite; public class NewTestng { @Test(dataProvider = 'dp') public void f(Integer n, String s) { System.out.println(' * * * * * * *Parameterized method * * * * * * * * * '); System.out.println('Integer '+n+' String '+s); System.out.println(' * * * * * * * * * * * * * * * * '); } @BeforeMethod public void beforeMethod() { System.out.println('Before Method'); } @AfterMethod public void afterMethod() { System.out.println('After Method'); } @DataProvider public Object()() dp() { return new Object()() { new Object() { 1, 'a' }, new Object() { 2, 'b'}, }; } @BeforeClass public void beforeClass() { System.out.println('Before Class'); } @AfterClass public void afterClass() { System.out.println('After Class'); } @BeforeTest public void beforeTest() { System.out.println('Before Test'); } @AfterTest public void afterTest() { System.out.println('After Test'); } @BeforeSuite public void beforeSuite() { System.out.println('Before Suite'); } @AfterSuite public void afterSuite() { System.out.println('After Suite'); } } Resultado esperado:
# 2) Código JUnit 4
package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.BeforeClass; import org.junit.AfterClass; public class JunitTest { @Parameterized.Parameters public static Object()() data() { return new Object(3)(0); } @BeforeClass public static void beforeClass() { System.out.println('Before Class'; } @Before public void beforeMethod() { System.out.println('Before Method'); } @Test public void f() { System.out.println(' * * * * * * *test * * * * * * * * * '); int n=10; System.out.println('Integer '+n); System.out.println(' * * * * * * * * * * * * * * * * '); } @After public void afterMethod() { System.out.println('After Method'); } @AfterClass public static void afterClass() { System.out.println('After Class'); } } Resultado esperado:
JUnit 5 vs TestNG: diferença de recursos com exemplos
# 1) Suite de Teste
- O conjunto de testes é uma coleção de testes, o que significa que estamos agrupando vários casos de teste de várias classes.
- A abordagem que o TestNG usa é diferente e poderosa em comparação com a do JUnit.
Conjunto de testes no JUnit 5
Vejamos rapidamente como o JUnit 5 aplica o conjunto de testes.
Referir-se Tutorial 8 -JUnit Test Suites e filtragem Casos de teste para uma melhor compreensão da implementação do conjunto de testes no JUnit 4 e no JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { } Conjunto de testes no TestNG
TestNG usa o XML como o modelo abaixo para envolver todas as classes de teste conectadas logicamente
# 2) Teste parametrizado
Ambos TestNG e JUnit permitem parametrização de testes que nada mais é do que executar os mesmos testes com variações de dados.
Teste parametrizado em JUnit 4
@RunWith(value=Parameterized.class) public class JUnitclass{ int n; public JUnitclass (int num){ this.n=num; } @Parameters public static Iterable data(){ Object()() objectArray =new Object()() {{1},{2},{3}}; returnArrays.asList(objectArray); } @Test public void Junittst(){ System.out.println(“Multiples of 2 are :”+ 2*n); } } Teste parametrizado em TestNG
Existem 2 maneiras de como você pode usar a parametrização no TestNG
- @Parameters e passando por TestNG XML
- Anotação @DataProvider
a) @Parameters e passando por TestNG XML
public class testins{ @Test @Parameters(value=”env_pd”) public void paramEnv(str env_pd){ If(env_pd=”QA”){ url=”definetest.com” } else if(env_pd=”accpt”){ url=”defineacc.com” }}} XML para o mesmo
b) DataProvider
A anotação DataProvider sempre retorna Object () () que é a matriz de objetos.
@DataProvider(name='state') public Object()() getDataFromDataprovider(){ return new Object()() { { 'Maharashtra', 'Pune' }, { 'Karnataka', 'Bangalore' }, { 'Kerala', 'Trivandrum' } }; @Test(dataProvider=”state”) public void paramMethd(str stateName, str cityName){ System.out.println(stateName+” ”+cityName); } # 3) Tempo limite
Se um determinado teste não for concluído no tempo estipulado, ele terá um tempo limite. Em outro, o Thread é interrompido.
o que é um bom downloader de mp3 para android
Tempo limite em JUnit
Existem diferentes abordagens para a implementação do Timeout no JUnit. Esses são:
- Usando o tempo limite normal com milissegundos específicos
- Usando o tempo limite com a asserção
- Usando o tempo limite global
Teremos um tutorial detalhado com foco no tempo limite para JUnit 4 e JUnit 5.
Abaixo está o snippet que mostra o uso do Timeout normal no JUnit 5:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } O tempo limite de teste acima após 5 segundos.
Tempo limite em TestNG
O TestNG também usa a maneira simples de implementação de tempo limite:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } # 4) Teste de exceção
O teste de exceção garante que, quando houver essa exceção predefinida lançada, ela seja normalmente capturada e notificada nos logs.
Teste de exceção em JUnit 4
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } Haverá um tutorial separado cobrindo as exceções para JUnit 4 e 5 em detalhes.
Teste de exceção em TestNG
Há uma ligeira mudança na declaração do teste de exceção no TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } # 5) Desativar teste
Ambos TestNG e JUnit permitem desabilitar um teste para execução.
Teste Desabilitado em JUnit 5
Anotação @Disabled quando usada no início da classe, todos os testes dentro da classe são ignorados para execução. A anotação, quando usada sobre um método @Test específico, esse caso de teste específico é desabilitado para execução.
o que é um bom downloader de música para Android
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram { Teste desativado em TestNG
TestNG permite que um teste desabilite a execução de um teste quando o atributo “habilitado” da anotação @Test é definido como falso e é habilitado quando o atributo é definido como verdadeiro. Se todos os testes em uma classe tiverem que ser ativados, marque explicitamente enabled = true para cada método @Test.
Abaixo está o trecho de código que demonstra a omissão de um teste.
@Test(enabled=false) public void f_validate(){ // let us skip this function} # 6) Testes de Grupo
Houve declarações contraditórias em vários sites e fóruns onde as pessoas mencionaram que o JUnit nunca apoiou o agrupamento de testes com o nome de grupo específico.
Anotações @BeforeGroups e @AfterGroups vêm apenas com TestNG, entretanto o agrupamento é permitido no JUnit 4, bem como no JUnit 5. Aqui iremos demonstrar rapidamente o uso de testes de grupo no JUnit 5. Os testes de grupo são referidos como categorias no JUnit 4 e Tags no JUnit 5.
Você pode se referir a Tutorial 8 - Conjuntos de testes JUnit e testes de filtragem para obter detalhes sobre o uso em JUnit.
Testes de grupo em JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){ Snippet de código de JUnit5TestSuite.java:
O código abaixo inclui o grupo com o nome “Regression” e exclui o grupo “SmokeTest” que infere que junitMethod1 () será executado, no entanto junitMethod2 () é excluído.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { } Testes de grupo em TestNG
Se o snippet acima tiver que ser interpretado no TestNG, a seguir está o código para o mesmo:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){} O XML do TestNG é o seguinte:
Aqui, os métodos de grupo de regressão são incluídos no corredor, enquanto o resto dos grupos, incluindo SmokeTest, são excluídos.
# 7) Testes paralelos
Este é o recurso que está disponível apenas com TestNG. Normalmente, os casos de teste são tipos de threads que são chamados um após o outro. No entanto, se você deseja economizar no tempo de execução, pode controlar isso no TestNG definindo os testes a serem executados em paralelo e fornecendo o número de threads que precisam ser executados de uma vez.
Demonstraremos resumidamente o uso de depende de métodos aqui e não discutiremos depende de grupos.
O teste dependente em outro método é definido por meio do XML TestNG da seguinte maneira:
# 8) Testes Dependentes
Os testes dependentes são recursos avançados disponíveis apenas com TestNG. As dependências podem ser em um teste ou em um grupo.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); } No programa acima, como mytest2 depende de mytest1, primeiro mytest1 é executado e, em seguida, mytest2 é executado. Se mytest1 falhar, então mytest2 não será invocado. É assim que os casos de teste dependentes podem ser predefinidos para controlar um fluxo de trabalho específico que você deseja executar.
# 9) Ouvintes
Os ouvintes ouvem todos os eventos que ocorrem nos testes. Os ouvintes são suportados tanto no JUnit quanto no TestNG. Então, se você deseja realizar certas tarefas ou mostrar uma mensagem específica no log antes do início do teste, depois que o teste terminar, quando o teste for ignorado, quando o teste for aprovado ou reprovado, temos essas funções de Listener que nos permitem fazem isto
JUnit usa a classe Listener e TestNG usa uma interface Listener. TestNG escreve uma classe de ouvinte que define os métodos da interface de Ouvinte e a segunda etapa é chamar esse nome de classe de Ouvinte usando a anotação @Listeners na classe principal.
JUnit também herda os métodos da classe pai Listener após a qual uma classe executora Listener é definida para aplicar as funções de listener em uma ou mais classes principais.
Ouvinte em TestNG
Existe uma interface ITestListener a partir da qual TestNG é implementado.
Abaixo estão os métodos que precisam ser definidos quando ITestListener é implementado -
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- OnStart ()
- OnFinish ()
Abaixo está o snippet de código que demonstra onTestStart () e onTestSuccess ()
import org.testng.ITestListener; import org.testng.ITestResult; public class TestListener implements ITestListener { @Override public void onTestStart(ITestResult result) { System.out.println('Execution started: '+result.getName()); } @Override public void onTestSuccess(ITestResult result) { System.out.println('Test Passed '+result.getName()); } Chame essa classe de ouvinte em sua classe principal, conforme mostrado abaixo, usando a anotação @Listener:
import org.testng.annotations.Listeners; import org.testng.annotations.Test; @Listeners(com.javatpoint.Listener.class) public class MymainClass { @Test public void sum() { Ouvinte no JUnit 5
RunListener é a classe que precisa ser estendida por sua classe de listener para definir as funções de Listener.
Temos os seguintes métodos para JUnit:
- testRunStarted
- testRunFinished
- testFailure
- testado
import org.junit.runner.notification.Failure; import org.junit.runner.notification.RunListener; public class Mylistenerclass extends RunListener { public void testRunStarted(Description desc) throws java.lang.Exception { System.out.println('Execution started' + desc.getMethodName()); } public void testRunFinished(Description desc) throws java.lang.Exception { System.out.println('Execution finished' + desc.getMethodName()); } Deve haver uma classe de execução de ouvinte criada para invocar a classe de ouvinte acima.
Você pode aplicar a classe ouvinte Mylistener a várias classes com métodos de teste.
public class ListenerRunner { public static void main(String() args) { JUnitCore runme = new JUnitCore(); runme.addListener(new ListenerRunner()); runner.run(FirstClass.class, SecondClass.class); } Conclusão
Neste tutorial JUnit Vs TestNG, comparamos as estruturas TestNG e JUnit. Aprendemos os recursos comuns com suporte em ambas as estruturas, bem como recursos adicionais com suporte apenas no TestNG. Aparentemente, existem alguns recursos extras apenas no TestNG, como execução paralela e testes de dependência. A maioria dos recursos suportados pelo TestNG também está disponível no JUnit.
Há pequenos desvios em termos de sintaxe e terminologias em JUnit vs TestNG para os recursos comuns. Aqueles que minaram a força do JUnit sobre o TestNG teriam percebido até agora, ou seja, o JUnit também é uma das poderosas estruturas de automação.
Voltaremos com muitos outros aspectos interessantes do JUnit. Siga os próximos tutoriais !!!
Leitura recomendada
- Tutorial JUnit para iniciantes - O que é teste JUnit
- Lista de anotações JUnit: JUnit 4 Vs JUnit 5
- Como usar a anotação JUnit 5 @RepeatedTest com exemplos
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Instalação do TestNG, programa básico e relatórios
- Anotações e ouvintes do TestNG
- Tutorial TestNG: Introdução ao Framework TestNG
- Asserções no Selenium usando os frameworks Junit e TestNG