SlideShare a Scribd company logo
1 of 40
Download to read offline
eXtreme Programming Brasil

    Testes de Unidade
    em Java com




Helder da Rocha (helder@acm.org)   argonavis.com.br
Objetivos

                       1. Apresentar o framework JUnit e demonstrar como
                         utilizá-lo para testar aplicações em Java
                       2. Discutir dificuldades relativas à prática de testar,
                         como descobrir testes, dependências, GUIs, etc.
                       3. Apresentar extensões do JUnit para lidar com
                         dificuldades e cenários específicos de teste
www.argonavis.com.br




                         Público-alvo:
                         Programadores Java


                                                                                    2
Por que testar?

                       Por que não?
                         Como saber se o recurso funciona sem testar?
                         Como saber se ainda funciona após refatoramento?
                       Testes dão maior segurança: coragem para mudar
                         Que adianta a OO isolar a interface da implementação
                         se programador tem medo de mudar a implementação?
                         Código testado é mais confiável
                         Código testado pode ser alterado sem medo
www.argonavis.com.br




                       Como saber quando o projeto está pronto
                         Testes == requisitos 'executáveis'
                         Testes de unidade devem ser executados o tempo todo
                         Escreva os testes antes. Quando todos rodarem 100%, o
                         projeto está concluído!
                                                                                 3
O que é JUnit?

                       Um framework que facilita o desenvolvimento e
                       execução de testes de unidade em código Java
                         Uma API para construir os testes
                         Aplicações para executar testes
                       A API
                         Classes Test, TestCase, TestSuite, etc. oferecem a
                         infraestrutura necessária para criar os testes
                         Métodos assertTrue(), assertEquals(), fail(), etc. são
www.argonavis.com.br




                         usados para testar os resultados
                       Aplicação TestRunner
                         Roda testes individuais e suites de testes
                         Versões texto, Swing e AWT
                         Apresenta diagnóstico sucesso/falha e detalhes
                                                                                  4
Para que serve?

                       'Padrão' para testes de unidade em Java
                         Desenvolvido por Kent Beck e Erich Gamma
                         Design muito simples
                       Testar é uma boa prática, mas é chato; JUnit torna as
                       coisas mais agradáveis, facilitando
                         A criação e execução automática de testes
                         A apresentação dos resultados
                       JUnit pode verificar se cada unidade de código funciona
www.argonavis.com.br




                       da forma esperada
                         Permite agrupar e rodar vários testes ao mesmo tempo
                         Na falha, mostra a causa em cada teste
                       Serve de base para extensões
                                                                                 5
Arquitetura do JUnit

                            Diagrama de classes
www.argonavis.com.br




                       Fonte: Manual do JUnit (Cooks Tour)
                                                                                    6
Como usar o JUnit?

                       Há várias formas de usar o JUnit. Depende da
                       metodologia de testes que está sendo usada
                         Código existente: precisa-se escrever testes para
                         classes que já foram implementadas
                         Desenvolvimento guiado por testes (TDD): código novo
                         só é escrito se houver um teste sem funcionar
                       Onde obter?
                         www.junit.org
www.argonavis.com.br




                       Como instalar?
                         Incluir o arquivo junit.jar no classpath para compilar e
                         rodar os programas de teste


                                                                                    7
JUnit para testar código existente

                       Exemplo de um roteiro típico
                       1. Crie uma classe que estenda junit.framework.TestCase
                         para cada classe a ser testada
                          import junit.framework.*;
                          class SuaClasseTest extends TestCase {...}
                       2. Para cada método xxx(args) a ser testado defina um
                         método public void testXxx() no test case
                           SuaClasse:
www.argonavis.com.br




                              public boolean equals(Object o) { ... }
                           SuaClasseTest:
                              public void testEquals() {...}
                         Sobreponha o método setUp(), se necessário
                         Sobreponha o método tearDown(), se necessário
                                                                                 8
JUnit para guiar o desenvolvimento

                       Cenário de Test-Driven Development (TDD)
                       1. Defina uma lista de tarefas a implementar
                       2. Escreva uma classe (test case) e implemente um
                         método de teste para uma tarefa da lista.
                       3. Rode o JUnit e certifique-se que o teste falha
                       4. Implemente o código mais simples que rode o teste
                           Crie classes, métodos, etc. para que código compile
                           Código pode ser código feio, óbvio, mas deve rodar!
www.argonavis.com.br




                       5. Refatore o código para remover a duplicação de dados
                       6. Escreva mais um teste ou refine o teste existente
                       7. Repita os passos 2 a 6 até implementar toda a lista

                                                                                 9
Como implementar?

                        Dentro de cada teste, utilize os métodos herdados da
                        classe TestCase
                           assertEquals(objetoEsperado, objetoRecebido),
                           assertTrue(valorBooleano), assertNotNull(objeto)
                           assertSame(objetoUm, objetoDois), fail (), ...
                        Exemplo de test case com um setUp() e um teste:
                       public class CoisaTest extends TestCase {
                         // construtor padrão omitido
www.argonavis.com.br




                         private Coisa coisa;
                         public void setUp() { coisa = new Coisa("Bit"); }
                         public void testToString() {
                           assertEquals("<coisa>Bit</coisa>",
                                         coisa.toString());
                         }
                       }
                                                                               10
Como funciona?

                       O TestRunner recebe uma subclasse                TestCase
                       de junit.framework.TestCase                      setUp()
                         Usa reflection para descobrir seus métodos     tearDown()

                       Para cada método testXXX(), executa:
                         1. o método setUp()
                                                                       MeuTestCase
                         2. o próprio método testXXX()
                                                                       setUp()
                         3. o método tearDown()                        testXXX()
                       O test case é instanciado para executar         testYYY()
www.argonavis.com.br




                                                                       tearDown()
                       um método testXXX() de cada vez.
                         As alterações que ele fizer ao estado do objeto não
                         afetarão os demais testes
                       Método pode terminar, falhar ou provocar exceção
                                                                                     11
Exemplo: uma classe

                       package junitdemo;
                       import java.io.*;

                       public class TextUtils {

                           public static String removeWhiteSpaces(String text)
                                                                  throws IOException {
                             StringReader reader = new StringReader(text);
                             StringBuffer buffer = new StringBuffer(text.length());
                             int c;
                             while( (c = reader.read()) != -1) {
                               if (c ==' '||c =='n'||c =='r'|| c =='f'||c =='t') {
www.argonavis.com.br




                                  ; /* do nothing */
                               } else {
                                  buffer.append((char)c);
                               }
                             }
                             return buffer.toString();
                                                                             veja código em
                           }
                       }                                                         junitdemo.zip
                                                                                                 12
Exemplo: um test case para a classe
                       package junitdemo;                              Construtor precisa ser
                                                                       publico, receber String
                       import junit.framework.*;                       name e chamar
                       import java.io.IOException;                     super(String name)

                       public class TextUtilsTest extends TestCase {

                           public TextUtilsTest(String name) {
                               super(name);                       Método começa com "test"
                           }                                       e é sempre public void
                           public void testRemoveWhiteSpaces() throws IOException {
                               String testString = "one, ( two | three+) ,      "+
www.argonavis.com.br




                                                   "(((four+ |t five)?n n, six?";
                               String expectedString = "one,(two|three+)"+
                                                       ",(((four+|five)?,six?";
                               String results = TextUtils.removeWhiteSpaces(testString);
                               assertEquals(expectedString, results);
                           }
                       }

                                                                                                 13
Exemplo: como executar
                           Use a interface de texto                        veja demonstração em

                             java -cp junit.jar junit.textui.TestRunner     junitdemo.zip
                                junitdemo.TextUtilsTest
                           Ou use a interface gráfica
                             java -cp junit.jar junit.swingui.TestRunner
                                junitdemo.TextUtilsTest
                           Use Ant <junit>
                             tarefa do Apache Ant
www.argonavis.com.br




                           Ou forneça um main():
                       public static void main (String[] args) {
                           TestSuite suite =
                             new TestSuite(TextUtilsTest.class);
                           junit.textui.TestRunner.run(suite);
                       }

                                                                                            14
TestSuite
                           Permite executar uma coleção de testes
                              Método addTest(TestSuite) adiciona um teste na lista
                           Padrão de codificação (usando reflection):
                              retornar um TestSuite em cada test-case:
                              public static TestSuite suite() {
                                 return new TestSuite(SuaClasseTest.class);
                              }
                              criar uma classe AllTests que combina as suites:
                                  public class AllTests {
                                      public static Test suite() {
www.argonavis.com.br




                        Pode incluir      TestSuite testSuite =
                       outras suites                      new TestSuite("Roda tudo");
                                          testSuite.addTest(pacote.AllTests.suite());
                                          testSuite.addTest(MinhaClasseTest.suite());
                                          testSuite.addTest(SuaClasseTest.suite());
                                          return testSuite;
                                                                           veja demonstração em
                                      }
                                  }                                          junitdemo.zip        15
