Vamos então à nossa demonstração. Vamos abrir a idéia de desenvolvimento "Eclipse". Vamos criar novo projeto "Java". E vamos dar o nome de "Identifier". Vamos finalizar. E aqui nós temos a estrutura de projeto "Java". Vamos realizar a cópia do código fonte do programa "Identifier" para dentro desse projeto, apenas para possibilitar a execução do mesmo. E agora nós temos aqui o código fonte do programa "Identifier". São duas classes, sendo que essa classe "main" é responsável por realizar a execução do programa. Como nós tratamos o teste funcional, nós não vamos estar observando o conteúdo do código fonte do programa "Identifier". Vamos observar a especificação do mesmo. Então, dando uma olhada na especificação, nós temos aqui que o nome do programa é "Identifier" e ele é utilizado para determinar se o identificador é válido ou não. "O programa 'Identifier' determina se o identificador é válido ou não. Identificador válido deve começar com uma letra e conter apenas letras ou dígitos. Além disso, deve ter no mínimo caractere e no máximo seis caracteres de comprimento." E temos aqui alguns exemplos: "Verificando identificador válido (respeita as restrições impostas na descrição)". Então, a gente tem a execução da classe "Identifier main", e é passado como parâmetro uma "string". E aí, como saída, é devolvido "string" que representa se aquele caractere é válido ou não. No caso desse cenário, passando como parâmetro "string", a gente vai ter uma saída dizendo que esse identificador é válido. Depois, a gente tem aqui a verificação de identificador inválido. "Extrapola o número máximo de caracteres aceitos," por exemplo. Então a gente tem aqui, "Stringmuitogrand". Se a gente passar para a execução da classe "Identifiermain", esse parâmetro "stringmuitogrand", a gente vai ter como saída que esse é identificador inválido. Então, com base nessa informação, nós devemos construir os nossos casos teste. Também levaremos consideração as classes de equivalência identificadas no "slide". Então, primeiro passo para a utilização da ferramenta de teste "Junit" é realizar a adição do mesmo ao projeto de teste, ao projeto do "eclipse". Então, vamos aqui clicar com o botão direito cima do projeto "identifier", vamos na opção "buildpath", "add libraries" e vamos selecionar a opção "Junit". Verificamos a versão do "Junit", versão quatro. Damos "next" e depois clicamos "finish". Pronto! A partir desse momento, o "Junit" já está adicionado ao projeto Java e nós já podemos criar a nossa classe de teste. Então, o nosso foco vai ser testar essa classe "identifiermain". Então, nós vamos clicar com o botão direito cima da classe "identifiermain", vamos "new", e vamos selecionar a opção, "Junit Test Case". A ideia "eclipse" vai sugerir nome, da classe de teste, que não seja "identifiermaintest". Estou de acordo, então, eu vou simplesmente clicar "finish". Então, foi criada a classe "identifiermaintest" e a gente vai ter aqui método teste que está anotado com a anotação @Test, contudo ele tem aqui a execução "fail". Simplesmente identificando que o método não foi implementado. Então, antes de realizar o teste do comportamento do programa "identifier", nós precisamos criar alguns mecanismos relacionados à linguagem de programação "java". Como o programa "identifier" retorna uma "string" de execução, nós precisamos criar mecanismo para capturar essa "string". Então, nós vamos precisar de objeto Java que seja capaz de recuperar essa "string" de resultado da execução do programa "identifier", para que a gente possa verificar se ela está de acordo ou não com o esperado. Então, nós vamos precisar de objeto, "ByteArrayOutputStream" [SEM ÁUDIO] Vamos chamar esse objeto de "baOut". [SEM ÁUDIO] E aí vamos criar método para inicializar o valor desse objeto. Então, vamos criar método anotado com a Anotação "@beforeclass". Vamos criar método chamado "beforeclassInit", por exemplo. "Void BeforeClassInit". Ele não vai receber nenhum parâmetro e vai simplesmente instanciar esse objeto "baOut" [SEM ÁUDIO] e nós vamos precisar, também, de outro objeto aqui. "Static Private". "PrintStream". Esse objeto vai ser responsável por capturar o conteúdo que será exibido no console. E nós vamos instanciar esse objeto também. "psOut". "PrintStream". E ele vai receber como parâmetro o objeto "ba.Out". Nós precisamos só disso. Nós precisamos também setar: "System" ponto "Out", esse objeto para a saída, para a gente poder capturar. "psOut", para a gente poder capturar a saída da execução do "Identifier.SetOut". Pronto! Antes de realizar a criação dos nossos testes nós vamos criar, também, método "@afterclass", para realizar "Void Static" "AfterClassFinalize". A gente vai ter método assim e esse método vai ser responsável por, simplesmente, retornar o comportamento desses objetos que a gente está criando. Nesse caso, eu simplesmente vou encerrar a execução desse objeto. "psOut.close". Pronto! A partir desse momento, eu já posso criar os métodos de teste e, melhor, antes de criar os métodos de teste, para evitar que ocorra algum erro, eu vou criar método anotado com "@before" e vou chamá-lo de "Setup". "public void setup". E esse método vai simplesmente limpar o conteúdo dentro desse objeto para evitar que a gente pegue o conteúdo de uma execução de caso de teste anterior. Então, para cada execução de caso de teste, a gente vai limpar a saída do "baOut" para evitar que a gente pegue os dados relacionados a execução de caso de teste anterior. Pronto! Agora a gente já tudo que a gente precisa, então, vamos criar os casos de teste para cada uma das classes definidas no conjunto de "slides". Então, a gente vai ter método anotado com "@test". O nome do método, por exemplo, "Public Void", Teste valido 01. Então, nesse método: Teste valido 01, eu vou testar a classe válida. Eu vou simplesmente fazer a execução, "IdentifierMain.main". Eu vou fazer a execução da da classe "Identifiermain". Então, "string" e aqui, eu vou passar como parâmetro, por exemplo, o identificador A1. [SEM ÁUDIO] Depois, eu vou Definir uma string. Eu vou setar o valor dessa string como a saída para a execução da 'identifier.Main'. Então, simplesmente eu vou pegar a saída e vou transformá-lo num string. Então, a execução da classe 'identifier.Main' resultará na execução, na resposta para esse caractere, para esse identificador. Informará se ele é válido ou não, e eu vou pegar essa execução e vou colocá-la na variável output, na string output, por fim, para verificar se a classe está se comportando da maneira que eu espero, então, eu vou colocar aqui método assert, proveniente da classe assert JUnit. Perceba que a gente tem uma infinidade de métodos assert, então, existem várias possibilidades mas no caso vou simplesmente verificar AssertEquals e eu vou informar que eu espero, que, para essa execução, para execução com identificador A1 eu espero que a saída seja válida. Então, com isso, com a construção desse caso de teste nós conseguimos cumprir a classe válida 1. Pois o tamanho do identificador é maior ou igual, e menor ou igual a 6, nós conseguimos cumprir a Classe válida 3, pois o primeiro caractere é uma letra, e nós também conseguimos cumprir a classe válida 5, pois o identificador contém apenas caracteres válidos. Então, a gente tem esse casos de teste aí que consegue contemplar esses três classes, essas três classes identificadas. E vamos criar mais alguns casos de teste que seriam capazes de identificar as demais classes, então eu vou copiar o conteúdo de caso de teste para acelerar o processo. Então, chamar esse caso de teste como teste válido 2. E eu vou passar como parâmetro o identificador 2b3. Nesse caso, como o identificador se inicia com número, eu espero que a execução do mesmo seja inválido. Inválido. Então, está aqui a execução do caso de teste, o caso de teste é composto pelo identificador 2b3. A execução vai ser repassada para esse objeto e vamos armazenar o resultado da execução na string output, por fim, vamos comparar a string output com o valor esperado que é o valor inválido. A execução desse caso de teste contempla a classe de equivalência inválida número 4, onde o primeiro caractere não é uma letra. Agora vamos criar mais caso de teste. Vamos chamar ele de caso de teste test03. Esse aqui. A gente deve chamar de inválido, né? Porque a gente está verificando uma classe inválida, então, esse aqui vai ser teste inválido 02. Vamos chamar esse aqui de inválido também, 03. Inválido. Nós vamos utilizar o parâmetro z-12, por exemplo. E aqui a gente espera que com esse identificador também seja inválido. Se a gente observar aqui na Classe inválida 06, a gente diz que a classe inválida não contém apenas caracteres válidos, então, a gente inseriu aqui caractere inválido e vamos verificar se se a execução funciona de acordo com o esperado. Por fim, vamos criar mais caso de teste. Dessa vez vamos criar caso de teste válido. Vamos chamar ele de caso de teste4, válido 04. Vamos passar como parâmetro, por exemplo, 1b2, c3d [AUDIO_EM_BRANCO] E vamos chamar ele de inválido. Pois, a saída que a gente espera aqui é que seja inválido, né? Inválido. A gente vai ter aqui então, identificador com 1, 2, 3, 4, 5, 6, 7 caracteres. E conforme a descrição das classes de equivalência, identificador com tamanho maior que 6 é uma classe inválida então, a gente está aqui complementando a classe de equivalência identificada como número 2. Então, a gente já tem o caso de teste para complementar as classes de equivalência 1, 3 e 5, que é esse primeiro caso de teste. A gente tem caso de teste para complementar a classe de equivalência 4. A gente tem caso de teste para complementar a classe de equivalência 6. E por último nós temos caso de teste para complementar a classe de equivalência número 2. Por fim, agora que nós temos todos os casos de teste prontos, o que nós temos que fazer é realizar a execução dos casos de teste. Para isso a gente pode clicar aqui cima da classe com o botão direito e ir na opção Run as JUnit test. Identificamos a classe main test. Clicamos ok. E temos aqui pequeno erro no código. A gente esqueceu de colocar aqui o identificador Public antes do método after class e também antes do método before class. Do método anotado como after class e do método anotado como before class. Vamos ver se a gente tem mais algum erro aqui, acredito que não, então, vamos tentar executar novamente. Então, agora assim a gente executou, está tudo correto, percebam que a barrinha aqui ficou verde. Isso quer dizer, que todos os casos de teste que foram executados, eles foram executados com sucesso. Então, para esse cenário nós criamos casos de teste que foram adequados às classes equivalentes que foram definidas. O que aconteceria se nós por acaso, realizássemos uma alteração. Por exemplo, vamos supor que por algum engano nós definimos caso de teste muito grande aqui, por exemplo, no primeiro caso de teste. Nós temos aqui identificador muito grande e então a execução deste caso de teste deveria dar como valor inválido, então veja, nós estamos esperando que a execução seja válida, contudo, a saída da execução do programa será inválida. Vamos ver o que acontece quando a gente tentar executar esse caso de teste. Vamos rodar novamente esse caso de teste e aí a gente vai perceber que aqui o teste inválido 02 passou, está verdinho, o teste inválido 03 passou, está verdinho e o teste inválido 04 passou, está verdinho. Contudo, o teste válido 01 não passou, porquê? Aqui na execução, a gente pode observar, que a gente esperava que o valor da execução fosse válido, contudo, a execução mostrou valor inválido, então, a execução do programa difere do valor que a gente estava esperando como saída, por isso o caso de teste não bateu. Então, dessa forma, a gente consegue observar o comportamento do programa. Vamos só corrigir aqui então, vamos rodar novamente. Então, depois de corrigir da entrada do programa a gente vê que de fato a gente passa identificador começando com uma letra e depois seguido de número, respeitando o tamanho máximo do identificador a gente vai ter uma saída realmente válida. Então, é isso, dessa forma nós podemos estar utilizando o o phramework de test JUnit para estar instanciando os conceitos relacionados a teste funcional conjunto com o critério de classes de equivalência. Até a próxima.
