O teste é o processo de verificar a funcionalidade do aplicativo, se está funcionando de acordo com os requisitos.

O teste de unidade é o teste de uma única entidade (classe ou método). O teste de unidade é muito essencial para todas as empresas de software para fornecer um produto de qualidade a seus clientes.

Executar os casos de teste manualmente sem qualquer suporte de ferramenta é conhecido como teste manual.

Obter suporte de ferramenta e executar os casos de teste usando a ferramenta de automação é conhecido como teste de automação.

A seguir estão as desvantagens do teste manual -

• Demorado e tedioso - como os casos de teste são executados por recursos humanos, é muito lento e tedioso.

• Grande investimento em recursos humanos - Como os casos de teste precisam ser executados manualmente, mais testadores são necessários nos testes manuais.

• Menos confiável - o teste manual é menos confiável, pois os testes podem não ser executados com precisão todas as vezes devido a erros humanos.

• Não programável - nenhuma programação pode ser feita para escrever testes sofisticados que buscam informações ocultas.

A seguir estão as vantagens do teste automatizado -

• Fast - A automação executa casos de teste significativamente mais rápido do que recursos humanos.

• Less investment in human resources - Os casos de teste são executados usando a ferramenta de automação, portanto, menos testadores são necessários nos testes de automação.

• More reliable - Os testes de automação executam precisamente a mesma operação sempre que são executados.

• Programmable - Os testadores podem programar testes sofisticados para revelar informações ocultas.

JUnit é uma estrutura de teste de regressão usada por desenvolvedores para implementar testes de unidade em Java e acelerar a velocidade de programação e aumentar a qualidade do código.

A seguir estão os recursos importantes do JUnit -

• É uma estrutura de código aberto.

• Fornece anotações para identificar os métodos de teste.

• Fornece afirmações para testar os resultados esperados.

• Fornece executores de teste para a execução de testes.

• Os testes JUnit podem ser executados automaticamente e eles verificam seus próprios resultados e fornecem feedback imediato.

• Os testes JUnit podem ser organizados em suítes de teste contendo casos de teste e até mesmo outras suítes de teste.

• O JUnit mostra o progresso do teste em uma barra que fica verde se o teste estiver indo bem e fica vermelha quando um teste falha.

Um Caso de Teste de Unidade é uma parte do código que garante que a outra parte do código (método) funcione conforme o esperado. Para alcançar esses resultados desejados rapidamente, é necessário um framework de teste .JUnit é um framework de teste de unidade perfeito para a linguagem de programação java.

Um caso de teste de unidade escrito formal é caracterizado por uma entrada conhecida e por uma saída esperada, que é trabalhada antes da execução do teste. A entrada conhecida deve testar uma pré-condição e a saída esperada deve testar uma pós-condição.

Deve haver pelo menos dois casos de teste de unidade para cada requisito: um teste positivo e um teste negativo. Se um requisito tiver sub-requisitos, cada sub-requisito deve ter pelo menos dois casos de teste como positivos e negativos.

Os testes são escritos antes do código durante o desenvolvimento para ajudar os programadores a escrever o melhor código.

Depurar o código usando system.out.println () levará à verificação manual de toda a saída toda vez que o programa for executado, para garantir que o código esteja executando as operações esperadas. Além disso, a longo prazo, leva menos tempo para codificar métodos JUnit e testá-los em arquivos de classe.

Siga as etapas abaixo -

• Baixe a versão mais recente do JUnit, referida a seguir como junit.zip.

• Descompacte o arquivo de distribuição junit.zip em um diretório conhecido como% JUNIT_HOME%.

• Adicione JUnit ao classpath -

set CLASSPATH=%CLASSPATH%;%JUNIT_HOME%\junit.jar

• Teste a instalação executando os testes de amostra distribuídos com JUnit (os testes de amostra estão localizados diretamente no diretório de instalação, não no arquivo junit.jar). Em seguida, basta digitar -

java org.junit.runner.JUnitCore org.junit.tests.AllTests

• Todos os testes devem passar com uma mensagem "OK". Se os testes não passarem, verifique se junit.jar está no CLASSPATH.

Relatar várias falhas em um único teste geralmente é um sinal de que o teste faz muito e é um teste de unidade muito grande. O JUnit foi projetado para funcionar melhor com uma série de pequenos testes. Ele executa cada teste em uma instância separada da classe de teste. Ele relata falha em cada teste.

O JUnit 3.7 tornou o assert () obsoleto e o substituiu por assertTrue (), que funciona exatamente da mesma maneira. JUnit 4 é compatível com a palavra-chave assert. Se você executar com o switch JVM -ea, as afirmações que falharem serão relatadas pelo JUnit.

A refatoração de componentes J2EE para delegar funcionalidade a outros objetos que não precisam ser executados em um contêiner J2EE melhorará o design e a testabilidade do software. Cactus é uma extensão JUnit de software livre que pode ser usada para testar a unidade do código java do lado do servidor.

O JUnit Framework pode ser facilmente integrado com qualquer um dos seguintes -

• Eclipse
• Ant
• Maven

A estrutura de teste JUnit fornece os seguintes recursos importantes -