Fixtures
                       São os dados reutilizados por vários testes
                          Inicializados no setUp() e destruídos no tearDown() (se necessário)
                        public class AttributeEnumerationTest extends TestCase {
                            String   testString;
                            String[] testArray;
                            AttributeEnumeration testEnum;                 Fixture
                            public void setUp() {
                                testString = "(alpha|beta|gamma)";
                                testArray = new String[]{"alpha", "beta", "gamma"};
                                testEnum = new AttributeEnumeration(testArray);
                            }
                            public void testGetNames() {
                                assertEquals(testEnum.getNames(), testArray);
                            }
www.argonavis.com.br




                            public void testToString() {
                                assertEquals(testEnum.toString(), testString);
                            }
                        (...)


                       Extensão JXUnit (jxunit.sourceforge.net) permite manter
                       dados de teste em arquivo XML (*.jxu) separado do código
                          Mais flexibilidade. Permite escrever testes         veja exemplo

                          mais rigorosos, com muitos dados                     jxunitdemo.zip   16
Teste situações de falha

                        É tão importante testar o cenário de falha do seu
                        codigo quanto o sucesso
                        Método fail() provoca uma falha
                           Use para verificar se exceções ocorrem quando se espera
                           que elas ocorram
                        Exemplo
                       public void testEntityNotFoundException() {
                          resetEntityTable(); // no entities to resolve!
www.argonavis.com.br




                          try {
                             // Following method call must cause exception!
                             ParameterEntityTag tag = parser.resolveEntity("bogus");
                             fail("Should have caused EntityNotFoundException!");
                          } catch (EntityNotFoundException e) {
                              // success: exception occurred as expected
                          }
                       }
                                                                                       17
Afirmações do J2SDK1.4 (assertions)
                       São expressões booleanas que o programador define para
                       afirmar uma condição que ele acredita ser verdade
                         Afirmações são usadas para validar código (ter a certeza que
                         um vetor tem determinado tamanho, ter a certeza que o
                         programa não passou por determinado lugar)
                         Melhoram a qualidade do código: tipo de teste
                         Devem ser usadas durante o desenvolvimento e desligadas na
                         produção (afeta a performance)
                         Não devem ser usadas como parte da lógica do código
www.argonavis.com.br




                       Afirmações são um recurso novo do JSDK1.4.0
                         Nova palavra-chave: assert
                         É preciso compilar usando a opção -source 1.4:
                         > javac -source 1.4 Classe.java
                         Para executar, é preciso habilitar afirmações (enable assertions):
                         > java -ea Classe
                                                                                              18
JUnit vs. afirmações
                       Afirmações do J2SDK 1.4 são usadas dentro do código
                          Podem incluir testes dentro da lógica procedural de um programa
                           if (i%3 == 0) {
                              doThis();
                           } else if (i%3 == 1) {
                              doThat();
                           } else {
                              assert i%3 == 2: "Erro interno!";
                           }

                          Provocam um AssertionError quando falham (que pode ser
                          encapsulado pelas exceções do JUnit)
                       Afirmações do JUnit são usadas em classe separada (TestCase)
www.argonavis.com.br




                          Não têm acesso ao interior dos métodos (verificam se a interface
                          dos métodos funciona como esperado)
                       Afirmações do J2SDK1.4 e JUnit são complementares
                          JUnit testa a interface dos métodos
                          assert testa trechos de lógica dentro dos métodos    veja exemplo

                                                                                junitdemo.zip   19
Limitações do JUnit

                       Acesso aos dados de métodos sob teste
                         Métodos private e variáveis locais não podem ser
                         testadas com JUnit.
                         Dados devem ser pelo menos package-private (friendly)
                       Soluções com refatoramento
                         Isolar em métodos private apenas código inquebrável
                         Transformar métodos private em package-private
                            Desvantagem: quebra ou redução do encapsulamento
www.argonavis.com.br




                            Classes de teste devem estar no mesmo pacote que as classes
                            testadas para ter acesso
                       Solução usando extensão do JUnit
                         JUnitX: usa reflection para ter acesso a dados private
                         http://www.extreme-java.de/junitx/index.html
                                                                                          20
Como escrever bons testes

                       JUnit facilita bastante a criação e execução de testes,
                       mas elaborar bons testes exige mais
                         O que testar? Como saber se testes estão completos?
                       "Teste tudo o que pode falhar" [2]
                         Métodos triviais (get/set) não precisam ser testados.
                         E se houver uma rotina de validação no método set?
                       É melhor ter testes a mais que testes a menos
                         Escreva testes curtos (quebre testes maiores)
www.argonavis.com.br




                         Use assertNotNull() (reduz drasticamente erros de
                         NullPointerException difíceis de encontrar)
                         Reescreva seu código para que fique mais fácil de testar


                                                                                    21
Como descobrir testes?

                       Listas de tarefas (to-do list)
                          Comece pelas mais simples e deixe os testes "realistas"
                          para o final
                          Requerimentos, use-cases, diagramas UML: rescreva os
                          requerimentos em termos de testes
                       Dados
                          Use apenas dados suficientes (não teste 10 condições
                          se três forem suficientes)
www.argonavis.com.br




                       Bugs revelam testes
                          Achou um bug? Não conserte sem antes escrever um
                          teste que o pegue (se você não o fizer, ele volta)!


                                                                                    22
Test-Driven Development (TDD)

                       Desenvolvimento guiado pelos testes
                         Só escreva código novo se um teste falhar
                         Refatore até que o teste funcione
                         Alternância: "red/green/refactor" - nunca passe mais de
                         10 minutos sem que a barra do JUnit fique verde.
                       Técnicas
                         "Fake It Til You Make It": faça um teste rodar
                         simplesmente fazendo método retornar constante
www.argonavis.com.br




                         Triangulação: abstraia o código apenas quando houver
                         dois ou mais testes que esperam respostas diferentes
                         Implementação óbvia: se operações são simples,
                         implemente-as e faça que os testes rodem

                                                                                   23
Como lidar com testes difíceis
                       Testes devem ser simples e suficientes
                         XP: design mais simples que resolva o problema;
                         sempre pode-se escrever novos testes, quando necessário
                       Não complique
                         Não teste o que é responsabilidade de outra classe/método
                         Assuma que outras classes e métodos funcionam
                       Testes difíceis (ou que parecem difíceis)
                         Aplicações gráficas: eventos, layouts, threads
                         Objetos inaccessíveis, métodos privativos, Singletons
www.argonavis.com.br




                         Objetos que dependem de outros objetos
                         Objetos cujo estado varia devido a fatores imprevisíveis
                       Soluções
                         Alterar o design da aplicação para facilitar os testes
                         Simular dependências usando proxies e stubs
                                                                                     24
Como testar GUIs
                       O que testar? [11]
                          Assumir que GUI (Swing, AWT, etc.) funciona
                          Concentrar-se na lógica de negócio e não na UI
                       Como testar?
                          "Emagrecer" o código para reduzir a chance de falha
                          Usar MVC: isolar lógica de apresentação e controle
                          Separar código confiável do código que pode falhar
                          Usar mediadores (Mediator pattern) para intermediar
www.argonavis.com.br




                          interações entre componentes
                       Exemplo: event handlers
                          Devem ter 0% de lógica de negócio: "A Stupid GUI is an
                          Unbreakable GUI" (Robert Koss, Object Mentor) [5]
                          Responsabilidades delegadas a mediadores testáveis
                                                                                   25
Dependência de código-fonte

                            Problema
                                Como testar componente que depende do código de
                                outros componentes?
                                Classe-alvo não oferece o que testar: Tanque
                                                                         +nivel()
                                        CarroTest             Carro
                                      +testAcelera()        +acelera()
                                                                          Ignição
                                                                         +ligada()
                               Se houver tinta e se houver papel
www.argonavis.com.br




                               método void imprime() public void testAcelera() {
                               deve funcionar                  Carro carro =
                                                                         new Carro();
                               Como saber se há ou não         carro.acelera();
                               tinta e papel?                  assert???(???);
                                                                }
                       Fonte: www.objectmentor.com, 2002                                26
Stubs: objetos "impostores"

                            É possível remover dependências de código-fonte
                            refatorando o código para usar interfaces
                               antes                                   depois
                                                                     «interface»              A não conhece mais o
                           A              B                 A          InterB           B
                                                                                                tipo concreto de B

                            Agora B pode ser substituída por um stub
                                 BStub está sob controle total de ATest (1)
                                 Em alguns casos, ATest pode implementar InterB (2)
www.argonavis.com.br




                                                       «interface»                                      «interface»
                         ATest                A                                 ATest       A             InterB
                                                         InterB
                                                                                            (2)
                                              (1)

                               « cria »             BStub       B                  self-shunt pattern           B

                       Fonte: www.objectmentor.com, 2002                                                              27
Dependência: solução usando stubs
                                                                        «interface»
                                                                         Tanque
                                                                     +nivel():float    TanqueImpl
                                                                                       +nivel():float
                                CarroTest                    Carro
                             +testTanqueVazioSemIgn()      +acelera()
                             +testTanqueCheioSemIgn()
                             +testTanqueVazioComIgn()
                                                                      «interface»
                             +testTanqueCheioComIgn()                   Ignicao
                                                                     +ligada(): bool    IgnicaoImpl
                                                                                       +ligada():bool
www.argonavis.com.br




                            Quando usar stubs
                                Dependência não existe ainda (não está pronta)
                                Dependências tem estado mutante, imprevisível ou
                                estão indisponíveis durante o desenvolvimento
                                    BDs, servidores de aplicação, servidores Web, hardware
                       Fonte: www.objectmentor.com, 2002                                                28
Dependências de servidores

                       Usar stubs para simular serviços e dados
                         É preciso implementar classes que devolvam as respostas
                         esperadas para diversas situações
                         Complexidade muito grande da dependência pode não
                         compensar investimento (não deixe de fazer testes por
                         causa disto!)
                         Vários tipos de stubs: mock objects, self-shunts.
                       Usar proxies (mediadores) para serviços reais
www.argonavis.com.br




                         Oferecem interface para simular comunicação e testa a
                         integração real do componente com seu ambiente
                         Não é teste unitário: teste pode falhar quando código
                         está correto (se os fatores externos falharem)

                                                                                 29
Mock Objects
                       Mock objects (MO) é uma estratégia similar ao uso de
                       stubs mas que não implementa nenhuma lógica
                         Um mock object não é, portanto, um stub, pois não simula
                         o funcionamento do objeto em qualquer situação
                       Comportamento é controlado pela classe de teste que
                         Define comportamento esperado (valores retornados, etc.)
                         Passa MO configurado para objeto a ser testado
                         Chama métodos do objeto (que usam o MO)
www.argonavis.com.br




                       Implementações open-source que facilitam uso de MOs
                         EasyMock (tammofreese.de/easymock/) e MockMaker
                         (www.xpdeveloper.com) geram MOs a partir de interfaces
                         Projeto MO (mockobjects.sourceforge.net) coleção de mock
                         objects e utilitários para usá-los
                                                                      mockdemo.zip
                                                                veja exemplo
                                                                                     30
Testes de interface
                       Caso específico: resposta de servidores Web
                         Verificar se uma página HTML ou XML contém
                         determinado texto ou determinado elemento
                         Verificar se resposta está de acordo com dados passados
                         na requisição: testes funcionais tipo "caixa-preta"
                       Soluções (extensões do JUnit)
                         HttpUnit e ServletUnit:
                           permite testar dados de árvore DOM HTML gerada
www.argonavis.com.br




                         JXWeb (combinação do JXUnit com HttpUnit)
                           permite especificar os dados de teste em arquivos XML
                           arquivos de teste Java são gerados a partir do XML
                         XMLUnit
                           extensão simples para testar árvores XML
                         Onde encontrar: (httpunit|jxunit|xmlunit).sourceforge.net
                                                                                     31
Testes de performance

                       JUnitPerf (www.clarkware.com)
                         Coleção de decoradores para medir performance e
                         escalabilidade em testes JUnit existentes
                       TimedTest
                         Executa um teste e mede o tempo transcorrido
                         Define um tempo máximo para a execução. Teste falha se
                         execução durar mais que o tempo estabelecido
                       LoadTest
                         Executa um teste com uma carga simulada
www.argonavis.com.br




                         Utiliza timers para distribuir as cargas usando distribuições
                         randômicas
                         Combinado com TimerTest para medir tempo com carga
                       ThreadedTest
                         Executa o teste em um thread separado
                                                                                         32
JUnitPerf: exemplo

                       import com.clarkware.junitperf.*;
                       import junit.framework.*;

                       public class ExampleLoadTest extends TestCase {
                         public ExampleLoadTest(String name) { super(name); }
                         public static Test suite() {
                            TestSuite suite = new TestSuite();
                            Timer timer = new ConstantTimer(1000);
                                                                       TestCase existente
                            int maxUsr = 10;
                            int iters = 10;                                  Decorador de carga
                            long maxElapsedTime = 20000;
                            Test test = new ExampleTestCase("testOneSecondResp");
www.argonavis.com.br




                            Test loadTest = new LoadTest(test, maxUsr, iters, timer);
                            Test timedTest = new TimedTest(loadTest, maxElapsedTime);
                            suite.addTest(timedTest);
                            return suite;               Decorador de tempo
                         }                                                        Example
                                                                                 TestCase
                         public static void main(String args[]) {
                                                                                 LoadTest
                           junit.textui.TestRunner.run(suite());
                         }                                                       TimedTest
                       }                                 TestRunner                Suite
                                                                                                  33
Ant + JUnit

                       Ant: ferramenta para automatizar processos de
                       construção de aplicações Java
                       Pode-se executar todos os testes após a integração com
                       um único comando:
                         ant roda-testes
                       Com as tarefas <junit> e <junitreport> é possível
                         executar todos os testes
                         gerar um relatório simples ou detalhado, em diversos
www.argonavis.com.br




                         formatos (XML, HTML, etc.)
                         executar testes de integração
                       São tarefas opcionais. É preciso ter no $ANT_HOME/lib
                         optional.jar (distribuído com Ant)
                         junit.jar    (distribuído com JUnit)
                                                                                34
Exemplo: <junit>
                       <target name="test" depends="build">
                          <junit printsummary="true" dir="${build.dir}"
                                 fork="true">
                             <formatter type="plain" usefile="false" />
                             <classpath path="${build.dir}" /
                             <test name="argonavis.dtd.AllTests" />
                          </junit>
                       </target>                           Formata os dados na tela (plain)
                                                            Roda apenas arquivo AllTests
                       <target name="batchtest" depends="build" >
                          <junit dir="${build.dir}" fork="true">
                             <formatter type="xml" usefile="true" />
                             <classpath path="${build.dir}" />
www.argonavis.com.br




                             <batchtest todir="${test.report.dir}">
                                <fileset dir="${src.dir}">
                                    <include name="**/*Test.java" />
                                    <exclude name="**/AllTests.java" />
                                </fileset>
                             </batchtest>              Gera arquivo XML
                          </junit>                Inclui todos os arquivos que
                       </target>                    terminam em TEST.java
                                                                                         35
<junitreport>

                         Gera um relatório detalhado (estilo JavaDoc) de todos
                         os testes, sucessos, falhas, exceções, tempo, ...
                       <target name="test-report" depends="batchtest" >
                         <junitreport todir="${test.report.dir}">
                           <fileset dir="${test.report.dir}">          Usa arquivos XML
                              <include name="TEST-*.xml" />               gerados por
                           </fileset>                                   <formatter>
                           <report todir="${test.report.dir}/html"
                                   format="frames" />
                         </junitreport>
www.argonavis.com.br




                       </target>

                            veja demonstração

                             junitdemo.zip

                                     veja demonstração

                                      dtdreader.zip
                                                                                    36
Resumo e conclusões

                       JUnit é uma ferramenta open-source que ajuda a
                       implementar testes em projetos Java
                       Com JUnit, é fácil viabilizar práticas como Refactoring,
                       Integração Contínua e Test-Driven Development (TDD)
                       Em um processo TDD, testes que falham são escritos no
                       JUnit para que, a partir deles, se possa implementar
                       código que os faça rodar com sucesso
                       Mock objects podem ser usados para representar
www.argonavis.com.br




                       dependência e diminuir as responsabilidades de testes
                       Para testes em domínios específicos e para lidar com
                       limitações do JUnit há várias extensões open-source
                         HttpUnit, Cactus, JUnitPerf, JXUnit, JUnitX, JUnitEE ...
                                                                                    37
Fontes (1)
                       [1] R.   Hightower, N. Lesiecki. Java Tools for eXtreme Programming. Wiley, 2002.
                             Explora ferramentas Ant, JUnit, Cactus e outras usando estudo de caso com processo XP.

                       [2]   Jeffries, Anderson, Hendrickson. eXtreme Programming Installed, Addison-
                             Wesley, 2001. Contém exemplos de estratégias para testes.
                       [3] Kent   Beck, Erich Gamma. JUnit Test Infected: programmers love writing tests.
                             (JUnit docs). Aprenda a usar JUnit em uma hora.
                       [4]   Andy Schneider. JUnit Best Practices. JavaWorld, Dec. 2000. Dicas do que fazer ou
                             não fazer para construir bons testes.

                       [5] Robert     Koss, Testing Things that are Hard to Test. Object Mentor, 2002
www.argonavis.com.br




                             http://www.objectmentor.com/resources/articles/TestingThingsThatAreHa~9740.ppt. Mostra
                             estratégias para testar GUIs e código com dependências usando stubs.




                                                                                                                      38
Fontes (2)
                       [6] Mackinnon,       Freeman, Craig. Endo-testing with Mock Objects.
                             http://mockobjects.sourceforge.net/misc/mockobjects.pdf. O autor apresenta técnicas para
                             testes usando uma variação da técnica de stubs chamada de "mock objects".

                       [7] William     Wake. Test/Code Cycle in XP. Part 1: Model, Part II: GUI.
                             http://users.vnet.net/wwake/xp/xp0001/. Ótimo tutorial em duas partes sobre a metodologia
                             "test-first" mostrando estratégias para testar GUIs na segunda parte.

                       [8]   Steve Freeman, Developing JDBC Applications Test First. 2001. Tutorial sobre
                             metodolodia test-first com mock objects para JDBC.

                       [9]   Martin Fowler. Refactoring: improving the design of existing code. Addison-
                             Wesley, 2000. Cap 4 (building tests) é um tutorial usando JUnit.
www.argonavis.com.br




                       [10]   Kent Beck. Test-driven development. Addison-Wesley, 2002. Mostra como
                             utilizar testes como "requerimentos executáveis" para guiar o desenvolvimento.




                                                                                                                         39
Palestra: JUnit


              helder@argonavis.com.br

         Selecione o link relativo a esta palestra no endereço

www.argonavis.com.br/xpbrasil2002
  Recursos disponíveis no site:
  • Palestra completa em PDF
  • Todo o código-fonte usado nos exemplos e demonstrações
  • Instruções detalhadas sobre como rodar e instalar os exemplos
  • Links para software utilizado e documentação


          Tutorial: Implementando eXtreme Programming em Java
                         XP Brasil 2002, São Paulo
                         © 2002, Helder da Rocha

More Related Content

What's hot

Desenvolvimento Dirigido por Testes com Junit
Desenvolvimento Dirigido por Testes com JunitDesenvolvimento Dirigido por Testes com Junit
Desenvolvimento Dirigido por Testes com JunitAdolfo Neto
 
Testes de Unidade com JUnit
Testes de Unidade com JUnitTestes de Unidade com JUnit
Testes de Unidade com JUnitelliando dias
 
Testes de Unidade com Junit
Testes de Unidade com JunitTestes de Unidade com Junit
Testes de Unidade com Junitcejug
 
Apresentacao Testes de Unidade
Apresentacao Testes de UnidadeApresentacao Testes de Unidade
Apresentacao Testes de UnidadeAline Ferreira
 
Escrevendo testes j unit no net beans ide
Escrevendo testes j unit no net beans ideEscrevendo testes j unit no net beans ide
Escrevendo testes j unit no net beans ideSocorro Vania Alves
 
Aexo TI - Boas práticas de testes tdd
Aexo TI - Boas práticas de testes tddAexo TI - Boas práticas de testes tdd
Aexo TI - Boas práticas de testes tddCarlos Santana
 
Testes Unitários/Integrados
Testes Unitários/IntegradosTestes Unitários/Integrados
Testes Unitários/IntegradosGiovanni Bassi
 
Testando Aplicações Django: Quando, Como e Onde?
Testando Aplicações Django: Quando, Como e Onde?Testando Aplicações Django: Quando, Como e Onde?
Testando Aplicações Django: Quando, Como e Onde?Bernardo Fontes
 
Padrões para Desenvolvimento de Software Guiado por Testes
Padrões para Desenvolvimento de Software Guiado por TestesPadrões para Desenvolvimento de Software Guiado por Testes
Padrões para Desenvolvimento de Software Guiado por TestesEverton Rodrigues
 
Mineração de Repositórios de Defeitos
Mineração de Repositórios de DefeitosMineração de Repositórios de Defeitos
Mineração de Repositórios de DefeitosRodrigo Rocha
 

What's hot (20)

Desenvolvimento Dirigido por Testes com Junit
Desenvolvimento Dirigido por Testes com JunitDesenvolvimento Dirigido por Testes com Junit
Desenvolvimento Dirigido por Testes com Junit
 
Testes de Unidade com JUnit
Testes de Unidade com JUnitTestes de Unidade com JUnit
Testes de Unidade com JUnit
 
Testes de Unidade com Junit
Testes de Unidade com JunitTestes de Unidade com Junit
Testes de Unidade com Junit
 
Testes Unitários
Testes UnitáriosTestes Unitários
Testes Unitários
 
Apresentacao Testes de Unidade
Apresentacao Testes de UnidadeApresentacao Testes de Unidade
Apresentacao Testes de Unidade
 
Teste Driven Development
Teste Driven DevelopmentTeste Driven Development
Teste Driven Development
 
Palestra Testes De Unidade Com JUnit
Palestra Testes De Unidade Com JUnitPalestra Testes De Unidade Com JUnit
Palestra Testes De Unidade Com JUnit
 
Escrevendo testes j unit no net beans ide
Escrevendo testes j unit no net beans ideEscrevendo testes j unit no net beans ide
Escrevendo testes j unit no net beans ide
 
Aexo TI - Boas práticas de testes tdd
Aexo TI - Boas práticas de testes tddAexo TI - Boas práticas de testes tdd
Aexo TI - Boas práticas de testes tdd
 
Gof design patterns
Gof design patternsGof design patterns
Gof design patterns
 
TDD (Resumo)
TDD (Resumo)TDD (Resumo)
TDD (Resumo)
 
Testes de Sistema
Testes de SistemaTestes de Sistema
Testes de Sistema
 
TDD em 220V
TDD em 220VTDD em 220V
TDD em 220V
 
TDD com Python (Completo)
TDD com Python (Completo)TDD com Python (Completo)
TDD com Python (Completo)
 
Testes Unitários/Integrados
Testes Unitários/IntegradosTestes Unitários/Integrados
Testes Unitários/Integrados
 
JUnit Sample
JUnit SampleJUnit Sample
JUnit Sample
 
Testes Unitários
Testes UnitáriosTestes Unitários
Testes Unitários
 
Testando Aplicações Django: Quando, Como e Onde?
Testando Aplicações Django: Quando, Como e Onde?Testando Aplicações Django: Quando, Como e Onde?
Testando Aplicações Django: Quando, Como e Onde?
 
Padrões para Desenvolvimento de Software Guiado por Testes
Padrões para Desenvolvimento de Software Guiado por TestesPadrões para Desenvolvimento de Software Guiado por Testes
Padrões para Desenvolvimento de Software Guiado por Testes
 
Mineração de Repositórios de Defeitos
Mineração de Repositórios de DefeitosMineração de Repositórios de Defeitos
Mineração de Repositórios de Defeitos
 

Viewers also liked

Modelo de Trabalhos Acadêmicos
Modelo de Trabalhos AcadêmicosModelo de Trabalhos Acadêmicos
Modelo de Trabalhos AcadêmicosDiego Fruscalso
 
Pathogenesis of asthma
Pathogenesis of asthmaPathogenesis of asthma
Pathogenesis of asthma9494606828
 
DBT Training 2 Day Workshop
DBT Training 2 Day WorkshopDBT Training 2 Day Workshop
DBT Training 2 Day Workshoptbrad0411
 
11 1 --teste_de_software_motivação_e_conceitos_basicos
11 1 --teste_de_software_motivação_e_conceitos_basicos11 1 --teste_de_software_motivação_e_conceitos_basicos
11 1 --teste_de_software_motivação_e_conceitos_basicosFabricio Guimaraes Soares
 
Teorias Psicopedagógicas do Ensino Aprendizagem
Teorias Psicopedagógicas do Ensino AprendizagemTeorias Psicopedagógicas do Ensino Aprendizagem
Teorias Psicopedagógicas do Ensino AprendizagemHebert Balieiro
 
Cálculo Diferencial - Curso Completo
Cálculo Diferencial - Curso CompletoCálculo Diferencial - Curso Completo
Cálculo Diferencial - Curso CompletoAndres Mendoza
 
32 ways to make your blog suck less
32 ways to make your blog suck less32 ways to make your blog suck less
32 ways to make your blog suck lessScott Hanselman
 

Viewers also liked (11)

Absolventa_LK
Absolventa_LKAbsolventa_LK
Absolventa_LK
 
Mendes&brito
Mendes&britoMendes&brito
Mendes&brito
 
Modelo de Trabalhos Acadêmicos
Modelo de Trabalhos AcadêmicosModelo de Trabalhos Acadêmicos
Modelo de Trabalhos Acadêmicos
 
5) liderança e administração eficaz (resumo do livro)
5) liderança e administração eficaz (resumo do livro)5) liderança e administração eficaz (resumo do livro)
5) liderança e administração eficaz (resumo do livro)
 
