TestNG vs JUnit – Diferença entre eles
Thomas Hamilton
Principal diferença entre TestNG JUnit
- TestNG é um Javaestrutura baseada em, enquanto JUnit é uma estrutura de teste de unidade de código aberto para JAVA.
- Comparando TestNG Vs JUnit, TestNG anotações são mais fáceis de usar e entender do que JUnit.
- TestNG nos permite criar testes paralelos, enquanto JUnit não oferece suporte à execução de testes paralelos.
- In TestNG, Os casos de teste podem ser agrupados, enquanto em JUnit, Não é possível agrupar testes.
O que é o TestNG?
TestNG é uma estrutura de testes de automação em que NG significa “Próxima Geração”. TestNG é inspirado por JUnit que usa as anotações (@). TestNG supera as desvantagens de JUnit e foi projetado para fazer teste de ponta a ponta fácil.
utilização TestNG, você pode gerar um relatório adequado e saber facilmente quantos casos de teste foram aprovados, reprovados e ignorados. Você pode executar os casos de teste com falha separadamente.
O que é Junit?
JUnit é uma unidade de código aberto Ensaios Estrutura para JAVA. É útil para Java Desenvolvedores para escrever e executar testes repetíveis. Erich Gamma e Kent Beck inicialmente o desenvolveram. É uma instância da arquitetura xUnit. Como o nome indica, é usado para Teste de Unidade de um pequeno pedaço de código.
Os desenvolvedores que seguem a metodologia orientada a testes devem escrever e executar o teste de unidade primeiro, antes de qualquer código.
Depois de concluir o código, você deverá executar todos os testes e ele deverá passar. Cada vez que qualquer código é adicionado, você precisa executar novamente todos os casos de teste e garantir que nada esteja quebrado.
Diferenças entre JUnit TestNG
Ambos TestNG JUnit4 é semelhante, exceto por um ou dois recursos. Vamos fazer uma comparação entre os dois para decidir rapidamente qual tecnologia é mais favorável para testes unitários. A tabela abaixo destaca os recursos suportados por ambos:
Anotações
Ambos JUnit TestNG usa anotações e quase todas as anotações são semelhantes.
TestNG usa @BeforeMethod ,@AfterMethod semelhante a @Before ,@After em JUnit4.
Ambos TestNG e Junit4 usa @Test(timeout = 1000) para timeout. Verifique a tabela abaixo para mais detalhes-
| SNA | Descrição | TestNG | JUnit 4 |
|---|---|---|---|
| 1 | Anotação de teste | @Teste | @Teste |
| 2 | Executa antes do primeiro método de teste ser invocado na classe atual | @Antes da aula | @Antes da aula |
| 3 | Executa depois de todos os métodos de teste na classe atual | @Depois da aula | @Depois da aula |
| 4 | Executa antes de cada método de teste | @BeforeMethod | @Antes |
| 5 | Executa após cada método de teste | @AfterMethod | @Depois de |
| 6 | anotação para ignorar um teste | @Test(habilitar=falso) | @ignorar |
| 7 | anotação para exceção | @Test(expectedExceptions = ArithmeticException.class) | @Test(esperado = ArithmeticException.class) |
| 8 | tempo limite | @Teste(tempo limite = 1000) | @Teste(tempo limite = 1000) |
| 9 | Executa antes de todos os testes da suíte | @AntesSuite | não aplicável |
| 10 | Executa após todos os testes na suíte | @AfterSuite | não aplicável |
| 11 | Executa antes de um teste ser executado | @AntesTeste | não aplicável |
| 12 | Executa após a execução de um teste | @DepoisTeste | não aplicável |
| 13 | Executa antes que o primeiro método de teste que pertence a qualquer um desses grupos seja invocado | @BeforeGroups | não aplicável |
| 14 | executado após o último método de teste que pertence a qualquer um dos grupos aqui | @AfterGroups | não aplicável |
Teste de suíte
Suites são usadas para executar vários testes juntos. Suites podem ser criadas usando ambos TestNG JUnit4. No entanto, as suítes são mais poderosas em TestNG pois utiliza métodos muito diferentes para execução de testes. Vamos entendê-lo usando o trecho de código fornecido abaixo:
utilização JUnit4
A classe abaixo descreve o uso do conjunto ao trabalhar com JUnit4:
package guru99.junit;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses({
SuiteTest1.class,
SuiteTest2.class,
})
public class JunitTest {
// This class remains empty,it is used only as a holder for the above annotations
}
utilização TestNG
TestNG usa xml para agrupar todos os testes em um só lugar. O xml abaixo descreve o uso do conjunto ao trabalhar com TestNG:
<!DOCTYPE suite SYSTEM "http://beust.com/testng/testng-1.0.dtd" > <suite name="My test suite"> <test name="testing"> <classes> <class name="com.guru99.SuiteTest1" /> <class name="com.guru99.SuiteTest2" /> </classes> </test> </suite>
Ignorar teste
Usando ambos, podemos pular um teste. Vamos ver usando o exemplo de código fornecido abaixo:
utilização JUnit4
O trecho de código abaixo descreve o uso da anotação @ignore ao trabalhar com JUnit4:
@Ignore
public void method1()
{
System.out.println("Using @Ignore , this execution is ignored");
}
utilização TestNG
O trecho de código abaixo descreve o uso da anotação @Test(enabled=false) ao trabalhar com TestNG:
@Test(enabled=false)
public void TestWithException()
{
System.out.println("Method should be ignored as it's not ready yet");
}
Teste de exceção
O teste de exceção está disponível tanto em TestNG JUnit4. É usado para verificar qual exceção é lançada no teste?
utilização JUnit4
O trecho de código abaixo descreve o uso do teste de exceção ao trabalhar com JUnit4:
@Test(expected = ArithmeticException.class)
public void divideByZero()
{
Int i = 1/0;
}
utilização TestNG
O trecho de código abaixo descreve o uso do teste de exceção ao trabalhar com TestNG:
@Test(expectedExceptions = ArithmeticException.class)
public void divideByZero()
{
Int i = 1/0;
}
Timeout
Este recurso é implementado tanto no TestNg quanto no JUnit4.Timeout é usado para encerrar um teste que leva mais tempo do que o especificado (em milissegundos).
utilização JUnit4
O trecho de código abaixo descreve o uso do teste de tempo limite ao trabalhar com JUnit4:
@Test(timeout = 1000)
public void method1()
{
while (true);
}
utilização TestNG
O trecho de código abaixo descreve o uso do teste de tempo limite ao trabalhar com TestNG:
@Test(timeOut = 1000)
public void method1()
{
while (true);
}
Teste parametrizado
JUnit fornece uma abordagem de teste mais fácil e legível, conhecida como teste parametrizado. Ambos TestNG JUnit suporta testes parametrizados, mas diferem na maneira como definem o valor do parâmetro. Vamos ver isso um por um.
utilização JUnit4
As anotações “@RunWith” e “@Parameter” são usadas para fornecer o valor do parâmetro para o teste de unidade. A anotação @Parameters deve retornar List[] . Este parâmetro será passado para o construtor da classe como um argumento.
@RunWith(value = Parameterized.class)
public class JunitTest{
privateint number;
public JunitTest6(int number)
{
this.number = number;
}
@Parameters
public static Collection<Object[]> data()
{
Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
returnArrays.asList(data);
}
@Test
public void parameterTest()
{
System.out.println("Parameterized Number is : " + number);
}
}
utilização TestNG
In TestNG, arquivo XML ou “@DataProvider” é usado para fornecer um parâmetro para teste.
Aqui a anotação @Parameters declarada no método precisa de um parâmetro para teste. Os dados usados como parâmetro serão fornecidos em TestNGarquivos de configuração XML. Ao fazer isso, podemos reutilizar um único Caso de teste com conjuntos de dados diferentes e podemos obter resultados diferentes.
public class Test1 {
@Test
@Parameters(value="number")
public void parameterTest(int number)
{
System.out.println("Parameterized Number is : " + number);
}
}
Veja abaixo o arquivo xml a ser usado para a classe acima:
<!DOCTYPE suite SYSTEM "http://beust.com/testng/testng-1.0.dtd" >
<suite name="My test suite">
<test name="testing">
<parameter name="number" value="2"/>
<classes>
<class name="com.guru99.Test1" />
</classes>
</test>
</suite>
Resumo
Vimos JUnit4 e TestNG comparação em detalhes. Também vimos que ambos são semelhantes, exceto teste parametrizado e teste de dependência. Em resumo, podemos dizer que, com base na flexibilidade e exigência, podemos escolher qualquer um deles para Teste Unitário.
