A necessidade das empresas em produzir software com qualidade tem aumentado a demanda por profissionais com conhecimentos e habilidades em Teste de Software. Entretanto, existe uma escassez de mão-de-obra especializada nesta área. Considerando essa lacuna, o curso de Introdução ao Teste de Software foi planejado para servir como um guia para pessoas que necessitam de uma fonte de consulta e/ou aprendizado na área.
Ao completar o curso, os estudantes serão capazes de planejar e aplicar as principais técnicas, critérios e ferramentas de teste em variados domínios e tipos de software. Adicionalmente, terão a oportunidade de desenvolver habilidades essenciais para um testador, tais como pensar a partir da perspectiva do cliente, habilidade para raciocinar e se comunicar efetivamente, capacidade de se adaptar às mudanças do projeto, curiosidade para compreender o produto que será testado, busca constante pela qualidade, dentre outras.
À partir de la leçon
Teste Funcional
Ao final deste módulo, espera-se que você seja capaz de compreender a técnica de Teste Funcional e seus principais critérios.
Doutoranda em Ciências de Computação e Matemática Computacional pela Universidade de São Paulo (USP). Professora efetiva no IFSULDEMINAS Campus Muzambinho. Ciência da Computação
Stevao Alves de Andrade
Doutorando em Ciências de Computação e Matemática Computacional pela Universidade de São Paulo (USP). Universidade de São Paulo (ICMC/USP)
Draylson Micael de Souza
Doutor em Ciências da Computação e Matemática Computacional Universidade de São Paulo (ICMC/USP)
Olá pessoal.
Nessa aula, vamos estudar pouco a respeito do framework de teste de unidade Junit,
e vamos verificar como é possível utilizá-lo para aplicar os
conhecimentos vistos a respeito da técnica de teste funcional.
Mais especificamente, vamos tentar aplicar os conceitos relacionados ao critério de
particionamento de classes de equivalência.
Então, o Junit é framework de teste de
unidade para a linguagem de programação Java e é proveniente de uma
família de frameworks de Teste de Unidade denominada xUnit.
Essa família de frameworks de teste possui uma
gama de frameworks de teste para diversas linguagens de programação,
como por exemplo C, PHP, Phyton, Java, etc.
Os requisitos para a utilização do Junit são: nós
necessitamos da instalação do kit de desenvolvimento Java.
A versão mínima suportada é a versão 1.5, a versão cinco.
Atualmente, o kit de desenvolvimento Java encontra-se na versão nove, então,
é necessário que seja instalada uma das versões entre essas
versões disponíveis, e para essa aula nós vamos utilizar o framework de
teste Junit conjunto com a Ideia de Desenvolvimento Eclipse (IDE).
As principais características do framework de teste Junit são: é framework
de teste open source, ou seja, você pode ter acesso ao código fonte da ferramenta.
Isso possibilita que possam ser sugeridas melhorias para a ferramenta e,
também, casos que se encontra problema na ferramenta,
também podem ser sugeridas correções.
O framework utiliza conceito de Annotations para identificar métodos
de teste e fornece conjunto de métodos de assertivas para avaliar os valores
esperados para determinado programa teste, além de possibilitar a execução de testes
de maneira automatizada, possibilitando feedback imediato ao testador.
As principais Annotations disponíveis no Junit são:
Annotations são conjuntos de meta tags que podem ser adicionadas ao código.
Então, nós temos a annotation @Test, que é a annotation mais clássica,
e essa annotation serve para informar ao Junit que método public void que
está associado a essa notação, deve ser executado como caso de teste.
Temos duas anotações: @Before e @After que servem para constituir cenário de teste.
Por exemplo, uma situação que são necessárias realizar operações antes
da execução do caso de teste, essas operações são executadas dentro de método,
que é anotado como anotação @Before.
De forma similar, após a execução do caso de teste, esse recurso que foi alocado
inicialmente antes da execução do caso de teste, se ele necessita ser desalocado,
ele é desalocado método que é anotado com a anotação @After.
Imagine o cenário que é necessário recuperar dados de
banco de dados para realizar a aplicação de teste.
Então, criamos método com a anotação @Before.
Nesse método, os dados necessários para a execução do caso de teste são recuperados
do banco de dados, o caso de teste é executado e, posteriormente,
após a execução do caso de teste, existe método @After que fica responsável
por realizar o fechamento da conexão com o banco de dados, por exemplo.
De maneira similar, temos a anotação @BeforeClass e a anotação @AfterClass.
A principal diferença entre as anotações @Before e @After e
@BeforeClass e @AfterClass é que a anotação @Before e a anotação
@After executam métodos a cada caso de teste, ou seja,
se temos cinco casos de teste, antes da execução de cada dos cinco casos de teste,
o método anotado com @Before é executado e após a execução de cada
dos cinco casos de teste, o método anotado com @After é executado.
Já para @BeforeClass e @AfterClass,
o método anotado com @BeforeClass é executado uma única vez,
antes da execução dos casos de teste, e o método anotado
@AfterClass é executado uma única vez após todos os testes terem sido realizados.
Por fim, nós temos a anotação @Ignore que é utilizada para
ignorar caso de teste que não se deseja executar no momento.
As principais classes contidas no pacote de framework Junit são: a classe Assert,
que contém conjunto de métodos de assertivas para realizar os casos
de teste; temos a classe TestCase,
que serve para definir características de caso de testes; temos a classe TestResult,
que serve para coletar resultados a respeito da execução de
determinado caso de teste; e temos a classe TestSuite que é
utilizada para composição de conjunto de casos de teste, por exemplo.
Os passos para a aplicação de critério funcional consistem
analisar a especificação de requisitos do software que se deseja testar.
Com base nessa análise, as entradas válidas serão escolhidas para
determinar se o produto teste está se comportando da maneira que se espera.
De forma similar,
são identificadas as entradas inválidas e as mesmas são escolhidas para verificar se
os comportamentos inesperados do software estão sendo tratados de maneira adequada.
Os casos de teste são constituídos e, então,
são definidos os pares de entrada e saída, e depois,
o conjunto dos casos de teste é executado a fim de verificar se as saídas obtidas
são iguais às saídas esperadas para a execução de cada dos cenários de teste.
Posteriormente, relatório é gerado para avaliar o resultado desses testes.
Como vínhamos trabalhando com o programa Identifier,
montamos conjunto de classes válidas e
classes inválidas para a realização da nossa prática.
Então, nós temos aqui o programa Identifier,
nós temos as condições de entrada.
O tamanho de identificador deve variar entre maior do que e menor ou
igual a seis, maior ou igual a ou menor ou igual a seis, isso para uma classe válida.
Para uma classe inválida, o tamanho do identificador deve ser maior do que seis.
Na próxima classe inválida, a gente tem a condição de entrada que o
primeiro caractere seja uma letra.
De forma análoga à classe inválida, seria então que o caractere não seja classe
inválida, seria então que o caractere não seja uma letra,
e posteriormente, nós temos uma outra condição de entrada,
que os caracteres inseridos contenham apenas caracteres válidos,
e a classe inválida seria a negação disso,
que seriam caracteres inválidos.
Explorer notre catalogue
Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.
Márcio Eduardo DelamaroProfessor Associado
Ellen Francine BarbosaProfessor Associado
Aracele Garcia de Oliveira FassbinderDoutoranda em Ciências de Computação e Matemática Computacional pela Universidade de São Paulo (USP). Professora efetiva no IFSULDEMINAS Campus Muzambinho.
Stevao Alves de AndradeDoutorando em Ciências de Computação e Matemática Computacional pela Universidade de São Paulo (USP).
Draylson Micael de SouzaDoutor em Ciências da Computação e Matemática Computacional