Pathogenesis of asthma
Pathogenesis of asthmaPathogenesis of asthma
Pathogenesis of asthma
 
DBT Training 2 Day Workshop
DBT Training 2 Day WorkshopDBT Training 2 Day Workshop
DBT Training 2 Day Workshop
 
11 1 --teste_de_software_motivação_e_conceitos_basicos
11 1 --teste_de_software_motivação_e_conceitos_basicos11 1 --teste_de_software_motivação_e_conceitos_basicos
11 1 --teste_de_software_motivação_e_conceitos_basicos
 
Teorias Psicopedagógicas do Ensino Aprendizagem
Teorias Psicopedagógicas do Ensino AprendizagemTeorias Psicopedagógicas do Ensino Aprendizagem
Teorias Psicopedagógicas do Ensino Aprendizagem
 
Cálculo Diferencial - Curso Completo
Cálculo Diferencial - Curso CompletoCálculo Diferencial - Curso Completo
Cálculo Diferencial - Curso Completo
 
32 ways to make your blog suck less
32 ways to make your blog suck less32 ways to make your blog suck less
32 ways to make your blog suck less
 
Pdf maria edlene correia
Pdf   maria edlene correiaPdf   maria edlene correia
Pdf maria edlene correia
 

Similar to J unit xp

Implementando Implementando eXtreme treme Programming rogramming em em Java Java
Implementando Implementando eXtreme treme Programming rogramming em em Java JavaImplementando Implementando eXtreme treme Programming rogramming em em Java Java
Implementando Implementando eXtreme treme Programming rogramming em em Java Javaelliando dias
 