• Fixtures
• Suítes de teste
• Corredores de teste
• Classes JUnit

Fixture é um estado fixo de um conjunto de objetos usados ​​como linha de base para a execução de testes. O objetivo de um dispositivo de teste é garantir que haja um ambiente bem conhecido e fixo no qual os testes são executados para que os resultados sejam repetidos. Inclui os seguintes métodos -

• Método setUp () que é executado antes de cada invocação de teste.

• tearDown (), que é executado após cada método de teste.

Conjunto de testes significa agrupar alguns casos de teste de unidade e executá-los juntos. No JUnit, as anotações @RunWith e @Suite são usadas para executar o teste do conjunto.

O executor de teste é usado para executar os casos de teste.

As classes JUnit são classes importantes que são usadas para escrever e testar JUnits. Algumas das classes importantes são -

• Assert - Ele contém um conjunto de métodos de declaração.

• TestCase - Ele contém um caso de teste que define o dispositivo para executar vários testes.

• TestResult - Contém métodos para coletar os resultados da execução de um caso de teste.

• TestSuite - É um composto de testes.

As anotações são como metatags que você pode adicionar ao seu código e aplicá-las a métodos ou na aula. A anotação em JUnit nos fornece informações sobre os métodos de teste, quais métodos serão executados antes e depois dos métodos de teste, quais métodos serão executados antes e depois de todos os métodos, quais métodos ou classes serão ignorados durante a execução.

Siga as etapas abaixo -

• Defina o CLASSPATH

• Invoque o corredor -

java org.junit.runner.JUnitCore

Esta classe fornece um conjunto de métodos de asserção úteis para escrever testes. Apenas as afirmações com falha são registradas.

Um TestResult coleta os resultados da execução de um caso de teste. É uma instância do padrão Parâmetro de coleta. A estrutura de teste distingue entre falhas e erros. Uma falha é antecipada e verificada com afirmações. Erros são problemas imprevistos, como ArrayIndexOutOfBoundsException.

Um TestSuite é um composto de testes. Ele executa uma coleção de casos de teste.

A anotação de teste informa ao JUnit que o método void público ao qual está anexado pode ser executado como um caso de teste.

Vários testes precisam de objetos semelhantes criados antes de serem executados. Anotar um método void público com @Before faz com que esse método seja executado antes de cada método de teste.

Se você alocar recursos externos em um método Before, precisará liberá-los após a execução do teste. Anotar um método void público com @After faz com que esse método seja executado após o método Test.

Anotar um método void estático público com @BeforeClass faz com que ele seja executado uma vez antes de qualquer um dos métodos de teste na classe.

Isso executará o método após a conclusão de todos os testes. Isso pode ser usado para realizar atividades de limpeza.

A seguir estão algumas das utilidades da anotação @Ignore -

Você pode identificar facilmente todas as anotações @Ignore no código-fonte, enquanto os testes não anotados ou comentados não são tão simples de encontrar.

Há casos em que você não pode consertar um código que está falhando, mas ainda quer que o método esteja por perto, justamente para que ele não seja esquecido. Em tais casos, @Ignore faz sentido.

A seguir está como funciona o procedimento de execução JUnit -

• Em primeiro lugar, o método anotado como @BeforeClass é executado apenas uma vez.

• Por último, o método anotado como @AfterClass é executado apenas uma vez.

• O método anotado como @Before é executado para cada caso de teste, mas antes de executar o caso de teste.

• Método anotado como @After é executado para cada caso de teste, mas após a execução do caso de teste.

• Entre o método anotado como @Before e o método anotado como @After cada caso de teste é executado.

Os casos de teste são executados usando a classe JUnitCore. JUnitCore é uma fachada para a execução de testes. Ele suporta a execução de testes JUnit 4, testes JUnit 3.8.x e misturas.

O Junit oferece uma opção útil de Timeout. Se um caso de teste levar mais tempo do que o número especificado de milissegundos, o Junit o marcará automaticamente como com falha. O parâmetro de tempo limite é usado junto com a anotação @Test.

JUnit fornece uma opção de rastrear a manipulação de código de exceção. Você pode testar se um código lança a exceção desejada ou não. O parâmetro esperado é usado junto com a anotação @Test da seguinte maneira - @Test (esperado)

Junit 4 apresentou um novo recurso de testes parametrizados. Os testes parametrizados permitem que o desenvolvedor execute o mesmo teste repetidamente usando valores diferentes.

Existem cinco etapas, que você precisa seguir para criar testes parametrizados -

• Anote a classe de teste com @RunWith (Parameterized.class).

• Crie um método estático público anotado com @Parameters que retorna uma coleção de objetos (como matriz) como conjunto de dados de teste.

• Crie um construtor público que obtenha o que é equivalente a uma "linha" de dados de teste.

• Crie uma variável de instância para cada "coluna" de dados de teste.

• Crie seus casos de teste usando as variáveis ​​de instância como a fonte dos dados de teste.

• O caso de teste será chamado uma vez para cada linha de dados. Vamos ver os testes parametrizados em ação.

