usando JUnit
JUnit
é uma estrutura padronizada para as unidades de teste Java (isto é, classes Java). JUnit pode ser automatizado para levar a parte do trabalho de testes.Imagine que você tenha criado um enum digitar com três valores: VERDE, AMARELO, e VERMELHO. A Listagem 1 contém o código:
listagem 1
public enum SignalColor {VERDE, AMARELO, VERMELHO}Um semáforo tem um Estado (Que é um nome fantasia para a cor do semáforo).
TrafficLight classe pública {estado SignalColor = SignalColor.RED-Se você sabe o estado atual do semáforo, você pode decidir o próximo estado do semáforo será.
public void nextState () {switch (estado) {case RED: state = SignalColor.GREEN-break-Amarelo caso: Green State = SignalColor.RED-break-caso: state = SignalColor.YELLOW-break-padrão: state = SignalColor. RED-break-}}Você também pode alterar o estado do semáforo um certo número de vezes:
mudança public void (int numberOfTimes) {for (int i = 0- i lt; numberOfTimes- i ++) {nextState () -}}Juntando tudo, você tem a Semáforo classe na Listagem 2.
A Lista 2
TrafficLight classe pública {estado SignalColor = SignalColor.RED-public void nextState () {switch (estado) {case RED: state = SignalColor.GREEN-break-Amarelo caso: Green State = SignalColor.RED-break-caso: state = SignalColor .YELLOW-break-padrão: state = SignalColor.RED-break -}} mudança public void (int numberOfTimes) {for (int i = 0- i lt; numberOfTimes- i ++) {nextState () -}}}Nos velhos tempos você poderia ter continuado a escrita de código, criando mais classes, chamando a nextState e alterar métodos na Listagem 2. Em seguida, após vários meses de codificação, você fazer uma pausa para testar o seu trabalho.
E que surpresa! Seus testes iria falhar miseravelmente! Você nunca deve atrasar testes por mais de um dia ou dois. Teste inicial e testar muitas vezes!
Uma filosofia sobre o teste diz que você deve testar cada pedaço de código, logo que você escreveu ele. Claro, o "pedaço de código" frase não soa muito científico. Não faria para ter desenvolvedores andando por aí falando sobre o "teste pedaço-de-código" que eles fizeram esta tarde. É melhor chamar cada pedaço de código a unidade, e obter os desenvolvedores para falar sobre teste de unidade.
A unidade mais comum para o teste é uma classe. Então, um desenvolvedor típica Java testa cada classe assim que o código da classe está escrito.
Então, como é que você vai testar uma classe? Um novato pode testar a Semáforo classe, escrevendo uma classe adicional - uma classe que contém uma a Principal método. o a Principal método cria uma instância de Semáforo, a chama nextState e alterar métodos e exibe os resultados. O noviço examina os resultados e compara-os com alguns valores esperados.
Depois de escrever a Principal métodos para dezenas, centenas ou mesmo milhares aulas, o novato (agora um desenvolvedor de pleno direito) torna-se cansado da rotina de testes e procura maneiras de automatizar o procedimento de teste. Cansado ou não, um desenvolvedor pode tentar decifrar os testes com código de mão de outro desenvolvedor. Sem ter quaisquer normas ou diretrizes para a construção de testes, ler e entender os testes de outro desenvolvedor pode ser difícil e tedioso.
Então JUnit vem para o resgate !.
Para descobrir como Eclipse automatiza o uso do JUnit, faça o seguinte:
Criar um projeto Eclipse contendo listas 1 e 2.
No Windows, direito, clique ramo TrafficLight.java do Package Explorer. Em um Mac, controle clique com o ramo TrafficLight.java do Package Explorer.
Um menu de contexto aparece.
No menu de contexto, selecione Test Case New-JUnit.
Como resultado, a caixa de diálogo Test Case New JUnit aparece.
Clique em Avançar na parte inferior da caixa de diálogo Test Case New JUnit.
Como resultado, você vê a segunda página da caixa de diálogo Test Case New JUnit. A segunda página lista métodos que pertencem (quer directamente ou indirectamente) ao Semáforo classe.
Coloque uma marca na caixa de seleção semáforo.
Como resultado, Eclipse coloca marcas de verificação no nextState () e mudança (int) caixas de seleção.
Clique em Concluir na parte inferior da caixa de diálogo Test Case New 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, Eclipse perguntará se você deseja incluir as classes JUnit e métodos como parte de seu projeto.
Selecione executar a seguinte acção e adicionar JUnit 4 Biblioteca no caminho de construção. Em seguida, clique em OK.
Eclipse fecha as caixas de diálogo e seu projeto tem uma marca nova TrafficLightTest.java Arquivo. 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 som desagradável falhou método. Eclipse quer que você adicionar código para fazer estes testes passam.
Retire as chamadas para o método Fail. No lugar das chamadas de método falhar, digite o código mostrado em negrito na Listagem 4.
No Package Explorer, direita; clique (no Windows) ou Control-clique (no Mac) o ramo TrafficLightTest.java. No menu de contexto resultante, selecione Executar como-teste JUnit.
Eclipse pode ter mais de um tipo de teste JUnit quadro na manga. Se assim for, você pode ver uma caixa de diálogo como a mostrada abaixo. Se fizer isso, selecione o Eclipse JUnit Launcher, e clique em OK.
Como resultado, Eclipse executa o seu TrafficLightTest.java programa. Eclipse exibe o resultado da corrida na frente de seu próprio pacote Explorer. O resultado mostra sem erros e sem falhas. Ufa!
listagem 3
importação org.junit.Assert estática. * - import org.junit.Test-pública classe TrafficLightTest {@Testpublic testNextState void () {falhar ( "Ainda não implementado") -} @ Testpublic testChange void () {falhar ( "Ainda não implementado ") -}}Lista 4
importação org.junit.Assert estática. * - TrafficLightTest classe de importação org.junit.Test-pública {@Testpublic testNextState void () {luz TrafficLight = new TrafficLight () -assertEquals (SignalColor.RED, light.state) -light.nextState () -assertEquals (SignalColor.GREEN, light.state) -light.nextState () -assertEquals (SignalColor.YELLOW, light.state) -light.nextState () -assertEquals (SignalColor.RED, light.state) -} @Testpublic Anular testChange () {luz TrafficLight = new TrafficLight () -light.change (5) - assertEquals (SignalColor.YELLOW, light.state) -}}Quando você selecionar Executar teste As-JUnit, Eclipse não procurar um método principal. Em vez disso, parece Eclipse para métodos começando com @Teste e outras coisas que tais. Eclipse executa cada um dos @Teste métodos.
Coisas como @Teste são Java anotações.
Listagem 4 contém dois @Teste métodos: testNextState e testChange. o testNextState o método coloca Semáforo nextState método para o teste. Da mesma forma, o testChange o método flexiona Semáforo alterar músculos do método.
Considere o código na testNextState método. o testNextState método chama repetidamente a Semáforo classe de nextState método e JUnit de assertEquals método. o assertEquals método tem dois parâmetros: um valor esperado e um valor real.
Na extremidade superior assertEquals chamada, o valor esperado é SignalColor.RED. Você espera que o semáforo para ser VERMELHO porque, na Listagem 2, você inicializa a luz do Estado com o valor SignalColor.RED.
Na extremidade superior assertEquals chamada, o valor real é light.state (A cor que está realmente armazenado no semáforo da Estado variável).
Se o valor real é igual ao valor esperado, a chamada para assertEquals passa e JUnit continua executando as instruções no testNextState método.
Mas se o valor real for diferente do valor esperado, o assertEquals falha e o resultado da corrida exibe o fracasso. Por exemplo, considere o que acontece quando você alterar o valor previsto para o primeiro assertEquals chamar na Listagem 4:
@Testpublic Vazio testNextState () {TrafficLight luz = new TrafficLight () - assertEquals (SignalColor.YELLOW, light.state) -Imediatamente após a sua construção, a cor de um semáforo é VERMELHO, não AMARELO. Então o testNextState método contém uma falsa afirmação e o resultado de fazer Executar como-JUnit parece boletim ruim de uma criança.
Tendo testNextState antes testChange na Listagem 4 não garante que irá executar JUnit testNextState antes de executar testChange. Se você tem três @Teste métodos, JUnit pode executá-los a partir de nível superior para bottommost, de bottommost ao mais alto nível, a partir do método do meio para o superior à extremidade inferior, ou em qualquer ordem em tudo. JUnit pode ainda fazer uma pausa no meio de um teste para executar peças de outro ensaio. É por isso que você nunca deve fazer suposições sobre o resultado de um teste quando você escreve um outro teste.
Você pode querer certas instruções a serem executadas antes de qualquer um dos testes começam. Se fizer isso, coloque essas declarações em um método chamado configuração, e que preceda um método com @Antes anotação. (Veja a configuração() checkbox na figura na Etapa 3 na Listagem 2, acima).
Aqui é novidade: Nem todos assertEquals métodos são iguais! Imagine que a adição de um Condutor classe para o código do seu projeto. "Classe Driver" não significa um driver de impressora ou um driver de pilha. Isso significa que uma pessoa dirigindo um carro - um carro que está se aproximando o seu semáforo. Para os detalhes, consulte a Lista 5.
Lista 5
Motorista classe pública {velocidade dupla públicos (luz TrafficLight) {switch (light.state) {case RED: retornar de 0.0 caso AMARELO: retornar VERDE 10.0 caso: voltar 30,0-padrão: retorno 0.0-}}}Quando a luz é vermelha, a velocidade do motorista é de 0,0. Quando a luz é amarela, o carro está a abrandar para um cofre 10.0. Quando a luz está verde, os cruzeiros de carro a uma velocidade de 30,0.
(Neste exemplo, as unidades de velocidade, não importa. Eles poderiam ser milhas por hora, quilômetros por hora, ou o que quer. A única maneira que importa é se o carro está em Boston ou Nova York. Nesse caso, o velocidade de AMARELO deve ser muito maior do que a velocidade de VERDE, e a velocidade de VERMELHO não deve ser 0,0).
Para criar testes JUnit para o Condutor classe, siga as etapas de 1 a 9 listados anteriormente neste artigo, mas não se esqueça de fazer as seguintes alterações:
No Passo 2, à direita; clique ou control-clique no Driver.java em vez do ramo TrafficLight.java ramo.
Na etapa 5, coloque uma marca de verificação no ramo de Driver.
No Passo 8, o remover falhou chamadas de método para criar o DriverTest classe mostrada na Listagem 6. (O código que você digita é mostrado em negrito).
Lista 6
importação org.junit.Assert estática. * - import classe org.junit.Test-pública DriverTest {testVelocity vazio @Testpublic () {luz TrafficLight = new TrafficLight () -light.change (7) -motorista motorista = new Driver () -assertEquals (30.0, driver.velocity (luz), 0,1) - }}Se tudo correr bem, o teste JUnit passa com distinção. (Para ser mais preciso, o JUnit passa com a cor verde!) Então, a execução de DriverTest não é novo e excitante. O que é interessante é a chamada para assertEquals na Listagem 6.
Quando você compara dois duplo valores em um programa Java, você tem o direito de esperar on-the-nariz igualdade. Isto é, um dos duplo valores pode ser 30,000000000 enquanto a outra duplo valor está mais perto de 30,000000001. Um computador tem apenas 64 bits para armazenar cada duplo valor e imprecisões fluência em aqui e ali. Assim, em JUnit, o assertEquals método para comparar duplo valores tem um terceiro parâmetro. O terceiro parâmetro representa espaço de manobra.
Na Listagem 6, a declaração
assertEquals (30.0, driver.velocity (luz), 0,1) -
diz o seguinte: "Afirmar que o valor real de driver.velocity (luz) está dentro de 0,1 do valor esperado de 30,0. Se assim for, a afirmação passa. Se não, a declaração falha ".
Quando você chamar assertEquals para duplo valores, selecionando uma boa margem de erro pode ser complicado. Estes números ilustram os tipos de coisas que podem dar errado.
Aqui, a sua margem de erro é muito pequena.
Lá, a sua margem de erro é muito grande.
Felizmente, neste DriverTest exemplo, a margem de 0,1 é uma aposta muito segura. Aqui está o porquê:
Quando o teste assertEquals falhar, ele falha por muito mais do que 0,1.
Falha significa ter um driver.velocity (luz) valor, tais como 0,0 ou 10,0.
Neste exemplo, quando o teste assertEquals passa, provavelmente representa, completa igualdade on-the-nariz.
O valor de driver.velocity (luz) vem diretamente do voltar 30,0 código na Listagem 5. Nenhum aritmética está envolvido. Portanto, o valor de driver.velocity (luz) e o esperado 30,0 valor deve ser exatamente o mesmo (ou quase o mesmo).