Testes O que são e para que servem? - LadyTalks
Testes O que são e para que servem? - LadyTalksTestes O que são e para que servem? - LadyTalks
Testes O que são e para que servem? - LadyTalksDiana Ungaro Arnos
 
Validação e Testes de software
Validação e Testes de softwareValidação e Testes de software
Validação e Testes de softwareRondinelli Mesquita
 
Curso Básico de Selenium
Curso Básico de SeleniumCurso Básico de Selenium
Curso Básico de SeleniumAutotic
 
Introdução a testes automatizados
Introdução a testes automatizadosIntrodução a testes automatizados
Introdução a testes automatizadosThiago Ghisi
 
Pensando em java univali turbinando seus testes
Pensando em java univali   turbinando seus testesPensando em java univali   turbinando seus testes
Pensando em java univali turbinando seus testesSandro Giacomozzi
 
ABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDD
ABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDDABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDD
ABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDDRaphael Pacheco
 
Introdução a testes unitários automatizados com JUnit e NUnit
Introdução a testes unitários automatizados com JUnit e NUnitIntrodução a testes unitários automatizados com JUnit e NUnit
Introdução a testes unitários automatizados com JUnit e NUnitelliando dias
 
Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...
Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...
Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...Claudinei Brito Junior
 
Test-Driven Development (TDD) utilizando o framework xUnit.net
Test-Driven Development (TDD) utilizando o framework xUnit.netTest-Driven Development (TDD) utilizando o framework xUnit.net
Test-Driven Development (TDD) utilizando o framework xUnit.netRenato Groff
 
