Usando JUnit - dummies

JUnit é uma estrutura padronizada para testar unidades Java (isto é, classes Java). O JUnit pode ser automatizado para tirar o trabalho do teste.

Imagine que você criou um tipo de enum com três valores: VERDE, AMARELO e VERMELHO. O Listado 1 contém o código:

Listagem 1

público enum SignalColor {VERDE, AMARELO, VERMELHO}

Um semáforo tem um estado (que é um nome extravagante para a cor da luz do semáforo).

classe pública TrafficLight {SignalColor state = SignalColor. VERMELHO;

Se você conhece o estado atual do semáforo, você pode decidir qual será o próximo estado da semáforo.

public void nextState () {switch (state) {case RED: state = SignalColor. VERDE; pausa; caso AMARELO: estado = SignalColor. VERMELHO; pausa; caso GREEN: estado = SignalColor. AMARELO; pausa; padrão: state = SignalColor. VERMELHO; break;}}

Você também pode alterar o estado do semáforo um certo número de vezes:

public void change (int numberOfTimes) {for (int i = 0; i 
Ao juntar tudo, você tem a classe TrafficLight no Listagem 2.

Listagem 2
classe pública TrafficLight {SignalColor state = SignalColor. VERMELHO; public void nextState () {switch (state) {case RED: state = SignalColor. VERDE; pausa; caso AMARELO: estado = SignalColor. VERMELHO; pausa; caso GREEN: estado = SignalColor. AMARELO; pausa; padrão: state = SignalColor. VERMELHO; break;}} public void change (int numberOfTimes) {for (int i = 0; i 
Nos dias anteriores, você pode ter continuado escrevendo código, criando mais classes, chamando o próximo estado e alterando os métodos na Listagem 2. Depois, após vários meses de codificação, você deve pausar para testar seu trabalho.






E que surpresa! Seus testes falharam miseravelmente! Você nunca deve atrasar o teste por mais de um dia ou dois. Teste antecipadamente e teste com frequência!
Uma filosofia sobre testes diz que você deve testar cada pedaço de código assim que você escreveu. Claro, a frase "pedaço de código" não soa muito científica. Isso não faria para que os desenvolvedores caminhassem falando sobre o "teste de bloco de código" que eles fizeram esta tarde. É melhor chamar cada pedaço de código de uma unidade e fazer com que os desenvolvedores conversem sobre teste de unidade .
A unidade mais comum para testes é uma classe. Então, um desenvolvedor Java típico testa cada classe assim que o código da classe é escrito.
Então, como você vai testar uma aula? Um novato pode testar a classe TrafficLight escrevendo uma classe adicional - uma classe que contém um método principal. O método principal cria uma instância do TrafficLight, chama o próximo estado e muda os métodos e exibe os resultados.O novato examina os resultados e os compara com alguns valores esperados.
Depois de escrever métodos principais para dezenas, centenas ou mesmo milhares de classes, o novato (agora um desenvolvedor de pleno direito) fica cansado da rotina de teste e procura maneiras de automatizar o procedimento de teste. Cansado ou não, um desenvolvedor pode tentar decifrar os testes codificados por mão de outro desenvolvedor. Sem ter quaisquer padrões ou diretrizes para a construção de testes, ler e entender os testes de outros desenvolvedores pode ser difícil e tedioso.
Então JUnit vem ao resgate!.
Para descobrir como o Eclipse automatiza o uso do JUnit, faça o seguinte:


Crie um projeto do Eclipse contendo listagens 1 e 2.



No Windows, clique com o botão direito do mouse no TrafficLight do Explorer do pacote. ramo de java. Em um Mac, controle-clique no TrafficLight do Package Explorer. ramo de java.
Aparece um menu de contexto.


No menu de contexto, selecione Novo → Caso de teste JUnit.
Como resultado, aparece a caixa de diálogo Novo caso de teste JUnit.



Clique em Avançar na parte inferior da caixa de diálogo Novo caso de teste JUnit.
Como resultado, você vê a segunda página da caixa de diálogo Novo caso de teste JUnit. A segunda página lista os métodos que pertencem (direta ou indiretamente) à classe TrafficLight.



Coloque uma marca de seleção na caixa de seleção Traffic Light.
Como resultado, o Eclipse coloca as marcas de seleção nas caixas de seleção nextState () e (int) .


Clique em Concluir na parte inferior da caixa de diálogo Novo caso de teste JUnit.
JUnit não é formalmente parte do Java. Em vez disso, vem com seu próprio conjunto de classes e métodos para ajudá-lo a criar testes para seu código. Depois de clicar em Concluir, o Eclipse pergunta se você deseja incluir as classes e métodos JUnit como parte do seu projeto.



Selecione Executar a seguinte ação e Adicionar JUnit 4 Library ao caminho de construção. Em seguida, clique em OK.
O Eclipse fecha as caixas de diálogo e seu projeto possui um novo TrafficLightTest. arquivo java. O código do arquivo é mostrado na Listagem 3.
O código na Listagem 3 contém dois testes, e ambos os testes contêm chamadas para um método de falha de som desagradável. O Eclipse quer que você adicione código para fazer esses testes passarem.


Remova as chamadas para o método de falha. No lugar das chamadas de método de falha, digite o código mostrado em negrito na Listagem 4.


No Package Explorer, clique com o botão direito do mouse (no Windows) ou clique com o botão direito do mouse (em um Mac) no TrafficLightTest. ramo de java. No menu de contexto resultante, selecione Executar como → JUnit Test.
O Eclipse pode ter mais de um tipo de estrutura de teste JUnit em sua manga. Se assim for, você pode ver uma caixa de diálogo como aquela abaixo. Se você fizer isso, selecione o Eclipse JUnit Launcher e clique em OK.

Como resultado, o Eclipse executa seu TrafficLightTest. programa java. O Eclipse exibe o resultado da execução na frente do seu próprio Pacote Explorer. O resultado não mostra erros e não há falhas. Whew!




Listagem 3
importar org estática. junt. Afirmar. *; importar org. junt. Teste; classe pública TrafficLightTest {@Test public void testNextState () {fail ("Ainda não implementado");} @Test public void testChange () {fail ("Ainda não implementado");}}


Listing 4
import org estáticajunt. Afirmar. *; importar org. junt. Teste; classe pública TrafficLightTest {@Test public void testNextState () { TrafficLight light = new TrafficLight (); assertEquals (SignalColor. RED, estado da luz); luz. NextState (); assertEquals (SignalColor. GREEN, estado da luz); luz. NextState (); assertEquals (SignalColor. YELLOW, estado da luz); luz. NextState (); assertEquals (SignalColor. RED, estado da luz); } @Test public void testChange () { TrafficLight light = new TrafficLight (); luz. mudança (5); assertEquals (SignalColor. YELLOW, estado da luz); }}

Quando você seleciona Executar como → JUnit Test, o Eclipse não procura um método principal. Em vez disso, o Eclipse procura métodos que começam com o @Test e outras coisas assim. O Eclipse executa cada um dos métodos @Test.
Coisas como @Test são Java anotações .
O Listado 4 contém dois métodos @Test: testNextState e testChange. O método testNextState coloca o método TrafficLight nextState para a prova. Da mesma forma, o método testChange flexiona os músculos do método de mudança do TrafficLight.
Considere o código no método testNextState. O método testNextState repetidamente chama o método NextState da classe TrafficLight e o método assertEquals de JUnit. O método assertEquals leva dois parâmetros: um valor esperado e um valor real.


Na chamada assertEquals superior, o valor esperado é SignalColor. VERMELHO. Você espera que o semáforo seja VERMELHO porque, na Listagem 2, você inicializa o estado da luz com o valor SignalColor. VERMELHO.


Na chamada assertEquals superior, o valor real é leve. estado (a cor que está realmente armazenada na variável de estado da luz do semáforo).


Se o valor real for igual ao valor esperado, a chamada para asserirEquals passa e JUnit continua a executar as instruções no método testNextState.
Mas se o valor real for diferente do valor esperado, o assertEquals falhará e o resultado da execução exibirá a falha. Por exemplo, considere o que acontece quando você altera o valor esperado na primeira chamada assertEquals na Listagem 4:
@Test public void testNextState () {TrafficLight light = new TrafficLight (); AssertEquals (SignalColor. AMARELO, estado da luz);

Imediatamente após sua construção, a cor de um semáforo é VERMELHO, não AMARELO. Então, o método testNextState contém uma asserção falsa e o resultado de executar Run As → JUnit parece um relatório ruim de uma criança.

Tendo testNextState antes do testChange no Listing 4 não garante que JUnit executará testNextState antes de executar testChange. Se você tiver três métodos @Test, JUnit pode executá-los de cima para baixo, de baixo para o topo, do método do meio para o mais alto para o mais baixo, ou em qualquer ordem. JUnit pode até pausar no meio de um teste para executar partes de outro teste. É por isso que você nunca deve fazer suposições sobre o resultado de um teste quando você escreve outro teste.
Você pode querer que certas instruções sejam executadas antes de qualquer um dos testes começar.Se você fizer isso, coloque essas declarações em um método chamado setUp e prefile esse método com uma anotação @Before. (Veja a caixa de seleção setUp () na figura na Etapa 3 na Listagem 2, acima.)
Aqui está a notícia: nem todos os métodos assertEquals são criados iguais! Imagine adicionar uma classe Driver ao código do seu projeto. "Classe de driver" não significa um driver de impressora ou um driver de pilha. Isso significa uma pessoa dirigindo um carro - um carro que está se aproximando do seu semáforo. Para obter detalhes, consulte a Listagem 5.

Listagem 5
driver de classe pública {pública de velocidade dupla (luz de TrafficLight) {switch (estado de luz) {caso RED: return 0. 0; caso AMARELO: retorno 10. 0; caso GREEN: retorno 30. 0; padrão: retornar 0. 0;}}}

Quando a luz está vermelha, a velocidade do driver é 0. 0. Quando a luz é amarela, o carro está diminuindo para um ponto seguro 10. 0. Quando a luz é verde, o carro cruza a uma velocidade de 30. 0.
(Neste exemplo, as unidades de velocidade não importam. Podem ser milhas por hora, quilômetros por hora, ou o que quer que seja. A única maneira que importa é se o O carro está em Boston ou na cidade de Nova York. Nesse caso, a velocidade para AMARELO deve ser muito maior do que a velocidade para GREEN e a velocidade para RED não deve ser 0. 0.)
Para criar testes JUnit para o Classe de controle, siga os passos 1 a 9 listados anteriormente neste artigo, mas certifique-se de efetuar as seguintes alterações:


Na Etapa 2, clique com o botão direito ou controle-clique no driver. ramificação java em vez do TrafficLight. ramo de java.


Na Etapa 5, coloque uma marca de seleção na ramificação Driver.


Na etapa 8, remova as chamadas de método de falha para criar a classe DriverTest mostrada na Listagem 6. (O código que você digita é mostrado em negrito.)



Listagem 6
importar org estática. junt. Afirmar. *; importar org. junt. Teste; classe pública DriverTest {@Test public void testVelocity () { TrafficLight light = new TrafficLight (); luz. mudança (7); Driver driver = Driver novo (); assertEquals (30. 0, velocidade do motorista (luz), 0. 1); }}

Se tudo correr bem, o teste JUnit passa com cores voadoras. (Para ser mais preciso, o JUnit passa com a cor verde!) Então, a execução do DriverTest não é nova ou excitante. O que é emocionante é a chamada para asserir as reivindicações na Listagem 6.
Quando você compara dois valores duplos em um programa Java, você não tem o direito de esperar igualdade no nariz. Ou seja, um dos valores duplos pode ser 30. 000000000 enquanto o outro valor duplo é mais próximo de 30. 000000001. Um computador tem apenas 64 bits para armazenar cada valor duplo, e as imprecisões passam por aqui e aí. Então, no JUnit, o método assertEquals para comparar valores duplos tem um terceiro parâmetro. O terceiro parâmetro representa a sala de mudanças.
Na Listagem 6, a declaração
afirmaram-se (30. 0, velocidade do driver (luz), 0. 1);

diz o seguinte: "Afirme que o valor real do driver. A velocidade (luz) está dentro de 0. 1 do valor esperado 30. 0. Se assim for, a asserção passa. Caso contrário, a asserção falhará. "
Quando você chama assertEquals para valores duplos, selecionar uma boa margem de erro pode ser complicado.Essas figuras ilustram o tipo de coisas que podem dar errado.

Aqui, sua margem de erro é muito pequena.

Lá, sua margem de erro é muito grande.
Felizmente, neste exemplo do DriverTest, a margem 0. 1 é uma aposta muito segura. É por isso que:


Quando o teste assertEquals falhar, ele falha em muito mais de 0. 1. 
Falha significa ter um driver. valor de velocidade (luz) como 0. 0 ou 10. 0.



Neste exemplo, quando o teste assertEquals passa, provavelmente representa igualdade completa no nariz. 
O valor do driver. A velocidade (luz) vem diretamente do retorno 30. Código 0 na Listagem 5. Nenhuma aritmética está envolvida. Então, o valor do driver. velocidade (luz) e o valor esperado de 30. 0 deve ser exatamente o mesmo (ou quase exatamente o mesmo).