what is junit test fixture
Este tutorial explicará quando, por que e como usar o acessório de teste JUnit com exemplos de acessórios de teste JUnit simples para sua fácil compreensão do conceito:
Nós aprenderemos -
- Quando e por que temos a necessidade de usar o Fixture de teste?
- Qual é a abordagem para usá-lo em nosso código para o teste JUnit?
- Alguns exemplos para entender o termo 'Dispositivo de Teste' em cascata paralelamente com uma vantagem inicial nas anotações do ciclo de vida JUnit 4 como @Before, @After, @BeforeClass, @AfterClass e @Test.
=> Verifique TODOS os tutoriais JUnit aqui.
O que você aprenderá:
Dispositivo de teste JUnit
Quando há vários casos de teste em uma classe JUnit, pode haver um ou mais objetos comuns usados por todos os casos de teste. Nesse caso, pode haver funções específicas que podem ser comuns em todos os casos de teste.
Isso não significa que os objetos de teste devem ser compartilhados por todos os casos de teste. A mudança no objeto feita em um teste não precisa ser compartilhada entre todos os testes, pois esses testes são independentes e podem ser executados em uma ordem diferente de acordo com seu conjunto de prioridades.
melhor software de manutenção de sistema para windows 10
A compreensão holística do termo 'dispositivo de teste' é um estado fixo em um código ou um conjunto de etapas fixas em um código que é usado como uma pré-condição e alguns outros conjuntos de etapas que são usados como pós-condição para todos os testes.
Portanto, em outras palavras, estamos identificando aqueles conjuntos de instruções que se repetirão para todos os testes e, portanto, tentamos definir um ambiente fixo para que nossos métodos de teste sejam executados.
O propósito Usar Test Fixture é eliminar a duplicação do código comum para todos os casos de teste.
por que os filmes solares não estão funcionando?
Vamos tentar entender a implementação prática do dispositivo de teste em um teste JUnit.
método setUp ()
- Existem testes que precisam de inicialização de certos objetos (string, integer ou ArrayList ou qualquer objeto para esse assunto). Você pode criar um método public void setUp () em que você pode declarar as variáveis de instância para os objetos comuns. Coloque este método setUp () sob a anotação @Antes . Com a anotação @Before, a estrutura executará o método setUp () antes de cada execução de caso de teste.
- O método setUp () também pode ser usado no caso de você desejar iniciar um navegador com uma URL específica como a primeira etapa para executar um caso de teste que segue o login do aplicativo com credenciais predefinidas.
método tearDown ()
- Se você alocou recursos externos em um teste, deve se lembrar de liberar os recursos também. O método teardown () pode ser adicionado para a limpeza dos objetos após a conclusão da execução do caso de teste. De maneira semelhante ao método setUp (), adicione um método public void teardown () sob @Depois de anotação. A estrutura JUnit garante que, após a execução de cada caso de teste, o método em @After seja executado com certeza. Os objetos usados no teste devem ser definidos como NULL no método teardown () para que o lixo dos testes seja coletado.
- Outro bom candidato para a limpeza dos objetos é matar um navegador em ação após a conclusão do caso de teste e liberar a memória ao destruir os objetos usados.
- Os nomes dos métodos setUp () e tearDown () são apenas nomes definidos pelo usuário. Você pode definir qualquer nome de método que desejar. São apenas as anotações usadas com o método que decidem a sequência de execução dos testes.
Exemplos de acessórios de teste JUnit
Nesta seção, veremos dois exemplos do teste JUnit 4 e tentaremos entender como usar a abordagem de Fixtures de teste em nosso código junto com a sequência de diferentes anotações de ciclo de vida @Before, @After, @BeforeClass, @AfterClass, e @Test.
Claro, haverá um tutorial separado sobre anotações que irá esclarecer o que são e como cada uma das anotações funciona. A partir de agora, vamos nos ater ao entendimento do uso do acessório de teste no código.
Teste JUnit 4 - Exemplo 1
Neste exemplo, teremos os acessórios de teste na classe com três casos de teste. O método setUp () com a anotação @Before e o método tearDown () com a anotação @After.
Código:
package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; public class JUnitProgram { @Before public void setUp() { System.out.println('_______________________________________________________
'); System.out.println('This is the setUp() method that runs before each testcase'); } @Test public void test_JUnit1() { System.out.println('This is the testcase test_JUnit1() in this class'); } @Test public void test_JUnit2() { System.out.println('This is the testcase test_JUnit2() in this class'); } @Test public void test_JUnit3() { System.out.println('This is the testcase test_JUnit3() in this class'); } @After public void tearDown() { System.out.println('This is the tearDown() method that runs after each testcase'); System.out.println('_______________________________________________________
'); } }
A janela de console resultante será como mostrado abaixo:
A janela do console torna óbvio que antes de cada execução de teste, o método setUp () é executado e, após a conclusão de cada teste, o método tearDown () é executado.
Assim, a sequência de execução pela anotação para cada método de teste é:
- @Antes
- @Teste
- @Depois de
Lembre-se de que os testes aqui, foram executados em ordem sequencial, ou seja, test_JUnit1 (), test_JUnit2 (), test_JUnit3 (), não há sequência definida para o teste, portanto, eles podem ser executados em qualquer ordem. Cada teste é isolado do outro teste.
Teste JUnit 4 - Exemplo 2
Aqui, vamos ver rapidamente como podemos ter um método que é executado uma vez pela primeira vez em uma classe e outro método que é executado uma vez depois que todos os testes são executados para a classe.
Código:
package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; public class JUnitProgram { @BeforeClass public static void preClass() { System.out.println('This is the preClass() method that runs one time before the class'); } @Before public void setUp() { System.out.println('_______________________________________________________
'); System.out.println('This is the setUp() method that runs before each testcase'); } @Test public void test_JUnit1() { System.out.println('This is the testcase test_JUnit1() in this class'); } @Test public void test_JUnit2() { System.out.println('This is the testcase test_JUnit2() in this class'); } @Test public void test_JUnit3() { System.out.println('This is the testcase test_JUnit3() in this class'); } @After public void tearDown() { System.out.println('This is the tearDown() method that runs after each testcase'); System.out.println('_______________________________________________________
'); } @AfterClass public static void postClass() { System.out.println('This is the postClass() method that runs one time after the class'); } }
Adicionamos o método preClass () na anotação @BeforeClass. Este método é executado apenas uma vez para uma classe antes de o teste ser executado. Ele é executado antes mesmo de o método em @Before ser executado.
O método postClass () na anotação @AfterClass é executado uma vez no final, quando todos os testes, incluindo o teste em @After, são executados e concluídos.
A sequência da execução do teste é a seguinte:
- @Antes da aula
- @Antes
- @Teste
- @Depois de
- @Depois da aula
Os métodos em @BeforeClass e @AfterClass são comumente compartilhados pela classe, por isso, se os métodos não são declarados como estático então dá um erro de inicialização na execução do teste.
bom lugar para assistir anime online de graça
Veja a captura de tela abaixo, onde não definimos o método preClass () na anotação @BeforeClass como estático e, portanto, o teste apresentou erro na execução.
Você pode ver o resultado mostrando um erro de inicialização que pode ser eliminado marcando o método como estático. O mesmo vale para o método postClass () na anotação @AfterClass.
Conclusão
Tentamos definir um contexto sobre as boas práticas de programação a serem seguidas pela implementação do Fixação de teste abordagem e uma compreensão básica do uso e da sequência de execução para as anotações do ciclo de vida.
Em nosso próximo tutorial, aprenderemos sobre o diferentes maneiras de executar testes JUnit no Eclipse. Portanto, fique atento à série à medida que avançamos com aspectos mais interessantes do JUnit.
=> Verifique aqui para ver os tutoriais de treinamento A-Z de JUnit aqui.
Leitura recomendada
- Testes JUnit: como escrever casos de teste JUnit com exemplos
- Tutorial JUnit para iniciantes - O que é teste JUnit
- Tutorial Python DateTime com exemplos
- Java String contains () Tutorial de método com exemplos
- Tutorial de instrução de uso de C # e método virtual C # com exemplos
- Introdução ao JUnit Framework e seu uso no Selenium Script - Selenium Tutorial # 11
- Selenium Encontrar Elemento por Tutorial de Texto com Exemplos
- Tutorial de comprimento de array Java com exemplos de código