TDD - Pós Graduação em Engenharia de Software Ágil
TDD - Pós Graduação em Engenharia de Software ÁgilTDD - Pós Graduação em Engenharia de Software Ágil
TDD - Pós Graduação em Engenharia de Software ÁgilBruno Eustáquio
 

Similar to J unit xp (20)

Testes de Unidade com JUnit
Testes de Unidade com JUnitTestes de Unidade com JUnit
Testes de Unidade com JUnit
 
Implementando Implementando eXtreme treme Programming rogramming em em Java Java
Implementando Implementando eXtreme treme Programming rogramming em em Java JavaImplementando Implementando eXtreme treme Programming rogramming em em Java Java
Implementando Implementando eXtreme treme Programming rogramming em em Java Java
 
Android Aula 4
Android Aula 4Android Aula 4
Android Aula 4
 
Testes O que são e para que servem? - LadyTalks
Testes O que são e para que servem? - LadyTalksTestes O que são e para que servem? - LadyTalks
Testes O que são e para que servem? - LadyTalks
 
Validação e Testes de software
Validação e Testes de softwareValidação e Testes de software
Validação e Testes de software
 
Curso Básico de Selenium
Curso Básico de SeleniumCurso Básico de Selenium
Curso Básico de Selenium
 
Introdução a testes automatizados
Introdução a testes automatizadosIntrodução a testes automatizados
Introdução a testes automatizados
 
1° Madrugada de Testes
1° Madrugada de Testes1° Madrugada de Testes
1° Madrugada de Testes
 
Pensando em java univali turbinando seus testes
Pensando em java univali   turbinando seus testesPensando em java univali   turbinando seus testes
Pensando em java univali turbinando seus testes
 
Python com TDD
Python com TDDPython com TDD
Python com TDD
 
ABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDD
ABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDDABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDD
ABAP Code Retreat Brasil - Apagando tudo e começando novamente: Conhecendo o TDD
 
Introdução a testes unitários automatizados com JUnit e NUnit
Introdução a testes unitários automatizados com JUnit e NUnitIntrodução a testes unitários automatizados com JUnit e NUnit
Introdução a testes unitários automatizados com JUnit e NUnit
 
Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...
Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...
Minicurso - Técnicas de Teste e Automatização do Teste de Unidade XII SemanaT...
 
TDD com Python
TDD com PythonTDD com Python
TDD com Python
 
O que é Teste de Software?
O que é Teste de Software?O que é Teste de Software?
O que é Teste de Software?
 
J unit
J unitJ unit
J unit
 
Test-Driven Development (TDD) utilizando o framework xUnit.net
Test-Driven Development (TDD) utilizando o framework xUnit.netTest-Driven Development (TDD) utilizando o framework xUnit.net
Test-Driven Development (TDD) utilizando o framework xUnit.net
 
TDD - Pós Graduação em Engenharia de Software Ágil
TDD - Pós Graduação em Engenharia de Software ÁgilTDD - Pós Graduação em Engenharia de Software Ágil
TDD - Pós Graduação em Engenharia de Software Ágil
 
Testes Unitários
Testes UnitáriosTestes Unitários
Testes Unitários
 
Testes com JUnit
Testes com JUnitTestes com JUnit
Testes com JUnit
 

Recently uploaded

Antologia Literária NATAL em Versos 2023
Antologia Literária NATAL em Versos 2023Antologia Literária NATAL em Versos 2023
Antologia Literária NATAL em Versos 2023Nome Sobrenome
 
1. A atividade toda jurídica ocorre no plano do direito interno ou externo?
1. A atividade toda jurídica ocorre no plano do direito interno ou externo?1. A atividade toda jurídica ocorre no plano do direito interno ou externo?
1. A atividade toda jurídica ocorre no plano do direito interno ou externo?excellenceeducaciona
 
Slides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptx
Slides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptxSlides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptx
Slides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptxLuizHenriquedeAlmeid6
 
1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...
1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...
1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...excellenceeducaciona
 
Aula 2 - Beauty standards (Part 1) ula de inglês
Aula 2 - Beauty standards (Part 1) ula de inglêsAula 2 - Beauty standards (Part 1) ula de inglês
Aula 2 - Beauty standards (Part 1) ula de inglêsAldoBlfia1
 
5. Em caso de sentença condenatória do Estado agressor, quais as penas?
5. Em caso de sentença condenatória do Estado agressor, quais as penas?5. Em caso de sentença condenatória do Estado agressor, quais as penas?
5. Em caso de sentença condenatória do Estado agressor, quais as penas?excellenceeducaciona
 
Exercícios_Figuras_de_Linguagem para fundamental e medio
Exercícios_Figuras_de_Linguagem  para fundamental e medioExercícios_Figuras_de_Linguagem  para fundamental e medio
Exercícios_Figuras_de_Linguagem para fundamental e medioFernanda Mota
 
01. Considerando as informações da imagem acima, explique de formas simples e...
01. Considerando as informações da imagem acima, explique de formas simples e...01. Considerando as informações da imagem acima, explique de formas simples e...
01. Considerando as informações da imagem acima, explique de formas simples e...atividademapa3
 
Ensino Religioso Ensino Religioso Ensino Religioso
Ensino Religioso Ensino Religioso Ensino ReligiosoEnsino Religioso Ensino Religioso Ensino Religioso
Ensino Religioso Ensino Religioso Ensino ReligiosoLUZIATRAVASSO1
 
Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...
Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...
Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...excellenceeducaciona
 
Projeto escolar dia da água educação infantil e fundamental
Projeto escolar dia da água educação infantil e fundamentalProjeto escolar dia da água educação infantil e fundamental
Projeto escolar dia da água educação infantil e fundamentalDiana328805
 
Jean Piaget - Trajetória, teoria e contribuições para educação.
Jean Piaget - Trajetória, teoria e contribuições para educação.Jean Piaget - Trajetória, teoria e contribuições para educação.
Jean Piaget - Trajetória, teoria e contribuições para educação.marianedesouzapadua
 
Lição 10 - A Ceia do Senhor - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptx
Lição 10 - A Ceia do Senhor  - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptxLição 10 - A Ceia do Senhor  - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptx
Lição 10 - A Ceia do Senhor - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptxTiagoCarpesDoNascime
 
Introdução à Cartografia e Geoprocessamento - Conceitos Básicos
Introdução à Cartografia e Geoprocessamento - Conceitos  BásicosIntrodução à Cartografia e Geoprocessamento - Conceitos  Básicos
Introdução à Cartografia e Geoprocessamento - Conceitos BásicosVitor Vieira Vasconcelos
 
Trabalho Faculdade AD1 Didática - 2024 P
Trabalho Faculdade AD1 Didática - 2024 PTrabalho Faculdade AD1 Didática - 2024 P
Trabalho Faculdade AD1 Didática - 2024 PWallasTmara
 
Slides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptx
Slides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptxSlides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptx
Slides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptxLuizHenriquedeAlmeid6
 

Recently uploaded (20)

Antologia Literária NATAL em Versos 2023
Antologia Literária NATAL em Versos 2023Antologia Literária NATAL em Versos 2023
Antologia Literária NATAL em Versos 2023
 
1. A atividade toda jurídica ocorre no plano do direito interno ou externo?
1. A atividade toda jurídica ocorre no plano do direito interno ou externo?1. A atividade toda jurídica ocorre no plano do direito interno ou externo?
1. A atividade toda jurídica ocorre no plano do direito interno ou externo?
 
Os textos contemporâneos na construção da opinião.
Os textos contemporâneos na construção  da opinião.Os textos contemporâneos na construção  da opinião.
Os textos contemporâneos na construção da opinião.
 