Fixtures é um estado fixo de um conjunto de objetos usados ​​como linha de base para testes em execução. O objetivo de um dispositivo de teste é garantir que haja um ambiente bem conhecido e fixo no qual os testes são executados para que os resultados sejam repetidos. Inclui -

• Método setUp () que é executado antes de cada invocação de teste.

• tearDown (), que é executado após cada método de teste.

Compilar uma classe de teste JUnit é como compilar qualquer outra classe Java. A única coisa que você precisa observar é que o arquivo JUnit JAR deve ser incluído no classpath.

Se um método de teste JUnit for declarado como "privado", ele será compilado com sucesso. Mas a execução falhará. Isso ocorre porque o JUnit requer que todos os métodos de teste sejam declarados como "públicos".

Quando um método é declarado como "protegido", ele só pode ser acessado dentro do mesmo pacote em que a classe está definida. Portanto, para testar um método "protegido" de uma classe de destino, defina sua classe de teste no mesmo pacote da classe de destino.

Quando um método é declarado como "privado", ele só pode ser acessado dentro da mesma classe. Portanto, não há como testar um método "privado" de uma classe de destino de qualquer classe de teste. Portanto, você precisa realizar o teste de unidade manualmente. Ou você tem que alterar seu método de "privado" para "protegido".

Se um método de teste JUnit for declarado para retornar "String", a compilação passará bem. Mas a execução falhará. Isso ocorre porque o JUnit requer que todos os métodos de teste sejam declarados para retornar "void".

Sim, você pode testar usando o método main (). Uma vantagem óbvia parece ser que você pode testar a classe na caixa branca. Ou seja, você pode testar o seu interior (métodos privados, por exemplo). Você não pode fazer isso com testes de unidade. Mas principalmente a estrutura de teste testa a interface e o comportamento da perspectiva do usuário.

Não. Não precisamos escrever uma classe de teste independente para cada classe que precisa ser testada. Se houver um pequeno grupo de testes compartilhando um dispositivo de teste comum, você pode mover esses testes para uma nova classe de teste.

O executor de teste mantém referências fortes a todas as instâncias de teste durante a execução do teste. Isso significa que, para uma execução de teste muito longa com muitas instâncias de teste, nenhum dos testes pode ser coletado como lixo até o final de toda a execução do teste. Definir explicitamente um objeto como nulo no método tearDown (), por exemplo, permite que ele seja coletado como lixo antes do final de toda a execução do teste.

Em um teste de unidade, objetos fictícios podem simular o comportamento de objetos reais complexos (não fictícios) e, portanto, são úteis quando um objeto real é impraticável ou impossível de ser incorporado em um teste de unidade.

O estilo de codificação comum para teste com objetos fictícios é -

• Crie instâncias de objetos fictícios.
• Defina o estado e as expectativas nos objetos fictícios.
• Chame o código de domínio com objetos fictícios como parâmetros.
• Verifique a consistência nos objetos fictícios.

A seguir estão as extensões JUnit -

• Cactus

• JWebUnit

• XMLUnit

• MockObject

Cactus é uma estrutura de teste simples para testar a unidade de código java do lado do servidor (Servlets, EJBs, Tag Libs, Filtros). A intenção do Cactus é reduzir o custo de escrever testes para código do lado do servidor. Ele usa JUnit e o estende. O Cactus implementa uma estratégia dentro do contêiner, o que significa que os testes são executados dentro do contêiner.

O ecossistema de cactos é feito de vários componentes -

• O Cactus Framework é o coração do Cactus. É o mecanismo que fornece a API para escrever testes Cactus.

• Módulos de integração Cactus são front-ends e frameworks que fornecem maneiras fáceis de usar o Cactus Framework (scripts Ant, plugin Eclipse, plugin Maven).

WebUnit é uma estrutura de teste baseada em Java para aplicativos da web. Ele envolve estruturas de teste existentes, como HtmlUnit e Selenium, com uma interface de teste simples e unificada para permitir que você teste rapidamente a exatidão de seus aplicativos da web.

JWebUnit fornece uma API Java de alto nível para navegar em um aplicativo da web combinada com um conjunto de asserções para verificar a exatidão do aplicativo. Isso inclui navegação por links, entrada e envio de formulário, validação de conteúdo de tabela e outros recursos típicos de aplicativos da Web de negócios.

Os métodos de navegação simples e asserções prontas para uso permitem a criação de testes mais rápida do que usar apenas JUnit ou HtmlUnit. E se você quiser mudar de HtmlUnit para outros plug-ins, como Selenium (disponível em breve), não há necessidade de reescrever seus testes.

XMLUnit fornece uma única classe de extensão JUnit, XMLTestCase, e um conjunto de classes de suporte.

As classes de suporte permitem que as afirmações sejam feitas sobre -

• As diferenças entre duas partes do XML (por meio das classes Diff e DetailedDiff).

• A validade de uma parte do XML (via classe Validator).

• O resultado da transformação de um pedaço de XML usando XSLT (via classe Transform).

• A avaliação de uma expressão XPath em um pedaço de XML (por meio de classes que implementam a interface XpathEngine).

• Nós individuais em um fragmento de XML que são expostos pelo DOM Traversal (via classe NodeTest).