Slides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptx
Slides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptxSlides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptx
Slides Lição 12, BETEL, O verdadeiro sentido de serem dois em um, 1Tr24.pptx
 
1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...
1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...
1) De posse do conhecimento da sequência molde do DNA (gene), necessária para...
 
Aula 2 - Beauty standards (Part 1) ula de inglês
Aula 2 - Beauty standards (Part 1) ula de inglêsAula 2 - Beauty standards (Part 1) ula de inglês
Aula 2 - Beauty standards (Part 1) ula de inglês
 
5. Em caso de sentença condenatória do Estado agressor, quais as penas?
5. Em caso de sentença condenatória do Estado agressor, quais as penas?5. Em caso de sentença condenatória do Estado agressor, quais as penas?
5. Em caso de sentença condenatória do Estado agressor, quais as penas?
 
Exercícios_Figuras_de_Linguagem para fundamental e medio
Exercícios_Figuras_de_Linguagem  para fundamental e medioExercícios_Figuras_de_Linguagem  para fundamental e medio
Exercícios_Figuras_de_Linguagem para fundamental e medio
 
01. Considerando as informações da imagem acima, explique de formas simples e...
01. Considerando as informações da imagem acima, explique de formas simples e...01. Considerando as informações da imagem acima, explique de formas simples e...
01. Considerando as informações da imagem acima, explique de formas simples e...
 
Ensino Religioso Ensino Religioso Ensino Religioso
Ensino Religioso Ensino Religioso Ensino ReligiosoEnsino Religioso Ensino Religioso Ensino Religioso
Ensino Religioso Ensino Religioso Ensino Religioso
 
Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...
Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...
Explique o modelo de determinação social da saúde proposto por Dahlgren e Whi...
 
NBR 10520.2023. Citações. 1s24 (revisão em 09mar24).pdf
NBR 10520.2023. Citações. 1s24 (revisão em 09mar24).pdfNBR 10520.2023. Citações. 1s24 (revisão em 09mar24).pdf
NBR 10520.2023. Citações. 1s24 (revisão em 09mar24).pdf
 
Projeto escolar dia da água educação infantil e fundamental
Projeto escolar dia da água educação infantil e fundamentalProjeto escolar dia da água educação infantil e fundamental
Projeto escolar dia da água educação infantil e fundamental
 
Jean Piaget - Trajetória, teoria e contribuições para educação.
Jean Piaget - Trajetória, teoria e contribuições para educação.Jean Piaget - Trajetória, teoria e contribuições para educação.
Jean Piaget - Trajetória, teoria e contribuições para educação.
 
Lição 10 - A Ceia do Senhor - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptx
Lição 10 - A Ceia do Senhor  - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptxLição 10 - A Ceia do Senhor  - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptx
Lição 10 - A Ceia do Senhor - A Segunda Ordenança da Igreja(COM ANIMAÇÃO).pptx
 
Introdução à Cartografia e Geoprocessamento - Conceitos Básicos
Introdução à Cartografia e Geoprocessamento - Conceitos  BásicosIntrodução à Cartografia e Geoprocessamento - Conceitos  Básicos
Introdução à Cartografia e Geoprocessamento - Conceitos Básicos
 
Complementação: Aplicando as Normas da ABNT. 1s24.pdf
Complementação: Aplicando as Normas da ABNT. 1s24.pdfComplementação: Aplicando as Normas da ABNT. 1s24.pdf
Complementação: Aplicando as Normas da ABNT. 1s24.pdf
 
Trabalho Faculdade AD1 Didática - 2024 P
Trabalho Faculdade AD1 Didática - 2024 PTrabalho Faculdade AD1 Didática - 2024 P
Trabalho Faculdade AD1 Didática - 2024 P
 
Slides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptx
Slides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptxSlides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptx
Slides Lição 13, CPAD, O Poder de Deus na Missão da Igreja.pptx
 
Sugestões para a montagem e desenvolvimento de slides.pdf
Sugestões para a montagem e desenvolvimento de slides.pdfSugestões para a montagem e desenvolvimento de slides.pdf
Sugestões para a montagem e desenvolvimento de slides.pdf
 

J unit xp

  • 1. eXtreme Programming Brasil Testes de Unidade em Java com Helder da Rocha (helder@acm.org) argonavis.com.br
  • 2. Objetivos 1. Apresentar o framework JUnit e demonstrar como utilizá-lo para testar aplicações em Java 2. Discutir dificuldades relativas à prática de testar, como descobrir testes, dependências, GUIs, etc. 3. Apresentar extensões do JUnit para lidar com dificuldades e cenários específicos de teste www.argonavis.com.br Público-alvo: Programadores Java 2
  • 3. Por que testar? Por que não? Como saber se o recurso funciona sem testar? Como saber se ainda funciona após refatoramento? Testes dão maior segurança: coragem para mudar Que adianta a OO isolar a interface da implementação se programador tem medo de mudar a implementação? Código testado é mais confiável Código testado pode ser alterado sem medo www.argonavis.com.br Como saber quando o projeto está pronto Testes == requisitos 'executáveis' Testes de unidade devem ser executados o tempo todo Escreva os testes antes. Quando todos rodarem 100%, o projeto está concluído! 3
  • 4. O que é JUnit? Um framework que facilita o desenvolvimento e execução de testes de unidade em código Java Uma API para construir os testes Aplicações para executar testes A API Classes Test, TestCase, TestSuite, etc. oferecem a infraestrutura necessária para criar os testes Métodos assertTrue(), assertEquals(), fail(), etc. são www.argonavis.com.br usados para testar os resultados Aplicação TestRunner Roda testes individuais e suites de testes Versões texto, Swing e AWT Apresenta diagnóstico sucesso/falha e detalhes 4
  • 5. Para que serve? 'Padrão' para testes de unidade em Java Desenvolvido por Kent Beck e Erich Gamma Design muito simples Testar é uma boa prática, mas é chato; JUnit torna as coisas mais agradáveis, facilitando A criação e execução automática de testes A apresentação dos resultados JUnit pode verificar se cada unidade de código funciona www.argonavis.com.br da forma esperada Permite agrupar e rodar vários testes ao mesmo tempo Na falha, mostra a causa em cada teste Serve de base para extensões 5
  • 6. Arquitetura do JUnit Diagrama de classes www.argonavis.com.br Fonte: Manual do JUnit (Cooks Tour) 6
  • 7. Como usar o JUnit? Há várias formas de usar o JUnit. Depende da metodologia de testes que está sendo usada Código existente: precisa-se escrever testes para classes que já foram implementadas Desenvolvimento guiado por testes (TDD): código novo só é escrito se houver um teste sem funcionar Onde obter? www.junit.org www.argonavis.com.br Como instalar? Incluir o arquivo junit.jar no classpath para compilar e rodar os programas de teste 7
  • 8. JUnit para testar código existente Exemplo de um roteiro típico 1. Crie uma classe que estenda junit.framework.TestCase para cada classe a ser testada import junit.framework.*; class SuaClasseTest extends TestCase {...} 2. Para cada método xxx(args) a ser testado defina um método public void testXxx() no test case SuaClasse: www.argonavis.com.br public boolean equals(Object o) { ... } SuaClasseTest: public void testEquals() {...} Sobreponha o método setUp(), se necessário Sobreponha o método tearDown(), se necessário 8
  • 9. JUnit para guiar o desenvolvimento Cenário de Test-Driven Development (TDD) 1. Defina uma lista de tarefas a implementar 2. Escreva uma classe (test case) e implemente um método de teste para uma tarefa da lista. 3. Rode o JUnit e certifique-se que o teste falha 4. Implemente o código mais simples que rode o teste Crie classes, métodos, etc. para que código compile Código pode ser código feio, óbvio, mas deve rodar! www.argonavis.com.br 5. Refatore o código para remover a duplicação de dados 6. Escreva mais um teste ou refine o teste existente 7. Repita os passos 2 a 6 até implementar toda a lista 9
  • 10. Como implementar? Dentro de cada teste, utilize os métodos herdados da classe TestCase assertEquals(objetoEsperado, objetoRecebido), assertTrue(valorBooleano), assertNotNull(objeto) assertSame(objetoUm, objetoDois), fail (), ... Exemplo de test case com um setUp() e um teste: public class CoisaTest extends TestCase { // construtor padrão omitido www.argonavis.com.br private Coisa coisa; public void setUp() { coisa = new Coisa("Bit"); } public void testToString() { assertEquals("<coisa>Bit</coisa>", coisa.toString()); } } 10
  • 11. Como funciona? O TestRunner recebe uma subclasse TestCase de junit.framework.TestCase setUp() Usa reflection para descobrir seus métodos tearDown() Para cada método testXXX(), executa: 1. o método setUp() MeuTestCase 2. o próprio método testXXX() setUp() 3. o método tearDown() testXXX() O test case é instanciado para executar testYYY() www.argonavis.com.br tearDown() um método testXXX() de cada vez. As alterações que ele fizer ao estado do objeto não afetarão os demais testes Método pode terminar, falhar ou provocar exceção 11
  • 12. Exemplo: uma classe package junitdemo; import java.io.*; public class TextUtils { public static String removeWhiteSpaces(String text) throws IOException { StringReader reader = new StringReader(text); StringBuffer buffer = new StringBuffer(text.length()); int c; while( (c = reader.read()) != -1) { if (c ==' '||c =='n'||c =='r'|| c =='f'||c =='t') { www.argonavis.com.br ; /* do nothing */ } else { buffer.append((char)c); } } return buffer.toString(); veja código em } } junitdemo.zip 12
  • 13. Exemplo: um test case para a classe package junitdemo; Construtor precisa ser publico, receber String import junit.framework.*; name e chamar import java.io.IOException; super(String name) public class TextUtilsTest extends TestCase { public TextUtilsTest(String name) { super(name); Método começa com "test" } e é sempre public void public void testRemoveWhiteSpaces() throws IOException { String testString = "one, ( two | three+) , "+ www.argonavis.com.br "(((four+ |t five)?n n, six?"; String expectedString = "one,(two|three+)"+ ",(((four+|five)?,six?"; String results = TextUtils.removeWhiteSpaces(testString); assertEquals(expectedString, results); } } 13
  • 14. Exemplo: como executar Use a interface de texto veja demonstração em java -cp junit.jar junit.textui.TestRunner junitdemo.zip junitdemo.TextUtilsTest Ou use a interface gráfica java -cp junit.jar junit.swingui.TestRunner junitdemo.TextUtilsTest Use Ant <junit> tarefa do Apache Ant www.argonavis.com.br Ou forneça um main(): public static void main (String[] args) { TestSuite suite = new TestSuite(TextUtilsTest.class); junit.textui.TestRunner.run(suite); } 14
  • 15. TestSuite Permite executar uma coleção de testes Método addTest(TestSuite) adiciona um teste na lista Padrão de codificação (usando reflection): retornar um TestSuite em cada test-case: public static TestSuite suite() { return new TestSuite(SuaClasseTest.class); } criar uma classe AllTests que combina as suites: public class AllTests { public static Test suite() { www.argonavis.com.br Pode incluir TestSuite testSuite = outras suites new TestSuite("Roda tudo"); testSuite.addTest(pacote.AllTests.suite()); testSuite.addTest(MinhaClasseTest.suite()); testSuite.addTest(SuaClasseTest.suite()); return testSuite; veja demonstração em } } junitdemo.zip 15
  • 16. Fixtures São os dados reutilizados por vários testes Inicializados no setUp() e destruídos no tearDown() (se necessário) public class AttributeEnumerationTest extends TestCase { String testString; String[] testArray; AttributeEnumeration testEnum; Fixture public void setUp() { testString = "(alpha|beta|gamma)"; testArray = new String[]{"alpha", "beta", "gamma"}; testEnum = new AttributeEnumeration(testArray); } public void testGetNames() { assertEquals(testEnum.getNames(), testArray); } www.argonavis.com.br public void testToString() { assertEquals(testEnum.toString(), testString); } (...) Extensão JXUnit (jxunit.sourceforge.net) permite manter dados de teste em arquivo XML (*.jxu) separado do código Mais flexibilidade. Permite escrever testes veja exemplo mais rigorosos, com muitos dados jxunitdemo.zip 16
  • 17. Teste situações de falha É tão importante testar o cenário de falha do seu codigo quanto o sucesso Método fail() provoca uma falha Use para verificar se exceções ocorrem quando se espera que elas ocorram Exemplo public void testEntityNotFoundException() { resetEntityTable(); // no entities to resolve! www.argonavis.com.br try { // Following method call must cause exception! ParameterEntityTag tag = parser.resolveEntity("bogus"); fail("Should have caused EntityNotFoundException!"); } catch (EntityNotFoundException e) { // success: exception occurred as expected } } 17
  • 18. Afirmações do J2SDK1.4 (assertions) São expressões booleanas que o programador define para afirmar uma condição que ele acredita ser verdade Afirmações são usadas para validar código (ter a certeza que um vetor tem determinado tamanho, ter a certeza que o programa não passou por determinado lugar) Melhoram a qualidade do código: tipo de teste Devem ser usadas durante o desenvolvimento e desligadas na produção (afeta a performance) Não devem ser usadas como parte da lógica do código www.argonavis.com.br Afirmações são um recurso novo do JSDK1.4.0 Nova palavra-chave: assert É preciso compilar usando a opção -source 1.4: > javac -source 1.4 Classe.java Para executar, é preciso habilitar afirmações (enable assertions): > java -ea Classe 18
  • 19. JUnit vs. afirmações Afirmações do J2SDK 1.4 são usadas dentro do código Podem incluir testes dentro da lógica procedural de um programa if (i%3 == 0) { doThis(); } else if (i%3 == 1) { doThat(); } else { assert i%3 == 2: "Erro interno!"; } Provocam um AssertionError quando falham (que pode ser encapsulado pelas exceções do JUnit) Afirmações do JUnit são usadas em classe separada (TestCase) www.argonavis.com.br Não têm acesso ao interior dos métodos (verificam se a interface dos métodos funciona como esperado) Afirmações do J2SDK1.4 e JUnit são complementares JUnit testa a interface dos métodos assert testa trechos de lógica dentro dos métodos veja exemplo junitdemo.zip 19
  • 20. Limitações do JUnit Acesso aos dados de métodos sob teste Métodos private e variáveis locais não podem ser testadas com JUnit. Dados devem ser pelo menos package-private (friendly) Soluções com refatoramento Isolar em métodos private apenas código inquebrável Transformar métodos private em package-private Desvantagem: quebra ou redução do encapsulamento www.argonavis.com.br Classes de teste devem estar no mesmo pacote que as classes testadas para ter acesso Solução usando extensão do JUnit JUnitX: usa reflection para ter acesso a dados private http://www.extreme-java.de/junitx/index.html 20
  • 21. Como escrever bons testes JUnit facilita bastante a criação e execução de testes, mas elaborar bons testes exige mais O que testar? Como saber se testes estão completos? "Teste tudo o que pode falhar" [2] Métodos triviais (get/set) não precisam ser testados. E se houver uma rotina de validação no método set? É melhor ter testes a mais que testes a menos Escreva testes curtos (quebre testes maiores) www.argonavis.com.br Use assertNotNull() (reduz drasticamente erros de NullPointerException difíceis de encontrar) Reescreva seu código para que fique mais fácil de testar 21
  • 22. Como descobrir testes? Listas de tarefas (to-do list) Comece pelas mais simples e deixe os testes "realistas" para o final Requerimentos, use-cases, diagramas UML: rescreva os requerimentos em termos de testes Dados Use apenas dados suficientes (não teste 10 condições se três forem suficientes) www.argonavis.com.br Bugs revelam testes Achou um bug? Não conserte sem antes escrever um teste que o pegue (se você não o fizer, ele volta)! 22
  • 23. Test-Driven Development (TDD) Desenvolvimento guiado pelos testes Só escreva código novo se um teste falhar Refatore até que o teste funcione Alternância: "red/green/refactor" - nunca passe mais de 10 minutos sem que a barra do JUnit fique verde. Técnicas "Fake It Til You Make It": faça um teste rodar simplesmente fazendo método retornar constante www.argonavis.com.br Triangulação: abstraia o código apenas quando houver dois ou mais testes que esperam respostas diferentes Implementação óbvia: se operações são simples, implemente-as e faça que os testes rodem 23
  • 24. Como lidar com testes difíceis Testes devem ser simples e suficientes XP: design mais simples que resolva o problema; sempre pode-se escrever novos testes, quando necessário Não complique Não teste o que é responsabilidade de outra classe/método Assuma que outras classes e métodos funcionam Testes difíceis (ou que parecem difíceis) Aplicações gráficas: eventos, layouts, threads Objetos inaccessíveis, métodos privativos, Singletons www.argonavis.com.br Objetos que dependem de outros objetos Objetos cujo estado varia devido a fatores imprevisíveis Soluções Alterar o design da aplicação para facilitar os testes Simular dependências usando proxies e stubs 24
  • 25. Como testar GUIs O que testar? [11] Assumir que GUI (Swing, AWT, etc.) funciona Concentrar-se na lógica de negócio e não na UI Como testar? "Emagrecer" o código para reduzir a chance de falha Usar MVC: isolar lógica de apresentação e controle Separar código confiável do código que pode falhar Usar mediadores (Mediator pattern) para intermediar www.argonavis.com.br interações entre componentes Exemplo: event handlers Devem ter 0% de lógica de negócio: "A Stupid GUI is an Unbreakable GUI" (Robert Koss, Object Mentor) [5] Responsabilidades delegadas a mediadores testáveis 25
  • 26. Dependência de código-fonte Problema Como testar componente que depende do código de outros componentes? Classe-alvo não oferece o que testar: Tanque +nivel() CarroTest Carro +testAcelera() +acelera() Ignição +ligada() Se houver tinta e se houver papel www.argonavis.com.br método void imprime() public void testAcelera() { deve funcionar Carro carro = new Carro(); Como saber se há ou não carro.acelera(); tinta e papel? assert???(???); } Fonte: www.objectmentor.com, 2002 26
  • 27. Stubs: objetos "impostores" É possível remover dependências de código-fonte refatorando o código para usar interfaces antes depois «interface» A não conhece mais o A B A InterB B tipo concreto de B Agora B pode ser substituída por um stub BStub está sob controle total de ATest (1) Em alguns casos, ATest pode implementar InterB (2) www.argonavis.com.br «interface» «interface» ATest A ATest A InterB InterB (2) (1) « cria » BStub B self-shunt pattern B Fonte: www.objectmentor.com, 2002 27
  • 28. Dependência: solução usando stubs «interface» Tanque +nivel():float TanqueImpl +nivel():float CarroTest Carro +testTanqueVazioSemIgn() +acelera() +testTanqueCheioSemIgn() +testTanqueVazioComIgn() «interface» +testTanqueCheioComIgn() Ignicao +ligada(): bool IgnicaoImpl +ligada():bool www.argonavis.com.br Quando usar stubs Dependência não existe ainda (não está pronta) Dependências tem estado mutante, imprevisível ou estão indisponíveis durante o desenvolvimento BDs, servidores de aplicação, servidores Web, hardware Fonte: www.objectmentor.com, 2002 28
  • 29. Dependências de servidores Usar stubs para simular serviços e dados É preciso implementar classes que devolvam as respostas esperadas para diversas situações Complexidade muito grande da dependência pode não compensar investimento (não deixe de fazer testes por causa disto!) Vários tipos de stubs: mock objects, self-shunts. Usar proxies (mediadores) para serviços reais www.argonavis.com.br Oferecem interface para simular comunicação e testa a integração real do componente com seu ambiente Não é teste unitário: teste pode falhar quando código está correto (se os fatores externos falharem) 29
  • 30. Mock Objects Mock objects (MO) é uma estratégia similar ao uso de stubs mas que não implementa nenhuma lógica Um mock object não é, portanto, um stub, pois não simula o funcionamento do objeto em qualquer situação Comportamento é controlado pela classe de teste que Define comportamento esperado (valores retornados, etc.) Passa MO configurado para objeto a ser testado Chama métodos do objeto (que usam o MO) www.argonavis.com.br Implementações open-source que facilitam uso de MOs EasyMock (tammofreese.de/easymock/) e MockMaker (www.xpdeveloper.com) geram MOs a partir de interfaces Projeto MO (mockobjects.sourceforge.net) coleção de mock objects e utilitários para usá-los mockdemo.zip veja exemplo 30
  • 31. Testes de interface Caso específico: resposta de servidores Web Verificar se uma página HTML ou XML contém determinado texto ou determinado elemento Verificar se resposta está de acordo com dados passados na requisição: testes funcionais tipo "caixa-preta" Soluções (extensões do JUnit) HttpUnit e ServletUnit: permite testar dados de árvore DOM HTML gerada www.argonavis.com.br JXWeb (combinação do JXUnit com HttpUnit) permite especificar os dados de teste em arquivos XML arquivos de teste Java são gerados a partir do XML XMLUnit extensão simples para testar árvores XML Onde encontrar: (httpunit|jxunit|xmlunit).sourceforge.net 31
  • 32. Testes de performance JUnitPerf (www.clarkware.com) Coleção de decoradores para medir performance e escalabilidade em testes JUnit existentes TimedTest Executa um teste e mede o tempo transcorrido Define um tempo máximo para a execução. Teste falha se execução durar mais que o tempo estabelecido LoadTest Executa um teste com uma carga simulada www.argonavis.com.br Utiliza timers para distribuir as cargas usando distribuições randômicas Combinado com TimerTest para medir tempo com carga ThreadedTest Executa o teste em um thread separado 32
  • 33. JUnitPerf: exemplo import com.clarkware.junitperf.*; import junit.framework.*; public class ExampleLoadTest extends TestCase { public ExampleLoadTest(String name) { super(name); } public static Test suite() { TestSuite suite = new TestSuite(); Timer timer = new ConstantTimer(1000); TestCase existente int maxUsr = 10; int iters = 10; Decorador de carga long maxElapsedTime = 20000; Test test = new ExampleTestCase("testOneSecondResp"); www.argonavis.com.br Test loadTest = new LoadTest(test, maxUsr, iters, timer); Test timedTest = new TimedTest(loadTest, maxElapsedTime); suite.addTest(timedTest); return suite; Decorador de tempo } Example TestCase public static void main(String args[]) { LoadTest junit.textui.TestRunner.run(suite()); } TimedTest } TestRunner Suite 33
  • 34. Ant + JUnit Ant: ferramenta para automatizar processos de construção de aplicações Java Pode-se executar todos os testes após a integração com um único comando: ant roda-testes Com as tarefas <junit> e <junitreport> é possível executar todos os testes gerar um relatório simples ou detalhado, em diversos www.argonavis.com.br formatos (XML, HTML, etc.) executar testes de integração São tarefas opcionais. É preciso ter no $ANT_HOME/lib optional.jar (distribuído com Ant) junit.jar (distribuído com JUnit) 34
  • 35. Exemplo: <junit> <target name="test" depends="build"> <junit printsummary="true" dir="${build.dir}" fork="true"> <formatter type="plain" usefile="false" /> <classpath path="${build.dir}" / <test name="argonavis.dtd.AllTests" /> </junit> </target> Formata os dados na tela (plain) Roda apenas arquivo AllTests <target name="batchtest" depends="build" > <junit dir="${build.dir}" fork="true"> <formatter type="xml" usefile="true" /> <classpath path="${build.dir}" /> www.argonavis.com.br <batchtest todir="${test.report.dir}"> <fileset dir="${src.dir}"> <include name="**/*Test.java" /> <exclude name="**/AllTests.java" /> </fileset> </batchtest> Gera arquivo XML </junit> Inclui todos os arquivos que </target> terminam em TEST.java 35
  • 36. <junitreport> Gera um relatório detalhado (estilo JavaDoc) de todos os testes, sucessos, falhas, exceções, tempo, ... <target name="test-report" depends="batchtest" > <junitreport todir="${test.report.dir}"> <fileset dir="${test.report.dir}"> Usa arquivos XML <include name="TEST-*.xml" /> gerados por </fileset> <formatter> <report todir="${test.report.dir}/html" format="frames" /> </junitreport> www.argonavis.com.br </target> veja demonstração junitdemo.zip veja demonstração dtdreader.zip 36
  • 37. Resumo e conclusões JUnit é uma ferramenta open-source que ajuda a implementar testes em projetos Java Com JUnit, é fácil viabilizar práticas como Refactoring, Integração Contínua e Test-Driven Development (TDD) Em um processo TDD, testes que falham são escritos no JUnit para que, a partir deles, se possa implementar código que os faça rodar com sucesso Mock objects podem ser usados para representar www.argonavis.com.br dependência e diminuir as responsabilidades de testes Para testes em domínios específicos e para lidar com limitações do JUnit há várias extensões open-source HttpUnit, Cactus, JUnitPerf, JXUnit, JUnitX, JUnitEE ... 37
  • 38. Fontes (1) [1] R. Hightower, N. Lesiecki. Java Tools for eXtreme Programming. Wiley, 2002. Explora ferramentas Ant, JUnit, Cactus e outras usando estudo de caso com processo XP. [2] Jeffries, Anderson, Hendrickson. eXtreme Programming Installed, Addison- Wesley, 2001. Contém exemplos de estratégias para testes. [3] Kent Beck, Erich Gamma. JUnit Test Infected: programmers love writing tests. (JUnit docs). Aprenda a usar JUnit em uma hora. [4] Andy Schneider. JUnit Best Practices. JavaWorld, Dec. 2000. Dicas do que fazer ou não fazer para construir bons testes. [5] Robert Koss, Testing Things that are Hard to Test. Object Mentor, 2002 www.argonavis.com.br http://www.objectmentor.com/resources/articles/TestingThingsThatAreHa~9740.ppt. Mostra estratégias para testar GUIs e código com dependências usando stubs. 38
  • 39. Fontes (2) [6] Mackinnon, Freeman, Craig. Endo-testing with Mock Objects. http://mockobjects.sourceforge.net/misc/mockobjects.pdf. O autor apresenta técnicas para testes usando uma variação da técnica de stubs chamada de "mock objects". [7] William Wake. Test/Code Cycle in XP. Part 1: Model, Part II: GUI. http://users.vnet.net/wwake/xp/xp0001/. Ótimo tutorial em duas partes sobre a metodologia "test-first" mostrando estratégias para testar GUIs na segunda parte. [8] Steve Freeman, Developing JDBC Applications Test First. 2001. Tutorial sobre metodolodia test-first com mock objects para JDBC. [9] Martin Fowler. Refactoring: improving the design of existing code. Addison- Wesley, 2000. Cap 4 (building tests) é um tutorial usando JUnit. www.argonavis.com.br [10] Kent Beck. Test-driven development. Addison-Wesley, 2002. Mostra como utilizar testes como "requerimentos executáveis" para guiar o desenvolvimento. 39
  • 40. Palestra: JUnit helder@argonavis.com.br Selecione o link relativo a esta palestra no endereço www.argonavis.com.br/xpbrasil2002 Recursos disponíveis no site: • Palestra completa em PDF • Todo o código-fonte usado nos exemplos e demonstrações • Instruções detalhadas sobre como rodar e instalar os exemplos • Links para software utilizado e documentação Tutorial: Implementando eXtreme Programming em Java XP Brasil 2002, São Paulo © 2002, Helder da Rocha