Importando projetos do Eclipse para o NetBeans IDEConteúdo

Assistente de importação de projetos do Eclipse Como funciona o Assistente de importação Importando e configurando projetos Construção e execução de um projeto Arquivos de projetos do NetBeans Considerações sobre o controle de versão Ressincronizando um projeto Resolvendo problemas de importação

Para concluir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso Versão necessáriaNetBeans IDE versão 6.5

Java Development Kit (JDK)versão 6 ouversão 5

Assistente de importação de projetos do Eclipse

O NetBeans IDE 6.5 apresenta um Assistente de importação de projetos do Eclipse aprimorado. Esse assistente permite que você use o NetBeans para trabalhar com projetos de área de trabalho Java e de aplicações Web criados no Eclipse e MyEclipse.

Após criar um projeto NetBeans a partir de um projeto Eclipse, você pode trabalhar das seguintes maneiras:

Usar o NetBeans em um projeto de equipe em que outros desenvolvedores usem o Eclipse.

Alternar entre o NetBeans e o Eclipse em um projeto. Experimente o NetBeans em um projeto existente que tenha sido criado no

Eclipse.

Como funciona o Assistente de importação

Quando você importa um projeto, o IDE analisa os metadados do projeto Eclipse e cria um projeto NetBeans com base nesses metadados. A importação do projeto não impõe alterações na estrutura do projeto Eclipse, portanto isso não interfere no modo em que o projeto funciona no Eclipse.

Depois de ter importado o projeto, você pode usar um dos IDEs do NetBeans e Eclipse, ou ambos, para editar, construir, executar, depurar e criar o perfil do projeto. Se você fizer uma alteração de configuração no projeto Eclipse, você pode sincronizar o projeto NetBeans novamente. Isso permite que você trabalhe em projetos no NetBeans mesmo

se todos em sua equipe estiverem trabalhand com o Eclipse. O caminho de construção que você define no Eclipse continua sendo o caminho de construção mestre do projeto.

Importando e configurando projetos

Para importar um projeto Eclipse no NetBeans:

1. Certifique-se de que você tenha uma cópia do projeto que deseja importar para seu sistema.

Normalmente, esse projeto já estaria em um espaço de trabalho do Eclipse em seu sistema.

2. Escolha Arquivo > Importar projeto > Projeto Eclipse.3. Na página Localização do espaço de trabalho do assistente, selecione o botão de

opção Importar projetos para o espaço de trabalho e, em seguida, especifique a localização do espaço de trabalho.

4. Na página Projetos a importar, selecione os projetos que você deseja importar. Em seguida, selecione uma das seguintes opções de armazenamento dos arquivos do projeto NetBeans:

o Armazenar dados do projeto NetBeans nas pastas do projeto Eclipse.O NetBeans adiciona pastas e arquivos na pasta de nível superior do projeto original.

o Criar projetos NetBeans importados em um local separado. O NetBeans usa os códigos-fonte e bibliotecas na pasta do projeto Eclipse original, mas cria uma pasta separada para armazenar os metadados do projeto NetBeans e criar saídas.

Normalmente, é melhor armazenar os dados do projeto NetBeans dentro das pastas do projeto Eclipse. Na maioria dos casos, isso significa que os metadados

do projeto NetBeans irão se referir a códigos-fonte e bibliotecas com os mesmos caminhos que são usados pelos metadados do Eclipse. Portanto, a extração do projeto de um sistema de controle de versões em máquinas diferentes deve resultar em comportamento similar, tanto no NetBeans quanto no Eclipse.

Veja Arquivos do projeto NetBeans a seguir para obter uma relação dos arquivos e pastas criados pelo NetBeans.

5. Na página Servidores, registre todos os servidores que seu projeto precisa com o IDE NetBeans. (Essa página não é exibida se você não estiver importando aplicativos Web.)

Depois de ter concluído o assistente, as caixas de diálogo a seguir devem ser exibidas:

Problemas de importação. Esse diálogo oferece informações sobre as discrepâncias entre a estrutura do projeto no Eclipse e no NetBeans e destaca as ações que você pode ter que tomar para corrigir as discrepâncias.

Você pode copiar as informações obtidas desse diálogo e colá-las em outro lugar para consultar posteriormente.

Na maioria dos casos, você usa a caixa de diálogo Propriedades do projeto para resolver esses problemas. Veja Resolvendo problemas de importação para obter um guia para a solução dos problemas mais comuns.

Resolver problemas de referência. Essa caixa de diálogo alerta você sobre um problema de referência específico com uma das bibliotecas de seu projeto. Você pode solucionar esse problema depois de fechar a caixa de diálogo clicando com o botão direito do mouse no nó do projeot e escolhendo Resolver problemas de referências.

Resolver servidor ausente. Essa caixa de diálogo alerta você de que o projeto não foi capaz de encontrar um servidor necessário. Você pode solucionar esse problema depois de fechar a caixa de diálogo clicando com o botão direito do mouse no nó do projeto e escolhendo Resolver servidor ausente.

Depois de ter concluído o assistente e ter fechado algumas das caixas de diálogo informativas mostradas acima, os nós dos projetos serão exibidos na janela Projetos.

Se houver referências nos metadados de seu projeto sobre servidores ou outros recursos que o NetBeans não consegue resolver, o nó do projeto será exibido em vermelho. Você pode resolver essas referências imediatamente clicando com o botão direito do mouse no nó do projeto e escolhendo Resolver problemas de referência e Resolver servidor ausente.

Para outros tipos de ajustes na configuração do projeto, você usa a caixa de diálogo Propriedades do projeto. Abra a caixa de diálogo Propriedades do projeto clicando com o botão direito do mouse no nó do projeto e escolhendo Propriedades.

Para obter mais informações sobre a configuração de seu projeto, veja Configurando o classpath e outras configurações do projeto no guia Criando, importando e configurando projetos Java.

Construindo e executando um projeto

Depois de ter importado o projeto no NetBeans, você pode construir e executar o projeto. Todos os artefatos criados a partir dos comandos construir e executar do NetBeans são criados nas pastas build e dist. O NetBeans não sobrescreve a saída criada a partir de ações construir do Eclipse. Se o projeto Eclipse já tiver pastas build e dist, o projeto NetBeans cria pastas chamadas nbbuild e nbdist e as utiliza para as saídas do comando construir.

A seguir, alguns dos comandos construir e executar disponíveis no menu Executar:

Executar projeto. Testa a execução do aplicativo no IDE. Limpar e construir projeto. Exclui o conteúdo das pastas build (ou nbbuild)

e dist (ou nbdist) e reconstrói todas as saídas do projeto. Usa o script de construção do NetBeans. Similar ao comando Limpar no Eclipse.

Limpar. Exclui o conteúdo das pastas nbbuild e nbdist. Construir. Reconstrói as saídas do projeto. Se o recurso Compilar ao salvar

estiver habilitado, o comando Construir é desabilitado. Veja a seção Compilar ao salvar do guia Criando, importando e configurando projetos Java.

Para obter mais informações sobre a construção e execução de seu aplicativo, bem como sobre a personalização do processo de construção, veja Criando, importando e configurando projetos Java.

Arquivos do projeto NetBeans

Depois de ter importado o projeto, você encontrará a pasta e os arquivos a seguir em seu sistema:

Arquivo build.xml ou arquivo nb-build.xml. O script de construção principal do NetBeans para o projeto. Você pode personalizar esse script de acordo com as necessidades de seu projeto. Por padrão, esse arquivo é chamado de build.xml. Se esse arquivo já existir na pasta do projeto, o script é chamado de nb-build.xml.

Pasta nbproject. Contém a maioria dos metadados do projeto NetBeans, incluindo recursos que são chamados pelo script de construção principal do NetBeans. Se você marcar essa pasta e o arquivo build.xml ou nb-build.xml em seu sistema de controle de versão, outros usuários poderão abrir o projeto no NetBeans. Essa pasta também contém a pasta private, que contém dados específicos de seu sistema. Essa pasta não deve ser copiada para o sistema de

controle de versão, já que seu conteúdo irá variar entre os usuários. Veja Considerações sobre o controle de versão a seguir.

Pasta nbbuild. Quando você criar ou executar seu projeto no NetBeans, os códigos-fonte serão compilados nessa pasta.

Pasta nbdist. Quando você constrói seu projeto no NetBeans, as saídas distribuíveis do projeto são craidas e colocadas nessa pasta. Tais saídas podem ser arquivos JAR e arquivos WAR.

Considerações sobre o controle de versão

Se o projeto foi copiado de um sistema de controle de de versão, as pastas build (ou nbbuild), dist (ou nbdist) e nbproject/private não devem ser copiadas para esse sistema de controle de versão.

Se o projeto estiver sob os sistemas de controle de versão CVS, Subversion ou Mercurial, os arquivos "ignorar" apropriados são criados ou atualizados para esses diretórios quando o projeto é importado.

Embora a pasta nbproject/private deva ser ignorada, a pasta nbproject deve ser copiada para o sistema de controle de versão. A pasta nbproject contém metadados do projeto que permitem que outros usuários abram o projeto no NetBeans sem ter que importar o projeto primeiro.

Sincronizando um projeto novamente

O importador do projeto tem recursos de sincronização. Se o classpath no Eclipse tiver sido alterado desde que foi importado inicialmente, você pode usar o recurso Sincronizar projetos do Eclipse novamente para atualizar o classpath no projeto NetBeans correspondente.

A ressincronização do projeto é unidirecional, de projetos Ecilpse para projetos NetBeans. Se você fizer alterações na estrutura do projeto no NetBeans, essas alterações não serão propagadas para o projeto Eclipse com o recurso de ressincronização. Se você pretende manter tanto o projeto Eclipse quanto o NetBeans, use o projeto Eclipse como projeto "mestre".

O IDe também ressincroniza os projetos automaticamente se as alterações na configuração do Eclipse forem inequívocas e não exigirem sua intervenção. Essa ressincronização automática ocorre logo depois que você abre o projeto. Se a ressincronização exigir sua intervenção, você precisa ressincronizar manualmente o projeto.

Para sincronizar novamente de modo manual os projetos NetBeans com projetos Eclipse:

Escolha Arquivo > Importar projeto > Ressincronizar projetos Eclipse.

Observações: quando você ressincronizar um projeto, a ressincronização é realizada em todos os projetos que você importou do espaço de trabalho.

Resolvendo problemas de importação

Quando você importa um projeto no NetBeans, podem haver algumas coisas que não são automaticamente resolvidas no NetBeans IDE. Para alguns desses problemas, um item do menu, como Resolver problema de servidor ausente, é exibido no menu de contexto do projeto. Outros problemas podem ser resolvidos na caixa de diálogo Propriedades do projeto referente ao projeto importado no NetBeans IDE.

Eis uma lista de problemas de importação comuns e suas soluções.

Mensagem do problema Solução

Resolver problema de servidor ausente

Clique com o botão direito do mouse no nó do projeto e escolha Resolver problema de servidor ausente. Em seguida, navegue até o arquivo ou pasta que contém o servidor.

Resolver problema de referência

Clique com o botão direito do mouse no nó do projeto e escolha Resolver problema de referência. Em seguida, navegue até o arquivo ou pasta que contém o recurso que é mencionado no projeto.

A plataforma Eclipse para o projeto ProjectName não pode ser usada. Ela é um JRE e o projeto NetBeans requer um JDK. O NetBeans usará a plataforma padrão.

Caso queira alterar a plataforma que o NetBeans usa para o projeto, escolha Ferramentas > Plataformas e especifique uma plataforma diferente.

O projeto Eclipse ProjecName afirma usar o JDK a partir do diretório "{1}". Mas esse diretório não existe. O NetBeans usará a plataforma padrão.

Caso queira alterar a plataforma que o NetBeans usa para o projeto, escolha Ferramentas > Plataformas e especifique uma plataforma diferente.

O NetBeans não oferece suporte a inclusões/exclusões de código-fonte por raiz de código-fonte como o Eclipse. Elas foram mescladas e é recomendável que você as verifique no painel Código-fonte das propriedades do projeto.

No NetBeans, inclusões e exclusões são declaradas em um local para todo o projeto. Para verificar as inclusões e exclusões no projeto NetBeans, clique com o botão direito do mouse no nó do projeto e, na janela Projetos, escolha Propriedades. Na caixa de diálogo Propriedades do projeto, selecione a aba Códigos-fonte e, em seguida, clique no botão Inclusões/exclusões.

Falha na importação devido a .... Mais detalhes podem ser encontrados no arquivo de log do IDE.

Você pode abrir o arquivo de registro do IDE escolhendo Visualizar > Registro do IDE.

Tipo de projeto desconhecido, ele não pode ser importado.

Você pode importar apenas os seguintes tipos de projeto Eclipse: Projeto Java, Projeto Java de um arquivo Ant existente, Web estática, Web dinâmica e Projeto JPA.

Construindo, depurando e testando

Habilitando o Java Web Start no NetBeans IDE

Seguindo as etapas neste tutorial, você aprenderá a configurar seu aplicativo para que ele possa ser implantado utilizando o Java Web Start. O Java Web Start é uma tecnologia que é utilizada para executar aplicativos Java a partir de um navegador da web com apenas um clique. Em resumo, o Java Web Start é apenas outra forma de como é possível implantar aplicativos Java.

Neste tutorial, utilizamos um aplicativo Java simples, um conversor, que converte as medições de distâncias entre as unidades métricas e a dos EUA. O código para este aplicativo de amostra será disponibilizado para download e será necessário configurar as definições do projeto para poder iniciá-lo utilizando o Java Web Start. Projeto Kenai, que fornece as capacidades de colaboração para os desenvolvedores, é utilizado neste tutorial como um exemplo de um servidor da Web remoto ao qual é possível carregar arquivos do aplicativo. É possível utilizar qualquer outro local remoto para carregar os arquivos do aplicativo.

Este tutorial leva aproximadamente 20 minutos para ser completado.

Conteúdo

Abrindo um projeto Configurando o projeto para habilitar o Java Web Start Executando o aplicativo a partir de uma localização remota Resumo Consulte também

Para concluir este tutorial, são necessários o software e os recursos apresentados na tabela a seguir.

Software ou recurso Versão necessária

NetBeans IDE Versão 6.7, 6.8 ou 6.9

Java Development Kit (JDK) versão 6

Abrindo um projeto

Primeiro, é necessário abrir um projeto IDE com o aplicativo Converter. O código-fonte do aplicativo já está empacotado como um projeto NetBeans IDE, portanto, basta abri-lo no IDE.

O código-fonte para a demonstração Converter é originalmente fornecido no tutorial Java. Consulte a seção Utilizando componentes Swing do tutorial Java para aprender como escrever este pequeno aplicativo. Neste tutorial, você aprenderá a configurar suas configurações de projeto para que este aplicativo Java possa ser iniciado em um navegador Web.

1. Baixe do arquivo zip que contém a demonstração do aplicativo Convertor empacotado como um projeto do NetBeans IDE. Descompacte-o em qualquer localização do sistema.

2. No IDE, escolha Arquivo > Abrir projeto, a partir do menu principal. O projeto ConverterPrj é aberto na janela Projetos. Você pode expandir os nós do projeto para visualizar os arquivos de código-fonte.

Configurando o projeto para habilitar o Java Web Start

Com o Java Web Start, o usuário pode iniciar o aplicativo Java clicando no link HTML para um arquivo JNLP para este aplicativo dentro do navegador Web. O arquivo JNLP, que é um arquivo de configuração especial, instrui o Java Web Start para baixar, fazer o cache e executar o aplicativo Java. Para executar aplicativos com o Java Web Start, basta ter uma versão compatível do Java Runtime Environment (JRE) instalado na máquina cliente. A instalação do Java Development Kit (JDK) não é necessária.

Para habilitar seu aplicativo Java para ser executado com o Java Web Start, é preciso configurar as propriedades sobre como o IDE deveria ser incorporado no projeto. Quando o Java Web Start é habilitado nas propriedades do projeto, o IDE cria automaticamente um arquivo JNLP e uma página HTML com o link para o arquivo JNLP, junto com o arquivo JAR.

Configurando o projeto para habilitar o Java Web Start

Primeiro, configuramos o projeto para torná-lo habilitado para o Java Web Start e testamos localmente sua execução.

1. Clique com o botão direito do mouse no nó do projeto ConverterPrj e escolha Propriedades.

2. Em Categorias, escolha Web Start e selecione a caixa de verificação Habilitar o Web Start.

3. Escolha a opção Execução local na lista suspensa Código-base, já que primeiro iremos executar o aplicativo localmente. O campo Visualizar código-base mostra o caminho para os arquivos do aplicativo local.

4. Assegure que a caixa de verificação Autoassinado esteja marcada. O arquivo do aplicativo JAR será assinado por um certificado gerado automaticamente quando o projeto for construído. Com o certificado autoassinado, o aplicativo será capaz de acessar os mesmos recursos a partir do computador como um aplicativo regular que é executado localmente. Por exemplo, o certificado autoassinado permite que um aplicativo acesse arquivos locais e a rede.

5. (Opcional). Na caixa de diálogo Propriedades do projeto, selecione o painel Aplicativos e altere o título do aplicativo e o nome do fornecedor.

6. Clique em OK para fechar a caixa de diálogo Propriedades do projeto.

Compilando e executando o aplicativo Java WebStart a partir do IDE

Para compilar e executar localmente o aplicativo Java Web Start:

1. clique com o botão direito do mouse no nó do projeto ConvertePrj e selecione Definir como projeto principal.

2. Escolha Executar > Executar projeto principal ou pressione F6. O IDE compila o código-fonte e é possível ver a tela de splash indicando que o Java está sendo iniciado e a janela de aviso perguntando se o aplicativo assinado pode ser executado.

3. Selecione a caixa de verificação para definir o conteúdo como confiável e clique em Executar na janela de aviso. O aplicativo Converter é iniciado.

Explorando os arquivos Java Web Start

Vamos agora examinar de perto os arquivos Java Web Start que foram criados pelo IDE durante o processo de construção.

Para visualizar os arquivos, abra a janela Arquivos no IDE e expanda a pasta dist. Para o Java Web Start, os seguintes dois arquivos adicionais foram criados:

launch.jnlp: este é um arquivo XML com elementos especiais e atributos que instruem os navegadores sobre como executar o aplicativo. JNLP representa o Java Network Launching Protocol. Os atributos dos arquivos JNLP podem incluir a versão de especificação JNLP, o título do aplicativo, o nome do fornecedor, um link para o aplicativo JAR, etc.

launch.html: esta é uma página HTML automaticamente gerada, que possui um link para o arquivo JNLP. Os usuários clicam nesse link para iniciar os aplicativos através do Java Web Start. Esse arquivo HTML gerado também possui uma referência cancelada com comentário para o Java Deployment Toolkit (deployJava.js) publicamente disponível, que fornece funções JavaScript para poder evitar problemas de compatibilidade do navegador. É possível encontrar aqui mais informações sobre Java Deployment Toolkit .

É possível tentar o seguinte: fora do IDE, vá para o arquivo launch.html no sistema, abra-o em seu navegador e clique no link para iniciar o aplicativo de demonstração Converter.

Executando o aplicativo a partir de uma localização remota

Após ter verificado que o aplicativo foi iniciado com êxito com o Java Web Start a partir do código-fonte local, vamos carregá-lo em uma localização remota e iniciá-lo a partir daquela localização.

Este tutorial mostra como carregar o aplicativo no Projeto Kenai, que fornece um ambiente de colaboração para desenvolvedores e permite que os usuários hospedem e compartilhem código e projetos de código-fonte aberto. Se você decidir seguir nossas instruções sobre como carregar no Kenai, será necessário ter uma conta de usuário e um projeto Kenai. No entanto, também é possível decidir carregar seu aplicativo em qualquer outro servidor Web.

Nota: para deployment de aplicativos com o Java Web Start na Web, o servidor Web que estiver sendo utilizado deve ser capaz de manipular arquivos JNLP. O servidor Web deve ser configurado para reconhecer os arquivos JNLP como aplicativos, ou seja, o tipo MIME para o JNLP deve ser adicionado na configuração do servidor Web. Caso contrário, os arquivos com a extensão JNLP serão tratados como arquivos de texto comuns. Para obter mais informações sobre a configuração do servidor Web, consulte o Guia do Java Web Start.

Modificando o arquivo JNLP

Para iniciar o aplicativo a partir da Web, é preciso fornecer um link para o arquivo de código-fonte dos aplicativos na Web no arquivo JNLP.

1. Clique com o botão direito do mouse no nó do projeto ConvertePrj, escolha Propriedades e selecione Web Start em Categorias.

2. Escolha definida pelo usuário como o Código-base.3. No campo Visualizar o código-base, insira o URL onde estará carregando os arquivos

de código-fonte. Por exemplo, http://kenai.com/projects/netbeans-java-docs/downloads/download/converter/

Em nosso exemplo, carregaremos os arquivos do aplicativo no projeto netbeans-java-docs no Kenai.

4. Clique em OK na janela Propriedades do projeto.5. Clique com o botão direito do mouse no nó ConverterPRJ e escolha Limpar e

construir. Este comando do IDE exclui todos os arquivos anteriormente compilados e as saídas construídas, recompila seu aplicativo e constrói os arquivos de saída com as configurações atuais.

Carregando os arquivos do código-fonte

Agora nós iremos carregar os arquivos do código-fonte em um projeto Kenai e executar o aplicativo a partir do Kenai. Observe que todas as credenciais de usuário e nomes de projeto referenciados nesta seção deveriam ser substituídos por seus dados pessoais.

1. Faça o logon no Kenai.com e vá à área de download do seu projeto. Em nosso caso, o título do projeto é "NetBeans IDE Documentation Area" e o link para o download do projeto é http://kenai.com/projects/netbeans-java-docs/downloads/

2. Carregue os seguintes arquivos locais a partir da pasta dist de seu projeto para a área Downloads de seu projeto: ConverterPrj.jar, launch.html e launch.jnlp.A figura abaixo mostra a área de download para a área do projeto NetBeans IDE Documentation.

3. Agora, execute o aplicativo. Em uma janela do navegador, insira o URL para o arquivolaunch.html. Em nosso caso, o URL é http://kenai.com/downloads/netbeans-java-docs/converter/launch.html e clique no link "Iniciar o aplicativo".O aplicativo Converter se inicia com o Java Web Start.

Resumo

Neste curto tutorial, mostramos como tornar com facilidade um aplicativo Java implantável através da Web utilizando o NetBeans IDE. Essa é apenas outra forma para poder implantar aplicativos Java.

Como um exemplo de um servidor remoto onde hospedar o aplicativo, utilizamos o kenai.com.

Usar o NetBeans IDE para unir arquivos JAR em um único arquivo JAR

Índice de artigos

The Java Warehouse is the repository for Java and JavaFX applications submitted by developers for distribution through the Java Store to hundreds of millions of desktops worldwide. O Armazém Java é o repositório de aplicações Java e JavaFX submetidos por desenvolvedores para distribuição pela loja Java para centenas de milhões de desktops no mundo todo. The Java Warehouse Developer Center Release Notes make clear that there is currently no way to upload applications composed of several Java Archive (JAR) files into the Java Warehouse. O Java Developer Armazém Release Notes Center deixar claro que não há atualmente nenhuma maneira de fazer upload de aplicações Java composta de vários Archive (JAR) para o Java Warehouse. However, there is a workaround: Just concatenate each of the user and library classes into a single JAR file. No entanto, há uma solução: Basta concatenar cada uma das classes de usuário e biblioteca em um único arquivo JAR. This is very easy to do for both Java and JavaFX projects using NetBeans IDE 6.7.1. Isso é muito fácil de fazer para Java e projetos JavaFX com NetBeans IDE 6.7.1.

To demonstrate how to do this, let's use one of the sample Java projects that is included in the NetBeans IDE 6.7.1 distribution: the Mars Rover Viewer. Para demonstrar como fazer isso, vamos usar um dos projetos Java de exemplo que está incluído no IDE NetBeans 6.7.1 Distribuição, o Mars Rover Viewer. Open the NetBeans IDE, select File > New Project, then scroll down to the Samples folder and choose Java from the Categories pane. Abra o NetBeans IDE, selecione File> New Project, em seguida, role para a Samples de pasta e escolha Java no painel Categorias. From there, select Mars Rover Viewer in the Projects pane and click Next, as shown in Figure 1. A partir daí, selecionar Mars Rover Viewer no painel Projetos e clique em Avançar, como mostrado na Figura 1. Next, choose a suitable location for the project and click Finish. Em seguida, escolha um local adequado para o projeto e clique em Concluir.

Figure 1 - Creating the Mars Rover Viewer Sample Project in NetBeans. Figura 1 - Criando o Mars Rover Project Viewer exemplo no NetBeans.  

We've chosen this project because it makes use of a popular compile-time library that is not included with the standard Java Development Kit (JDK) : the Swing Application Framework . Nós escolhemos este projeto porque ele faz uso de uma biblioteca de tempo de compilação popular que não está incluído com o padrão Java Development Kit (JDK) : o Swing Application Framework . To verify that this library is being used, right-click on the project in the upper left pane and choose Properties. Para verificar se esta biblioteca está sendo usada, clique com o botão direito sobre o projeto no painel superior esquerdo e escolha Propriedades. From there, select Libraries on the left pane to verify that the Swing Application Framework is indeed listed, as shown in Figure 2. De lá, Bibliotecas selecionar no painel da esquerda para verificar se o Swing Application Framework é realmente na lista, como mostrado na Figura 2. Then click OK to close the Project Properties dialog box. Em seguida, clique em OK para fechar a caixa diálogo Project Properties.

Figure 2 - The Mars Rover Viewer Application Uses the Swing Application Framework Library. Figura 2 - O Mars Rover Application Viewer Usa a biblioteca Swing Application Framework.  

In order to bundle all of the libraries into a single JAR file, you will need to edit the project's Ant file, which is called build.xml . A fim de agrupar todas as bibliotecas em um único arquivo JAR, você precisará editar o arquivo de projeto do Ant, que é chamado build.xml . Choose the Files tab in the Project window in the upper left, then expand the project tab if necessary to show the build.xml file. Escolha a aba Files na janela Project no canto superior esquerdo, expanda a guia de projeto, se necessário, para mostrar o build.xml arquivo. Double-click this file to edit it in the source-code editor pane and scroll down to the bottom. Dê um duplo clique neste arquivo para editá-lo no painel de editor de código-fonte e vá até o fundo. Now copy and paste the following text to the end, just before the final line, which is the </project> closing tag: Agora copie e cole o seguinte texto para o final, pouco antes da linha final, que é o </project> tag de fechamento:

<target name="package-for-store" depends="jar"> <target name="package-for-store" depends="jar">

<!-- Change the value of this property to be the name of your JAR, <! - Alterar o valor da propriedade a ser o nome do seu JAR, minus the .jar extension. menos a extensão jar.. It should not have spaces. Ele não deve ter espaços. <property name="store.jar.name" value="MyJarName"/> <property name="store.jar.name" value="MyJarName"/> --> ->

<property name="store.jar.name" value="MarsRoverViewer"/> <property name="store.jar.name" value="MarsRoverViewer"/>

<!-- don't edit below this line --> <! - Não editar abaixo desta linha ->

<property name="store.dir" value="store"/> <property name="store.dir" value="store"/> <property name="store.jar" value="${store.dir}/${store.jar.name}.jar"/> <property name="store.jar" value="${store.dir}/${store.jar.name}.jar"/>

<echo message="Packaging ${application.title} into a single JAR at ${store.jar}"/> <echo ${application.title} message="Packaging em um JAR único a ${store.jar}"/>

<delete dir="${store.dir}"/> dir="${store.dir}"/> <delete <mkdir dir="${store.dir}"/> dir="${store.dir}"/> <mkdir

<jar destfile="${store.dir}/temp_final.jar" filesetmanifest="skip"> <jar destfile="${store.dir}/temp_final.jar" filesetmanifest="skip"> <zipgroupfileset dir="dist" includes="*.jar"/> <zipgroupfileset dir="dist" includes="*.jar"/> <zipgroupfileset dir="dist/lib" includes="*.jar"/> <zipgroupfileset dir="dist/lib" includes="*.jar"/>

<manifest> <manifest> <attribute name="Main-Class" value="${main.class}"/> <attribute name="Main-Class" value="${main.class}"/> </manifest> </> Manifesto </jar> </ Jar>

<zip destfile="${store.jar}"> destfile="${store.jar}"> <zip <zipfileset src="${store.dir}/temp_final.jar" <Zipfileset src = "$ store.dir () / temp_final.jar" excludes="META-INF/*.SF, META-INF/*.DSA, META-INF/*.RSA"/> exclui = "META-INF / *. SF, META-INF / *. DSA, META-INF / *. RSA" /> </zip> </> Zip

<delete file="${store.dir}/temp_final.jar"/> file="${store.dir}/temp_final.jar"/> <delete

</target> </ Target>

 

Note that you must change the following line in the Ant code above to match your particular project. Note-se que você deve alterar a seguinte linha no código Ant acima para corresponder ao seu projeto particular.

<property name="store.jar.name" value="MarsRoverViewer"/> <property name="store.jar.name" value="MarsRoverViewer"/>

The property store.jar.name specifies the name of the JAR file that will be created in the store directory — change the value to whatever name you like. A propriedade store.jar.name especifica o nome do arquivo JAR que será criado na store do diretório - altere o valor para o nome que você quiser. After you have changed this

name, save the build.xml file. Depois de ter alterado este nome, salve o build.xml arquivo. Figure 3 shows the additions to the build.xml file for the sample MarsRoverViewer project relative to the closing </project> tag. A Figura 3 mostra as adições ao build.xml MarsRoverViewer arquivo para o projeto de exemplo em relação ao fechamento </project> tag.

Figure 3 - Additions to the Project's build.xml File Relative to the Closing Tag. Figura 3 - Adições ao Projeto build.xml arquivo em relação à marca de fechamento.  

From here, you can continue normal development, editing Java source files and compiling and running as necessary. A partir daqui, você pode continuar o desenvolvimento normal, a fonte de edição de arquivos Java e compilar e executar, se necessário. Figure 4 shows the Mars Rover Viewer application fully built and running within the NetBeans IDE. A Figura 4 mostra o Mars Rover aplicativo Visualizador totalmente construído e funcionando dentro do IDE NetBeans.

Figure 4 - Running the Mars Rover Viewer Within the NetBeans IDE. Figura 4 - Executando o Mars Rover Viewer Dentro do IDE NetBeans.  

When you're ready to package all of the classes and libraries into a single JAR file, switch back to the Files view in the upper left, then right-click the build.xml file. Quando estiver pronto para embalar todas as classes e bibliotecas em um arquivo JAR único, voltar para a visualização dos arquivos no canto superior esquerdo, clique com o botão direito do mouse no build.xml arquivo. Choose Run Target, scroll down to select Other Targets, then choose package-for-store , as shown in Figure 5, to execute the target. Escolha Run Target, scroll para baixo para selecionar outros alvos, em seguida, escolher package-for-store , como mostrado na Figura 5, para executar o alvo. In this case, package-for-store is the name of the Ant target that you created previously in the project build.xml file. Neste caso, o package-for-store se o nome do alvo Ant que você criou anteriormente no projeto build.xml arquivo.

Figure 5 - Executing the package-for-store Ant Target From the Files Tab Inside the NetBeans IDE. Figura 5 - Execução do package-for-store Ant alvo do Tab arquivos dentro do IDE NetBeans.  

Executing this Ant target will create a directory called store inside your project directory. A execução deste objectivo Formiga irá criar um diretório chamado store dentro do seu diretório do projeto. NetBeans and Ant will then copy all of the classes and libraries into a temporary JAR file and strip out any unwanted files, placing the final result under the JAR name that you specified earlier. NetBeans e Formiga irá copiar todas as classes e bibliotecas em um frasco de arquivos temporários e tira todos os arquivos indesejados, colocando o resultado final com o nome de JAR que você especificou anteriormente. NetBeans will then delete the temporary file. NetBeans irá excluir o arquivo temporário. The results are shown in Figure 6. Os resultados obtidos são mostrados na Figura 6.

Figure 6 - The Final JAR File, Ready to Upload to the Java Warehouse. Figura 6 - O arquivo JAR final, pronto para fazer upload para o Armazém Java.  

That's all there is to it — you can use this JAR file to upload to the Java Warehouse. Isso é tudo que existe para isso - você pode usar este arquivo JAR para fazer o upload para o Armazém Java. Note that if you get an error stating that the dist/lib directory was not found, you should check that you have indeed included other libraries in your project, as this is the location where their JAR files will be stored. Note que se você receber um erro informando que o dist/lib do diretório não foi encontrado, você deve verificar se tem efectivamente incluídas outras bibliotecas no seu projeto, pois este é o local onde seus arquivos JAR será armazenado.

If you'd like to verify that the JAR file contains the appropriate libraries, you can use one of three methods: Se você gostaria de verificar se o arquivo JAR contém as bibliotecas adequadas, você pode usar um dos três métodos:

Use the command-line tool: jar tvf (filename) . Use a ferramenta de linha de comando: jar tvf (filename) .

Use a number of OS-based tools to inspect the JAR files (or ZIP files, if you change the extension). Utilize um número de ferramentas baseado no sistema operacional para inspecionar os arquivos JAR (ou arquivos ZIP, se você mudar a extensão).

Double-click on the JAR file to be sure that the Java runtime can execute it. Dê um duplo clique sobre o arquivo JAR para ter certeza de que o runtime do Java pode executá-lo.

Escrevendo testes JUnit no NetBeans IDEEste tutorial apresenta os princípios básicos da escrita e execução de testes de unidade JUnit no NetBeans IDE. O teste de um aplicativo faz parte do ciclo de desenvolvimento, e a escrita e manutenção de testes de unidade podem ajudar a garantir que os métodos individuais em seu código-fonte funcionem corretamente. O suporte integrado do IDE para a estrutura de teste de unidades JUnit permite que você crie os testes e suites de teste do JUnit de modo fácil e rápido.

Neste tutorial você cria testes de unidade JUnit 3 e JUnit 4 e suites de teste para um projeto de biblioteca de classe Java. A primeira parte do tutorial mostra como criar testes na JUnit 3. A segunda parte mostra como criar os mesmos testes na JUnit 4 usando anotações da JUnit. Não é necessário completar ambas as partes do tutorial, pois os testes são os mesmos. No entanto, ver como os testes são escritos em ambas as versões permite que você veja algumas das alterações introduzidas na JUnit 4.

Para saber mais sobre a utilização da JUnit, consulte www.junit.org.

Conteúdo

Criando o projeto o Criando o projeto de biblioteca de classe Java o Fazendo download do projeto da solução o Criando as classes Java

Escrevendo testes da JUnit 3 o Criando uma classe de teste para Vectors.java o Escrevendo métodos de teste para Vectors.java o Criando uma classe de teste para Utils.java o Escrevendo métodos de teste para Utils.java o Executando os testes

Escrevendo testes da JUnit 4 o Criando uma classe de teste para Vectors.java o Escrevendo métodos de teste para Vectors.java o Criando uma classe de teste para Utils.java o Escrevendo métodos de teste para Utils.java o Executando os testes

Criando suites de testes JUnit o Criando suites de teste JUnit 3 o Criando suites de teste JUnit 4 o Executando suites de teste

Resumo

Para seguir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso Versão necessária

NetBeans IDE 6.7

Java Development Kit (JDK) versão 6 ou versão 5

Projeto JUnitSampleSol download

Criando o projeto

Para concluir este tutorial, você cria primeiramente um projeto de biblioteca de classe Java chamado JUnit-Sample. Após você criar o projeto, copie as duas classes do projeto de amostra JUnitSampleSol para seu projeto JUnit-Sample.

Criando o projeto de biblioteca de classe Java

1. Escolha Arquivo > Novo projeto no menu principal.2. Selecione Biblioteca de classe Java em Categoria Java e clique em Avançar. 3. Insira JUnit-Sample para o projeto e defina a localização do projeto.4. Desmarque a opção Usar pasta dedicada, se ela estiver selecionada.

Para este tutorial, há pouco motivo para copiar as bibliotecas de projeto em uma pasta dedicada, pois você não precisará compartilhar bibliotecas com outros usuários ou projetos. Essa opção não está disponível se você estiver usando o NetBeans IDE 6.0.

Clique em Próximo.

5. Clique em Terminar.

Depois de criar o projeto, se você procurar no nó Testar bibliotecas na Janela de projetos, você poderá ver que o projeto contém bibliotecas JUnit 3 e JUnit 4. O IDE adiciona ambas as bibliotecas aos novos projetos por padrão. Na primeira vez em que você criar um teste JUnit, o IDE solicita que você selecione uma versão e, em seguida, remove a biblioteca desnecessária.

Fazendo download do projeto da solução

Você pode fazer o download do projeto de amostra JUnitSampleSol usado neste tutorial das seguintes formas:

Faça o download de um arquivo zip do projeto acabado. Retire o código-fonte do projeto do Kenai ao executar as seguintes etapas:

1. Escolha Equipe > Kenai > Obter código-fonte a partir do Kenai, a partir do menu principal.

Alternativamente, você pode escolher Abrir projeto Kenai para adicionar o projeto no painel do Kenai, e a seguir obter o código-fonte do projeto.

2. Na caixa de diálogo Obter código-fonte a partir do Kenai, localize o repositório Kenai ao clicar em Procurar para abrir a caixa de diálogo Procurar projetos Kenai.

3. Pesquise pelo Catálogo de amostras do NetBeans IDE.4. Selecione o Catálogo de amostra do NetBeans IDE e clique em OK.5. Clique em Procurar para especificar a Pasta a obter e selecione

Samples/Java/JUnitSampleSol. Clique em OK.6. Especifique a pasta local para o código-fonte (a pasta local precisa estar vazia).7. Clique em Obter do Kenai.

Quando você clica em Obter do Kenai, o IDE inicializa a pasta local como um repositório Subversion e retira o código-fonte do projeto.

8. Clique em Abrir projeto na caixa de diálogo que aparece quando a retirada estiver completada.

Criando as classes Java

Neste exercício você copia os arquivos Utils.java e Vectors.java do projeto de amostra JUnitSampleSol para o projeto de biblioteca de classes criado.

1. Na janela Projetos, clique com o botão direito do mouse no nó Pacotes de código-fonte de seu projeto JUnit-Sample e escolha Novo > Pacote Java no menu suspenso.

2. Insira sample como nome do pacote. Clique em Terminar.3. Abra o projeto JUnitSampleSol no IDE e expanda o nó do projeto na janela Projetos.4. Copie Utils.java e Vectors.java, na pasta Pacotes de código-fonte do projeto

JUnitSampleSol, no pacote de código-fonte sample, na JUnit-Sample.

Se você observar o código-fonte das classes, perceberá que Utils.java tem três métodos (computeFactorial, concatWords e normalizeWord) e que Vectors.java tem dois métodos (equals e scalarMultiplication). O próximo passo é criar classes de teste para cada classe e escrever alguns casos de teste para os métodos.

Escrevendo testes de unidade JUnit 3

Nesta parte do tutorial você cria testes básicos de unidade JUnit 3 para as classes Vectors.java e Utils.java. Você usará a IDE para criar classes de teste esqueleto baseadas nas classes de seu projeto. Em seguida, você modificará os métodos de teste gerados e adicionará novos métodos de teste.

O IDE solicita que você escolha uma versão da JUnit na primeira vez em que usar o IDE para criar seus testes no projeto. A versão selecionada se torna a versão da JUnit padrão e o IDE irá gerar todos os testes e suites de teste subseqüentes para essa versão.

Criando uma classe de teste para Vectors.java

Neste exercício você criará um esqueleto de teste JUnit para o Vectors.java.

1. Clique com o botão direito do mouse em Vectors.java e selecione Ferramentas > Criar testes JUnit.

2. Selecione JUnit 3.x na caixa de diálogo Versão da JUnit.

Quando você seleciona a JUnit 3.x, o IDE remove a biblioteca JUnit 4 do projeto.

3. Modifique o nome da classe de teste VectorsJUnit3Test na caixa de diálogo Criar testes.

Quando você alterar o nome da classe de teste, será exibido um aviso sobre a alteração do nome. O nome padrão é baseado no nome da classe que você está testando, com a palavra Teste agregada ao nome. Por exemplo, para a classe MyClass.java, o nome padrão da classe de teste é MyClassTest.java. Normalmente, é melhor manter o nome padrão, mas para a finalidade deste tutorial você mudará o nome porque também irá criar testes JUnit 4 no mesmo pacote e os nomes das classes de teste devem ser únicos.

4. Desmarque Inicializador de teste e Finalizador de teste. Clique em OK.

Quando você clicar em OK, o IDE criará um esqueleto de teste JUnit no diretório do pacote de teste sample.

Um projeto precisa de um diretório para que os pacotes de teste criem testes. A localização padrão do diretório de pacotes de teste está no nível raiz do projeto; porém, dependendo do tipo de projeto, você pode especificar uma localização diferente para o diretório no diálogo Propriedades do projeto.

Se você observar a classe de teste VectorsJUnit3Test.java gerada no editor, você poderá notar que o IDE gerou a classe de teste a seguir com os métodos de teste para os métodos equal e scalarMultiplication.

public class VectorsJUnit3Test extends TestCase { /** * Test of equal method, of class Vectors. */ public void testEqual() { System.out.println("equal"); int[] a = null; int[] b = null; boolean expResult = false; boolean result = Vectors.equal(a, b); assertEquals(expResult, result);

// TODO review the generated test code and remove the default call to fail. fail("The test case is a prototype."); }

/** * Test of scalarMultiplication method, of class Vectors. */ public void testScalarMultiplication() { System.out.println("scalarMultiplication"); int[] a = null; int[] b = null; int expResult = 0; int result = Vectors.scalarMultiplication(a, b); assertEquals(expResult, result); // TODO review the generated test code and remove the default call to fail. fail("The test case is a prototype."); }}

O corpo do método de cada teste gerado é fornecido somente como um guia e precisa ser modificado para ser um caso de teste real. Você pode desmarcar Corpos de método padrão na caixa de diálogo Criar testes se não quiser que o código seja gerado por você.

Quando o IDE gera os nomes para os métodos de teste, cada nome de método é prefixado com teste, pois a JUnit 3 usa convenções de nomeação e reflexão para identificar testes. Para identificar métodos de teste, cada método deverá seguir a sintaxe test<NOME>.

Na JUnit 4 não é mais necessário usar essa sintaxe de nomeação de métodos de teste, pois você pode usar anotações para identificar os métodos de teste e a classe de teste não precisa mais estender o TestCase.

Escrevendo métodos de teste para Vectors.java

Neste exercício, você modifica os métodos de teste gerados para torná-los testes funcionais e modificar as mensagens de saída padrão. Você não precisa modificar as mensagens de saída para executar os testes, mas pode querer modificar a saída para ajudar a identificar os resultados exibidos na janela de saída Resultados do teste JUnit.

1. Abra o VectorsJUnit3Test.java no editor.2. Modifique o esqueleto de teste do testScalarMultiplication, alterando o valor

de println e removendo as variáveis geradas. O método de teste agora deve se parecer com o seguinte (as alterações são mostradas em negrito):

3. public void testScalarMultiplication() {4. System.out.println("* VectorsJUnit3Test: 5. testScalarMultiplication()");6. assertEquals(expResult, result);

}

7. Agora adicione algumas asserções para testar o método. 8. public void testScalarMultiplication() {9. System.out.println("* VectorsJUnit3Test:

testScalarMultiplication()");

10. assertEquals( 0, Vectors.scalarMultiplication(new int[] { 0, 0}, new int[] { 0, 0}));

11. assertEquals( 39, Vectors.scalarMultiplication(new int[] { 3, 4}, new int[] { 5, 6}));

12. assertEquals(-39, Vectors.scalarMultiplication(new int[] {-3, 4}, new int[] { 5,-6}));

13. assertEquals( 0, Vectors.scalarMultiplication(new int[] { 5, 9}, new int[] {-9, 5}));

14. assertEquals(100, Vectors.scalarMultiplication(new int[] { 6, 8}, new int[] { 6, 8}));}

Este método de teste usa o método assertEquals da JUnit. Para usar a asserção, forneça as variáveis de entrada e o resultado esperado. Para passar no teste, o método de teste deve retornar de modo bem sucedido todos os resultados esperados com base nas variáveis fornecidas durante a execução do método. Você deve adicionar um número suficiente de asserções para abranger as várias permutações possíveis.

15. Modifique o esqueleto de teste para testEqual excluindo os corpos de método gerados e adicionando a seguinte println.

System.out.println("* VectorsJUnit3Test: testEqual()");

O método de teste deve ser semelhante a:

public void testEqual() { System.out.println("* VectorsJUnit3Test: testEqual()");}

16. Modifique o método testEqual adicionando as seguintes asserções (exibidas em negrito).

17. public void testEqual() {18. System.out.println("* VectorsJUnit3Test: testEqual()");19. assertTrue(Vectors.equal(new int[] {}, new int[] {}));20. assertTrue(Vectors.equal(new int[] {0}, new int[] {0}));21. assertTrue(Vectors.equal(new int[] {0, 0}, new int[] {0,

0}));22. assertTrue(Vectors.equal(new int[] {0, 0, 0}, new int[] {0,

0, 0}));23. assertTrue(Vectors.equal(new int[] {5, 6, 7}, new int[] {5,

6, 7}));24.25. assertFalse(Vectors.equal(new int[] {}, new int[] {0}));26. assertFalse(Vectors.equal(new int[] {0}, new int[] {0,

0}));27. assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0,

0, 0}));28. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[]

{0, 0}));29. assertFalse(Vectors.equal(new int[] {0, 0}, new int[]

{0}));30. assertFalse(Vectors.equal(new int[] {0}, new int[] {}));31.32. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[]

{0, 0, 1}));

33. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 1, 0}));

34. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {1, 0, 0}));

35. assertFalse(Vectors.equal(new int[] {0, 0, 1}, new int[] {0, 0, 3}));}

O teste usa os métodos assertTrue e assertFalse da JUnit para testar vários resultados possíveis. Para que o teste deste método seja aprovado, o assertTrue deve ser totalmente verdadeiro e assertFalse deve ser totalmente falso.

Compare: Escrevendo métodos de teste para Vectors.java (JUnit 4)

Criando uma classe de teste para Utils.java

Agora você pode criar os esqueletos de teste para Utils.java. Quando você criou o teste no exercício anterior, o IDE lhe solicitou a versão da JUnit. Desta vez, você não precisará selecionar uma versão.

1. Clique com o botão direito do mouse em Utils.java e escolha Ferramentas > Criar testes JUnit.

2. Selecione Inicializador de teste e Finalizador de teste na caixa de diálogo, se estiverem desmarcados.

3. Modifique o nome da classe de teste para UtilsJUnit3Test na caixa de diálogo Criar testes. Clique em OK.

Quando você clicar em OK, o IDE criará o arquivo de teste UtilsJUnit3Test.java no diretório Pacotes de teste > amostras. Você pode ver que, além de criar os esqueletos de teste testComputeFactorial, testConcatWords e testNormalizeWord para os métodos em Utils.java, o IDE também cria o método setUp do inicializador de teste e o método tearDown do finalizador de teste.

Escrevendo métodos de teste para Utils.java

Neste exercício você adiciona casos de teste que ilustram alguns elementos de teste JUnit comuns. Você também adiciona um println aos métodos, pois alguns métodos, por padrão, não imprimem saída. Adicionando um println aos métodos, você pode olhar posteriormente na janela de resultado de teste JUnit para verificar se os métodos foram executados e em qual ordem.

Inicializadores e finalizadores de testes

Os métodos setUp e tearDown são usados para inicializar e finalizar condições de teste. Você não precisa dos métodos setUp e tearDown para testar o Utils.java, mas eles estão incluídos aqui para demonstrar como funcionam.

O método setUp é um método de inicialização de testes e é executado antes de cada caso de teste na classe de teste. Um método de inicialização de teste não é obrigatório para executar testes, mas se for necessário inicializar algumas variáveis antes de executá-lo, use o método do inicializador de testes.

O método tearDown é um método de finalizador de testes e é executado depois de cada caso de teste na classe de teste. Um método de finalizador de teste não é obrigatório para executar testes, mas você pode precisar de um finalizador para limpar quaisquer dados que eram necessários durante a execução dos casos de teste.

1. Faça as alterações a seguir (exibidas em negrito) para adicionar um println em cada método.

2. @Override3. protected void setUp() throws Exception {4. super.setUp();5. System.out.println("* UtilsJUnit3Test: setUp() method");6. }7.8. @Override9. protected void tearDown() throws Exception {10. super.tearDown();11. System.out.println("* UtilsJUnit3Test: tearDown() method");

}

Quando você executa o teste, o texto do println de cada método será exibido na janela de saída Resultados de testes JUnit. Se você não adicionar o println, não haverá saída para mostrar que os métodos foram executados.

Testando o uso de uma asserção simples

Este caso de teste simples testa o método concatWords. Em vez de usar o método de teste gerado testConcatWords, você adicionará um novo método de teste chamado testHelloWorld, que usa uma única asserção simples para testar se o método concatena as strings corretamente. O assertEquals no caso de teste usa a sintaxe assertEquals(EXPECTED_RESULT, ACTUAL_RESULT) para testar se o resultado esperado é igual ao resultado real. Nesse caso, se a entrada para o método concatWords é "Hello", ", ", "world" e "!", o resultado esperado deve ser igual a "Hello, world!".

1. Exclua o método de teste gerado testConcatWords.2. Adicione o método a seguir para testar o método concatWords. 3. public void testHelloWorld() {4. assertEquals("Hello, world!", Utils.concatWords("Hello", ",

", "world", "!"));}

5. Adicione uma declaração println para exibir o texto sobre o teste na janela Resultados de testes JUnit.

6. public void testHelloWorld() {7. System.out.println("* UtilsJUnit3Test: test method 1 -

testHelloWorld()"); assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!"));

Compare: Testando usando uma asserção simples (JUnit 4)

Testando a utilização de um Tempo de espera

Esse teste demonstra como verificar se um método está demorando muito tempo para ser concluído. Se o método está demorando muito tempo, o thread de teste é interrompido e o teste falha. Você pode especificar o limite de tempo no teste.

O método de teste invoca o método computeFactorial em Utils.java. Você pode supor que o método computeFactorial esteja correto, mas nesse caso você quer testar se o cálculo é concluído dentro de 1000 milissegundos. O thread computeFactorial e um thread de teste são iniciados ao mesmo tempo. O thread de teste será interrompido depois de 1000 milissegundos e lançará um TimeoutException a menos que o thread computeFactorial seja concluído primeiro. Você adicionará uma mensagem de modo que uma mensagem seja exibida se um TimeoutException for lançado.

1. Exclua o método de teste gerado testComputeFactorial.2. Adicione o método testWithTimeout que calcula o fatorial de um número gerado

aleatoriamente. 3. public void testWithTimeout() throws InterruptedException,

TimeoutException {4. final int factorialOf = 1 + (int) (30000 * Math.random());5. System.out.println("computing " + factorialOf + '!');6.7. Thread testThread = new Thread() {8. public void run() {9. System.out.println(factorialOf + "! = " +

Utils.computeFactorial(factorialOf));10. }11. };

}

12. Corrija suas importações para importar o java.util.concurrent.TimeoutException.

13. Adicione o código a seguir (exibido em negrito) para que o método interrompa o thread e exiba uma mensagem se o teste levar muito tempo para ser executado.

14. Thread testThread = new Thread() {15. public void run() {16. System.out.println(factorialOf + "! = " +

Utils.computeFactorial(factorialOf));17. }18. };19.20. testThread.start();21. Thread.sleep(1000);22. testThread.interrupt();23.24. if (testThread.isInterrupted()) {25. throw new TimeoutException("the test took too long to

complete");26. }

}

Você pode modificar a linha Thread.sleep para alterar o número de milissegundos antes que o tempo de espera seja lançado.

27. Adicione a seguinte println (exibida em negrito) para imprimir o texto sobre o teste na janela Resultados dos testes JUnit.

28. public void testWithTimeout() throws InterruptedException, TimeoutException {

29. System.out.println("* UtilsJUnit3Test: test method 2 - testWithTimeout()");

30. final int factorialOf = 1 + (int) (30000 * Math.random());31. System.out.println("computing " + factorialOf + '!');

Compare: Testando a utilização de um tempo de espera (JUnit 4)

Testando a existência de uma exceção esperada

Esse teste demonstra como testar se há uma exceção esperada. O método falhará se não lançar a exceção esperada especificada. Nesse caso, você está testando se o método computeFactorial lança um IllegalArgumentException caso a variável de entrada seja um número negativo (-5).

1. Adicione o método testExpectedException a seguir, que invoca o método computeFactorial com uma entrada de -5.

2. public void testExpectedException() {3. try {4. final int factorialOf = -5;5. System.out.println(factorialOf + "! = " +

Utils.computeFactorial(factorialOf));6. fail("IllegalArgumentException was expected");7. } catch (IllegalArgumentException ex) {8. }

}

9. Adicione a seguinte println (exibida em negrito) para imprimir o texto sobre o teste na janela Resultados dos testes JUnit.

10. public void testExpectedException() {11. System.out.println("* UtilsJUnit3Test: test method 3 -

testExpectedException()"); try {

Compare: Testando se há uma exceção esperada (JUnit 4)

Desativando um teste

Este teste demonstra como desativar temporariamente um método de teste. Na JUnit 3, se um nome de método não iniciar com test, ele não será reconhecido como um método de teste. Nesse caso, você acrescenta o prefixo DISABLED ao nome do método de teste para desativá-lo.

1. Exclua o método de teste gerado testNormalizeWord.2. Adicione o método de teste a seguir à classe de teste. 3. public void testTemporarilyDisabled() throws Exception {4. System.out.println("* UtilsJUnit3Test: test method 4 -

checkExpectedException()");5. assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\

u0308"));}

O método de teste testTemporarilyDisabled será executado se você executar a classe de teste.

6. Acrescente o prefixo DISABLED_ (exibido em negrito) ao nome do método de teste. 7. public void DISABLED_testTemporarilyDisabled() throws Exception

{8. System.out.println("* UtilsJUnit3Test: test method 4 -

checkExpectedException()");9. assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\

u0308"));}

Compare: Desativando um teste (JUnit 4)

Agora que você escreveu os testes, poderá executar o teste e visualizar a saída do teste na janela Resultados de testes JUnit.

Executando os testes

Quando você executa um teste JUnit, os resultados são exibidos na janela Resultados de teste JUnit do IDE. Você pode executar classes de teste JUnit individuais ou selecionar Executar > Testar PROJECT_NAME no menu principal para executar todos os testes do projeto. Se você escolher Executar > Teste, o IDE executará todas as classes de teste na pasta Pacotes de teste. Para executar uma classe de teste individual, clique com o botão direito do mouse na classe de teste no nó Pacotes de teste e selecione Executar arquivo.

Selecione Executar > Testar projeto (JUnit-Sample), a partir do menu principal.

Quando você executar o teste, verá um dos resultados a seguir na janela Resultados de testes JUnit.

Nesta imagem (clique na imagem para ampliá-la) você pode ver que o projeto foi aprovado em todos os testes. O painel esquerdo exibe os resultados dos métodos de teste individuais e o painel direito exibe a saída do teste. Se você observar na saída, poderá verificar a ordem na qual os testes foram executados. A println adicionada a cada um dos métodos de testes imprimiu o nome do teste na janela de saída. Você também pode observar que na UtilJUnit3Test o método setUp foi executado antes de cada método de teste, e o método tearDown foi executado depois de cada método.

Nesta imagem (clique na imagem para ampliá-la) você pode verificar que o projeto falhou em um dos testes. O método testTimeout demorou muito tempo para ser concluído e o thread de teste foi interrompido, causando a falha do teste. Ele levou mais de 1000 milissegundos para calcular o fatorial do número gerado aleatoriamente (22991).

A próxima etapa após a criação das classes de teste de unidades é criar suites de testes. Consulte Criando suites de testes JUnit 3 para ver como executar os testes especificados como um grupo, de modo que você não precise executar cada teste individualmente.

Escrevendo testes JUnit 4

Neste exercício, você cria testes de unidades JUnit 4 para as classes Vectors.java e Utils.java. Os casos de teste da JUnit 4 são os mesmos dos casos de teste da JUnit 3, mas você observará que a sintaxe para a escrita dos testes é mais simples.

Você usará a criação de esqueletos de teste do IDE com base nas classes em seu projeto. Na primeira vez em que você usar o IDE para criar esqueletos de teste, o IDE solicitará que você escolha a versão da JUnit.

Se você já selecionou a JUnit 3.x como a versão padrão para seus testes, será necessário alterar a versão padrão para JUnit 4.x. Para alterar a versão da JUnit padrão, clique com o botão direito do mouse no nó Testar bibliotecas, selecione Adicionar biblioteca e adicione as bibliotecas da JUnit 4 ao projeto. Ao criar um novo teste, selecione a versão 4.x quando surgir a solicitação para que você escolha a versão da JUnit. Ao selecionar a JUnit 4.x, o IDE removerá as bibliotecas da JUnit 3.x desnecessárias. Você ainda pode executar testes das JUnit 3, mas quaisquer novos testes criados usarão a JUnit 4.

Criando uma classe de teste para Vectors.java

Neste exercício, você criará os esqueletos de teste da JUnit para o Vectors.java.

1. Clique com o botão direito do mouse em Vectors.java e selecione Ferramentas > Criar testes JUnit.

2. Selecione a JUnit 4.x na caixa de diálogo Selecionar a versão da JUnit.

Ao selecionar a JUnit 4.x, o IDE removerá as bibliotecas da JUnit 3. Se o seu projeto tem bibliotecas JUnit 4, você pode escrever e executar testes JUnit 3 e JUnit 4.

3. Modifique o nome da classe de teste para VectorsJUnit4Test na caixa de diálogo Criar testes.

Quando você alterar o nome da classe de teste, será exibido um aviso sobre a alteração do nome. O nome padrão é baseado no nome da classe que você está testando, com a palavra Teste agregada ao nome. Por exemplo, para a classe MyClass.java, o nome padrão da classe de teste é MyClassTest.java. Diferente da JUnit 3, na JUnit 4, o teste não precisa ser finalizado com a palavra Teste. Normalmente, é melhor manter o nome padrão, porém, como você está criando todos os testes da JUnit no mesmo pacote neste tutorial, os nomes das classes de teste devem ser exclusivos.

4. Desmarque Inicializador de teste e Finalizador de teste. Clique em OK.

Quando você clicar em OK, o IDE criará um esqueleto de teste JUnit no diretório do pacote de teste sample.

Um projeto precisa de um diretório para que os pacotes de teste criem testes. A localização padrão do diretório de pacotes de teste está no nível de raiz do projeto, mas você pode especificar uma localização diferente para o diretório na caixa de diálogo Propriedades do projeto.

Se observar VectorsJUnit3Test.java no editor, você irá verificar que o IDE gerou os métodos de teste testEqual e testScalarMultiplication. Na JUnit 4, cada método de teste é anotado com @Test. O IDE gerou os nomes dos métodos de teste com base nos nomes do método em Vectors.java, mas o nome do método de teste não precisa ter o prefixo test. O corpo padrão de cada método de teste gerado é fornecido exclusivamente como um guia e precisa ser modificado para se tornar caso de teste real.

Você pode desmarcar Corpos de método padrão na caixa de diálogo Criar testes se não quiser que os corpos do método sejam gerados para você.

O IDE também gerou os seguintes métodos de inicializador e finalizador de classes de teste:

@BeforeClass

public static void setUpClass() throws Exception {}

@AfterClasspublic static void tearDownClass() throws Exception {}

O IDE gera os métodos inicializador e finalizador de classes por padrão durante a criação das classes de teste JUnit 4. As anotações @BeforeClass e @AfterClass são usadas para marcar métodos que devem ser executados antes e depois de executar a classe de teste. Você pode excluir métodos, pois não precisará deles para testar o Vectors.java.

É possível configurar os métodos que são gerados por padrão configurando as opções da JUnit na janela Opções.

Escrevendo métodos de teste para Vectors.java

Neste exercício, você modificará cada um dos métodos de teste gerados para testar os métodos usando o método assert da JUnit e para alterar os nomes dos métodos de teste. Na JUnit 4 você tem maior flexibilidade ao nomear métodos de teste, pois os métodos de teste são indicados pela anotação @Test e não exigem o prefixo test para nomes de métodos de teste.

1. Abra o VectorsJUnit4Test.java no editor.2. Modifique o método de teste do testScalarMultiplication alterando o nome do

método, o valor de println e removendo as variáveis geradas. O método de teste agora deve se parecer com o seguinte (as alterações são mostradas em negrito):

3. @Test4. public void ScalarMultiplicationCheck() {5. System.out.println("* VectorsJUnit4Test:

ScalarMultiplicationCheck()");6. assertEquals(expResult, result);

}

Ao escrever testes, não é necessário alterar a saída impressa. Isso é realizado neste exercício, portanto é mais fácil identificar os resultados de teste na janela de saída.

7. Agora adicione algumas asserções para testar o método. 8. @Test9. public void ScalarMultiplicationCheck() {10. System.out.println("* VectorsJUnit4Test:

ScalarMultiplicationCheck()");11. assertEquals( 0, Vectors.scalarMultiplication(new int[]

{ 0, 0}, new int[] { 0, 0}));12. assertEquals( 39, Vectors.scalarMultiplication(new int[]

{ 3, 4}, new int[] { 5, 6}));13. assertEquals(-39, Vectors.scalarMultiplication(new int[] {-

3, 4}, new int[] { 5,-6}));14. assertEquals( 0, Vectors.scalarMultiplication(new int[]

{ 5, 9}, new int[] {-9, 5}));15. assertEquals(100, Vectors.scalarMultiplication(new int[]

{ 6, 8}, new int[] { 6, 8}));}

Neste método de teste, você usa o método assertEquals da JUnit. Para usar a asserção, forneça as variáveis de entrada e o resultado esperado. Para passar no teste, o método de teste deve retornar de modo bem sucedido todos os resultados esperados com base nas variáveis fornecidas durante a execução do método. Você deve adicionar um número suficiente de asserções para abranger as várias permutações possíveis.

16. Altere o nome do método de teste testEqual para equalsCheck.17. Modifique o método de teste equalsCheck excluindo o corpo do método gerado e

adicionando a seguinte println.

System.out.println("* VectorsJUnit4Test: equalsCheck()");

O método de teste deve ser semelhante a:

@Testpublic void equalsCheck() { System.out.println("* VectorsJUnit4Test: equalsCheck()");}

18. Modifique o método equalsCheck adicionando as asserções a seguir (exibidas em negrito).

19. @Test20. public void equalsCheck() {21. System.out.println("* VectorsJUnit4Test: equalsCheck()");22. assertTrue(Vectors.equal(new int[] {}, new int[] {}));23. assertTrue(Vectors.equal(new int[] {0}, new int[] {0}));24. assertTrue(Vectors.equal(new int[] {0, 0}, new int[] {0,

0}));25. assertTrue(Vectors.equal(new int[] {0, 0, 0}, new int[] {0,

0, 0}));26. assertTrue(Vectors.equal(new int[] {5, 6, 7}, new int[] {5,

6, 7}));27.28. assertFalse(Vectors.equal(new int[] {}, new int[] {0}));29. assertFalse(Vectors.equal(new int[] {0}, new int[] {0,

0}));30. assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0,

0, 0}));31. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[]

{0, 0}));32. assertFalse(Vectors.equal(new int[] {0, 0}, new int[]

{0}));33. assertFalse(Vectors.equal(new int[] {0}, new int[] {}));34.35. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[]

{0, 0, 1}));36. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[]

{0, 1, 0}));37. assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[]

{1, 0, 0}));38. assertFalse(Vectors.equal(new int[] {0, 0, 1}, new int[]

{0, 0, 3}));}

O teste usa os métodos assertTrue e assertFalse da JUnit para testar vários resultados possíveis. Para que o teste deste método seja aprovado, o assertTrue deve ser totalmente verdadeiro e assertFalse deve ser totalmente falso.

Compare: Escrevendo métodos de teste para Vectors.java (JUnit 3)

Criando uma classe de teste para Utils.java

Agora você criará os métodos de teste da JUnit para o Utils.java. Quando você criou a classe de teste no exercício anterior, o IDE solicitou a versão da JUnit. Agora você é solicitado a selecionar uma versão neste momento, pois já selecionou a versão da JUnit e todos os testes subseqüentes da JUnit são criados nessa versão.

Você ainda pode escrever e executar testes da JUnit 3 se selecionar a JUnit 4 como a versão, mas o IDE usa o modelo da JUnit 4 para a geração de esqueletos de teste.

1. Clique com o botão direito do mouse em Utils.java e selecione Ferramentas > Criar testes JUnit.

2. Selecione Inicializador de teste e Finalizador de teste na caixa de diálogo, se estiverem desmarcados.

3. Modifique o nome da classe de teste para UtilsJUnit4Test na caixa de diálogo Criar testes. Clique em OK.

Quando você clicar em OK, o IDE criará o arquivo de teste UtilsJUnit4Test.java no diretório Pacotes de teste > amostras. Você pode observar que o IDE gerou os métodos de teste testComputeFactorial, testConcatWords e testNormalizeWord para os métodos em Utils.java. O IDE também gerou os métodos inicializador e finalizador para o teste e para a classe de teste.

Escrevendo métodos de teste para Utils.java

Neste exercício, você adicionará casos de teste que ilustram alguns elementos comuns de teste da JUnit. Você também adicionará uma println aos métodos, pois alguns métodos não imprimem saída alguma na janela Resultados do teste JUnit para indicar que foram executados ou que o método passou no teste. Pela adição de uma println aos métodos, você pode verificar se os métodos foram executados e em qual ordem.

Inicializadores e finalizadores de testes

Quando você criou a classe de teste para Utils.java, o IDE gerou métodos anotados do inicializador e finalizador. Você pode escolher qualquer nome do método, pois não há convenção de nomeação obrigatória.

Não é necessário que os métodos inicializador e finalizador testem Utils.java, mas eles são incluídos neste tutorial para demonstrar como funcionam.

Na JUnit 4, você pode usar anotações para marcar os tipos de métodos inicializador e finalizador a seguir.

Inicializador da classe de teste. A anotação @BeforeClass marca um método como um método de inicialização da classe de teste. Um método de inicialização de classe de teste é executado somente uma vez, e antes de qualquer outro método na classe de teste. Por exemplo, em vez de criar uma conexão de banco de dados em um inicializador de teste e criar uma nova conexão antes de cada método de teste, você pode usar um inicializador da classe de teste para abrir uma conexão antes de executar os testes. Em seguida, é possível fechar a conexão com o finalizador da classe de teste.

Finalizador da classe de teste. A anotação @AFterClass marca um método como um método finalizador da classe de teste. Um método finalizador da classe de teste é executado apenas uma vez e depois que todos os outros métodos na classe de teste foram finalizados.

Inicializador de teste. A anotação @Before marca um método como um método de inicialização de teste. Um método de inicialização de teste é executado antes de cada caso de teste na classe de teste. Um método de inicialização de teste não é obrigatório para executar os testes, mas se você precisar inicializar algumas variáveis antes de executar um teste, você usará um método inicializador de teste.

Finalizador de teste. A anotação @After marca um método como um método finalizador de teste. Um método finalizador de teste é executado depois de cada caso de teste na classe de teste. Um método finalizador de teste não é obrigatório para executar testes, mas você pode precisar de um finalizador para limpar eventuais dados que foram necessários ao executar os casos de teste.

Faça as seguintes alterações (exibidas em negrito) para adicionar uma println aos métodos inicializador e finalizador.

@BeforeClasspublic static void setUpClass() throws Exception { System.out.println("* UtilsJUnit4Test: @BeforeClass method");}

@AfterClasspublic static void tearDownClass() throws Exception { System.out.println("* UtilsJUnit4Test: @AfterClass method");}

@Beforepublic void setUp() { System.out.println("* UtilsJUnit4Test: @Before method");}

@Afterpublic void tearDown() { System.out.println("* UtilsJUnit4Test: @After method");}

Compare: Inicializadores e finalizadores de testes (JUnit 3)

Quando você executa a classe de teste, o texto da println que você adicionou é exibido no painel de saída da janela Resultados do teste JUnit. Se você não adicionar a println, não haverá saída para indicar que os métodos inicializador e finalizador foram executados.

Testando o uso de uma asserção simples

Este caso de teste simples testa o método concatWords. Em vez de usar o método de teste gerado testConcatWords, você adicionará um novo método de teste chamado helloWorldCheck, que usa uma única asserção simples para testar se o método concatena as strings corretamente. O assertEquals no caso de teste usa a sintaxe assertEquals(EXPECTED_RESULT, ACTUAL_RESULT) para testar se o resultado esperado é igual ao resultado real. Nesse caso, se a entrada para o método concatWords é "Hello", ", ", "world" e "!", o resultado esperado deve ser igual a "Hello, world!".

1. Exclua o método de teste gerado testConcatWords.2. Adicione o método helloWorldCheck a seguir para testar Utils.concatWords. 3. @Test4. public void helloWorldCheck() {5. assertEquals("Hello, world!", Utils.concatWords("Hello", ",

", "world", "!"));}

6. Adicione uma declaração println para exibir o texto sobre o teste na janela Resultados de testes JUnit.

7. @Test8. public void helloWorldCheck() {9. System.out.println("* UtilsJUnit4Test: test method 1 -

helloWorldCheck()"); assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!"));

Compare: Testando usando uma asserção simples (JUnit 3)

Testando a utilização de um Tempo de espera

Esse teste demonstra como verificar se um método está demorando muito tempo para ser concluído. Se o método está demorando muito tempo, o thread de teste é interrompido e o teste falha. Você pode especificar o limite de tempo no teste.

O método de teste invoca o método computeFactorial em Utils.java. Você pode supor que o método computeFactorial esteja correto, mas nesse caso você quer testar se o cálculo é concluído dentro de 1000 milissegundos. Você faz isso interrompendo o thread de teste depois de 1000 milissegundos. Se o thread for interrompido, o método de teste lançará uma TimeoutException.

1. Exclua o método de teste gerado testComputeFactorial.2. Adicione o método testWithTimeout que calcula o fatorial de um número gerado

aleatoriamente. 3. @Test4. public void testWithTimeout() {5. final int factorialOf = 1 + (int) (30000 * Math.random());6. System.out.println("computing " + factorialOf + '!');7. System.out.println(factorialOf + "! = " +

Utils.computeFactorial(factorialOf));}

8. Adicione o código a seguir (exibido em negrito) para definir o tempo de espera e para interromper o thread se o método demorar muito tempo para ser executado.

9. @Test(timeout=1000)10. public void testWithTimeout() {

final int factorialOf = 1 + (int) (30000 * Math.random());

Você pode observar que o tempo de espera foi definido em 1000 milissegundos.

11. Adicione a seguinte println (exibida em negrito) para imprimir o texto sobre o teste na janela Resultados dos testes JUnit.

12. @Test(timeout=1000)13. public void testWithTimeout() {14. System.out.println("* UtilsJUnit4Test: test method 2 -

testWithTimeout()");15. final int factorialOf = 1 + (int) (30000 * Math.random());16. System.out.println("computing " + factorialOf + '!');

Compare: Testando usando um tempo de espera (JUnit 3)

Testando a existência de uma exceção esperada

Esse teste demonstra como testar se há uma exceção esperada. O método falhará se não lançar a exceção esperada especificada. Nesse caso, você está testando se o método computeFactorial lança um IllegalArgumentException caso a variável de entrada seja um número negativo (-5).

1. Adicione o método testExpectedException a seguir, que invoca o método computeFactorial com uma entrada de -5.

2. @Test3. public void checkExpectedException() {4. final int factorialOf = -5;5. System.out.println(factorialOf + "! = " +

Utils.computeFactorial(factorialOf));}

6. Adicione a propriedade a seguir (exibida em negrito) à anotação @Test para especificar que se espera que o teste lance a IllegalArgumentException.

7. @Test(expected=IllegalArgumentException.class)8. public void checkExpectedException() {9. final int factorialOf = -5;10. System.out.println(factorialOf + "! = " +

Utils.computeFactorial(factorialOf));}

11. Adicione a seguinte println (exibida em negrito) para imprimir o texto sobre o teste na janela Resultados dos testes JUnit.

12. @Test (expected=IllegalArgumentException.class)13. public void checkExpectedException() {14. System.out.println("* UtilsJUnit4Test: test method 3 -

checkExpectedException()");15. final int factorialOf = -5;16. System.out.println(factorialOf + "! = " +

Utils.computeFactorial(factorialOf));}

Compare: Testando a existência de uma exceção esperada (JUnit 3)

Desativando um teste

Este teste demonstra como desativar temporariamente um método de teste. Na JUnit 4, você simplesmente adiciona a anotação @Ignore para desativar o teste.

1. Exclua o método de teste gerado testNormalizeWord.2. Adicione o método de teste a seguir à classe de teste. 3. @Test4. public void temporarilyDisabledTest() throws Exception {5. System.out.println("* UtilsJUnit4Test: test method 4 -

checkExpectedException()");6. assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\

u0308"));}

O método de teste temporarilyDisabledTest será executado se você executar a classe de teste.

7. Adicione a anotação @Ignore (exibida em negrito) acima de @Test para desativar o teste.

8. @Ignore9. @Test10. public void temporarilyDisabledTest() throws Exception {11. System.out.println("* UtilsJUnit4Test: test method 4 -

checkExpectedException()");12. assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\

u0308"));}

13. Corrija as importações para importar a org.junit.Ignore.

Compare: Desativando um teste (JUnit 3)

Agora que você escreveu os testes, pode executar o teste e verificar a saída do teste na janela Resultados do teste JUnit.

Executando os testes

Você pode executar testes JUnit em todo o aplicativo ou em arquivos individuais e verificar os resultados no IDE. O modo mais fácil de executar todos os testes de unidade para o projeto é selecionar Executar > Teste <PROJECT_NAME> no menu principal. Se você escolher esse método, o IDE executará todas as classes de teste nos Pacotes de teste. Para executar uma classe de teste individual, clique com o botão direito do mouse na classe de teste no nó Pacotes de teste e selecione Executar arquivo.

1. Clique com o botão direito do mouse em UtilsJUnit4Test.java na janela Projetos.

2. Escolha Arquivo de teste.

Quando você executa UtilsJUnit4Tests.java, o IDE executa somente os testes na classe de teste. Se a classe for aprovada em todos os testes, você observará algo similar à imagem a seguir na janela Resultados do teste JUnit.

Nesta imagem (clique na imagem para ampliá-la) você pode notar que o IDE executou o teste JUnit em Utils.java e que a classe passou em todos os testes. O painel esquerdo exibe os resultados dos métodos de teste individuais e o painel direito exibe a saída do teste. Se você observar na saída, poderá verificar a ordem na qual os testes foram executados. A println adicionada a cada um dos métodos de testes imprimiu o nome do teste na janela Resultados do teste e na janela Saída.

Você pode notar que em UtilsJUnit4Test o método inicializador da classe de teste anotado com @BeforeClass foi executado antes dos outros métodos e foi executado somente uma vez. O método finalizador da classe de teste anotado com @AfterClass foi executado por último, depois de todos os outros métodos na classe. O método inicializador de teste anotado com @Before foi executado antes de cada método de teste.

Os controles no lado esquerdo da janela Resultados do teste, permitem executar com facilidade novamente o teste. Você pode usar o filtro para alternar entre a exibição de todos os resultados do teste ou somente os testes que falharam. As setas permitem ir para a próxima falha ou para a falha anterior.

Quando você clica com o botão direito do mouse em um resultado do teste na janela Resultados do teste, o menu suspenso permite escolher ir para o código-fonte de teste, executar novamente o teste ou depurar o teste.

O próximo passo após a criação das classes de teste de unidades é criar suites de testes. Consulte Criando suites de testes JUnit 4 para ver como executar os testes especificados como um grupo, de modo que você não tenha que executar cada teste individualmente.

Criando suites de testes

Durante a criação de testes para um projeto, você geralmente acabará com muitas classes de teste. Embora seja possível executar classes de teste individualmente ou executar todos os testes em um projeto, em muitos casos você irá querer executar um subconjunto dos testes ou executar testes em uma ordem específica. Você pode fazer isso criando um ou mais suites de testes. Por exemplo, você pode criar suites que testam aspectos específicos de seu código ou condições específicas.

Uma suite de testes é basicamente uma classe com um método que chama os casos de teste especificados, como as classes de teste específicas, os métodos de teste em classes de teste e outros suites. Um suite de teste pode ser incluído como parte de uma classe de

teste, mas as práticas recomendadas aconselham a criar classes individuais de suites de testes.

Você pode criar suites de teste JUnit 3 e JUnit 4 para seu projeto manualmente ou o IDE pode gerar os suites para você. Quando você usa o IDE para gerar um suite de teste, por padrão o IDE gera o código para invocar todas as classes de teste no mesmo pacote do suite de teste. Depois que o suite de testes foi criado, você pode modificar a classe para especificar os testes que deseja executar como parte desse suite.

Criando suites de testes JUnit 3

Se você selecionou o JUnit 3 como a versão de seus testes, o IDE pode gerar suites de teste JUnit 3 com base nas classes de testes no pacote de testes. Na JUnit 3 você especifica as classes de teste a incluir no suite de testes criando uma instância do TestSuite e usando o método addTest para cada teste.

1. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Novo > Outro para abrir o assistente para Novo arquivo.

2. Selecione a categoria JUnit e o suite de testes. Clique em Próximo.3. Insira JUnit3TestSuite para o nome de arquivo.4. Selecione o pacote amostra para criar o suite de testes na pasta de amostras, contida

na pasta pacotes de testes.5. Desmarque Inicializador de teste e Finalizador de teste. Clique em Terminar.

Quando você clicar em Terminar, o IDE criará a classe do suite de testes no pacote amostra e abrirá a classe no editor. O suite de testes conterá o código a seguir se o pacote amostra contiver as classes de teste VectorsJUnit3Test.java e Utils.JUnit3Test.java.

public JUnit3TestSuite(String testName) { super(testName);}

public static Test suite() { TestSuite suite = new TestSuite("JUnit3TestSuite"); suite.addTest(new TestSuite(sample.VectorsJUnit3Test.class)); suite.addTest(new TestSuite(sample.UtilsJUnit3Test.class)); return suite;}

Criando suites de teste JUnit 4

Se você selecionou a JUnit 4 para a versão de seus testes, o IDE pode gerar suites de teste JUnit 4. A JUnit 4 é compatível com versões anteriores, portanto você pode executar suites de testes JUnit 4 que contenham testes JUnit 4 ou JUnit 3. Nos suites de teste JUnit 4, você especifica as classes de teste a incluir como valores da anotação @Suite.

Para executar os suites de teste JUnit 3 como parte de um suite de teste JUnit 4 é necessária a JUnit 4.4 ou superior.

1. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Novo > Outro para abrir o assistente para Novo arquivo.

2. Selecione a categoria JUnit e o suite de testes. Clique em Próximo.3. Insira JUnit4TestSuite como o nome de arquivo.4. Selecione o pacote amostra para criar o suite de testes na pasta de amostras, contida

na pasta pacotes de testes.5. Desmarque Inicializador de teste e Finalizador de teste. Clique em Terminar.

Quando você clicar em Terminar, o IDE criará a classe do suite de testes no pacote amostra e abrirá a classe no editor. O suite de testes contém o código a seguir.

@RunWith(Suite.class)@Suite.SuiteClasses(value={UtilsJUnit4Test.class, VectorsJUnit4Test.class})public class JUnit4TestSuite {}

Quando você executar o suite de testes, o IDE executará as classes de teste UtilsJUnit4Test e VectorsJUnit4Test na ordem em que foram apresentadas.

Executando os suites de testes

Você pode executar um suite de testes da mesma forma que executa qualquer classe de teste individual.

1. Expanda o nó Pacotes de teste na janela Projetos.2. Clique com o botão direito do mouse na classe da suite de testes e selecione Arquivo

de teste.

Quando você executar o suite de testes, o IDE executará os testes incluídos no suite na ordem em que foram apresentados. Os resultados são exibidos na janela Resultados do teste JUnit.

Nessa imagem (clique na imagem para ampliá-la) você pode verificar os resultados de um suite de testes JUnit 3. O suite de teste executou as classes de teste UtilsJUnit3Test e VectorsJUnit3Test como um teste único e exibiu os resultados no painel esquerdo como resultados de um só teste. A saída no painel direito é a mesma de quando você executa o teste individualmente.

Nessa imagem (clique na imagem para ampliá-la) você pode verificar os resultados um suite de testes JUnit 4. O suite de teste executou as classes de teste UtilsJUnit4Test e VectorsJUnit4Test como um teste único e exibiu os resultados no painel esquerdo como resultados de um só teste. A saída no painel direito é a mesma de quando você executa o teste individualmente.

Nessa imagem (clique na imagem para ampliá-la) você pode verificar os resultados de um suite de testes mistos. O suite de teste inclui a JUnit 4 e uma das classes de teste JUnit 3. O suite de testes executou as classes de teste UtilsJUnit3Test.java e JUnit4TestSuite.java como um único teste e exibiu os resultados no painel esquerdo como resultados de um só teste. A saída no painel direito é a mesma obtida com a execução do teste individualmente.

Resumo

Este tutorial foi uma introdução básica à criação de testes de unidades JUnit e suites de testes no NetBeans IDE. O IDE suporta o JUnit 3 e o JUnit 4, e este documento demonstrou algumas das alterações introduzidas no JUnit 4, que são projetadas para tornar mais simples a criação e a execução de testes.

Como demonstrado neste tutorial, um dos principais aprimoramentos no JUnit4 é o seu suporte para anotações. No JUnit 4 você agora pode usar anotações para fazer o seguinte:

Identificar um teste usando a anotação @Test ao invés de uma convenção de nomeação

Identificar os métodos setUp e tearDown com as anotações @Before e @After Identificar os métodos setUp e tearDown que se aplicam à toda a classe de teste.

Métodos anotados com @BeforeClass são somente executados uma vez, antes que quaisquer métodos de teste na classe sejam executados. Métodos anotados com @AfterClass também são executados somente uma vez, após todos os métodos de teste tiverem terminado.

Identificar exceções esperadas Identificar testes que deveriam ser ignorados usando a anotação @Ignore

Especificar um parâmetro de expiração para um teste

Para obter mais informações sobre o uso do JUnit e outras alterações introduzidas no JUnit4, consulte os seguintes recursos:

Grupo JUnit nos grupos Yahoo www.junit.org

O teste do código geralmente ajuda a garantir que pequenas alterações feitas no código não interrompam o aplicativo. As ferramentas de testes automatizadas como a JUnit simplificam o processo de teste e, além disso, a execução freqüente de testes pode ajudar a encontrar erros precocemente.

Depurando aplicativos multithreaded no NetBeans IDEEste documento descreve como usar a janela Depuração no NetBeans IDE para depurar aplicativos multithreaded. O tutorial também demonstra como usar o IDE para detectar impasses em um aplicativo.

A janela Depuração simplifica o processo de depuração integrando em uma janela as informações sobre sessões de depuração, threads de aplicativos e pilhas de chamadas de threads. A janela Depuração permite que você veja facilmente o status dos threads de aplicativos para suspender e retomar qualquer um dos threads na sessão.

Este tutorial usa dois projetos de amostra para demonstrar como trabalhar com a janela Depuração. Para concluir este tutorial, primeiro faça o download e abra os projetos Gallery e Deadlock.

Conteúdo

Fazendo download de projetos de amostra Abrindo os projetos de amostra

o Executando o projeto Gallery o Executando o projeto Deadlock

Depurando os projetos de amostra o Suspendendo threads o Alternando threads o Detectando impasses

Para seguir este tutorial, você precisa dos seguintes recursos e softwares.

Software ou recurso Versão necessária

NetBeans IDE 6.7/6.5 Java

Java Development Kit (JDK)versão 6 ou

versão 5

Projeto Gallery e projeto Deadlock

Fazendo download de projetos de amostra

Você pode fazer o download dos projetos de amostra usados neste tutorial das seguintes formas:

Faça o download de um arquivo zip do projeto acabado. Retire o código-fonte do projeto do Kenai ao executar as seguintes etapas:

1. Escolha Equipe > Kenai > Obter código-fonte a partir do Kenai, a partir do menu principal.

Alternativamente, você pode escolher Abrir projeto Kenai para adicionar o projeto no painel do Kenai, e a seguir obter o código-fonte do projeto.

2. Na caixa de diálogo Obter código-fonte a partir do Kenai, localize o repositório Kenai ao clicar em Procurar para abrir a caixa de diálogo Procurar projetos Kenai.

3. Pesquise pelo Catálogo de amostras do NetBeans IDE.

Alternativamente, o código-fonte para a depuração de aplicativos de amostra também estão disponíveis a partir do repositório do projeto NetBeans Debugger Demos.

4. Selecione o Catálogo de amostra do NetBeans IDE e clique em OK.5. Clique em Procurar para especificar a Pasta a obter e selecione

NB67/Java/debugging-samples. Clique em OK.6. Especifique a pasta local para o código-fonte (a pasta local precisa estar vazia).7. Clique em Obter do Kenai.

Quando você clica em Obter do Kenai, o IDE inicializa a pasta local como um repositório Subversion e retira o código-fonte do projeto.

8. Clique em Abrir projeto na caixa de diálogo que aparece quando a retirada estiver completada.

Nota. o NetBeans IDE 6.7 é necessário.

Abrindo os projetos

Neste tutorial você usará dois aplicativos para demonstrar o suporte do IDE para a depuração de aplicativos multithreaded. Neste exercício, você abrirá e executará os dois projetos no IDE. Depois de executar os projetos, será necessário depurar cada um deles.

Executando o projeto Gallery

Gallery é um aplicativo Java Swing simples que reproduz imagens animadas. O aplicativo tem dois botões que permitem adicionar e remover imagens animadas. Neste exercício, você executará o aplicativo Gallery.

1. Faça o download e descompacte o arquivo debugging-samples.zip em seu sistema local.

2. Escolha Arquivo > Abrir no menu principal.3. Localize e selecione o projeto Gallery no diretório debugging-samples. Clique em Abrir.

Quando você clicar em Abrir, o IDE abrirá e exibirá o projeto na janela Projetos. Se você expandir o nó do projeto na janela Projetos, poderá observar que o projeto é um aplicativo Java Swing simples.

4. Clique com o botão direito do mouse no nó do projeto e escolha Executar para iniciar o aplicativo Gallery.

5. No aplicativo Gallery, clique em "Mais" para adicionar imagens e clique em "Menos" para remover imagens.

6. Feche a janela do aplicativo Gallery.

O projeto Gallery é um aplicativo multithreaded simples que você irá depurar neste tutorial.

Executando o projeto Deadlock

O aplicativo Deadlock contém um método main que inicia um thread, executado durante 500000 milissegundos. O método main inicia dois threads que imprimem na janela Saída quando concluídos.

1. Escolha Arquivo > Abrir no menu principal.2. Localize e selecione o projeto Deadlock no diretório debugging-samples. Clique em

Abrir.

Quando você clicar em Abrir, o IDE abrirá e exibirá o projeto na janela Projetos. Se você expandir o nó do projeto na janela Projetos, observará que o projeto é um aplicativo Java simples.

3. Clique com o botão direito do mouse no nó do projeto e escolha Executar para iniciar o aplicativo Deadlock.

Quando você clica em Run, a janela Saída abre e exibe a saída a seguir.

executar:Aplicativo iniciadoMyThread2 concluído com êxito.MyThread1 concluído com êxito.

4. Permita que o aplicativo finalize normalmente (cinco minutos).

Quando o aplicativo Deadlock finalizar, será exibido o seguinte na janela Saída.

Thread principal concluído

O projeto Deadlock é um aplicativo Java simples com dois threads. Quando você depurar o aplicativo, criará um impasse para ilustrar como o IDE pode ajudá-lo a detectar impasses.

Depurando os projetos de amostra

O projeto Gallery é um aplicativo Java Swing simples que exibe imagens animadas. Você adiciona e remove as imagens clicando nos botões do aplicativo. Clicar no botão "Mais" inicia um novo thread que exibe e anima uma imagem. Clicar no botão "Menos" pára o thread mais recente, interrompendo a animação e removendo a imagem.

Suspendendo threads

Neste exercício, você começa a depuração do aplicativo Gallery e adiciona imagens para iniciar alguns threads do aplicativo. Quando você inicia uma sessão de depuração, o IDE abre a janela Depuração no painel esquerdo do IDE. A janela Depuração exibe uma lista dos threads na sessão.

1. Clique com o botão direito do mouse no projeto Gallery na janela Projetos e escolha Depurar.

Quando você clica em Depurar, o IDE inicia o aplicativo Gallery e abre as janelas de depuração padrão. O IDE abre automaticamente a janela Depuração no lado esquerdo da janela principal e abre o Console do depurador na janela Saída.

2. Clique três vezes em "Mais" no aplicativo Gallery para iniciar três threads que exibem imagens animadas.

Se você observar a janela Depuração, poderá verificar que um novo thread foi iniciado para cada animação.

3. Suspenda dois threads clicando no botão "Suspender thread" à direita do thread, na janela Depuração.

Quando um thread é suspenso, o ícone do thread é alterado para indicar o novo estado. Você pode expandir o nó thread para visualizar a pilha de chamadas do thread. Você pode clicar com o botão direito do mouse nos itens na janela Depuração para abrir um menu suspenso com os comandos de depuração.

Se você observar o aplicativo Gallery, poderá verificar que, quando você suspendeu os threads, a animação desses threads foi interrompida.

A janela Depuração permite que você veja rapidamente e altere o status dos threads na sessão. Por padrão, a janela Depuração exibe os botões Retomar e Suspender no lado direito da janela. É possível ocultar os botões e personalizar ainda mais a exibição da janela Depuração usando a barra de ferramentas na parte inferior da janela Depuração. Se você estiver executando várias sessões de depuração, poderá usar a lista suspensa na parte superior da janela Depuração para escolher qual sessão será exibida na janela.

Alternando threads

Este exercício demonstra o que acontece quando você está avançando passo a passo no aplicativo e um thread diferente do aplicativo atinge um ponto de interrupção. Neste exercício você definirá um ponto de interrupção do método e iniciará o passo a passo no aplicativo. Enquanto estiver avançando passo a passo no aplicativo, você iniciará um novo thread que também atingirá o ponto de interrupção. O IDE informa quando isso ocorre, exibindo uma notificação na janela Depuração. Em seguida, você irá alternar entre os threads.

1. Expanda o pacote gallery na janela Projetos e clique duas vezes em Gallery.java para abrir o arquivo no editor.

2. Insira um ponto de interrupção do método em Gallery.java no início do método run clicando na margem esquerda, na linha 174.

3. Clique em "Mais" no aplicativo Gallery para iniciar um novo thread que atingirá o ponto de interrupção do método.

4. Clique em Passar sobre (F8) duas vezes para iniciar o passo-a-passo pelo método.

Você observará que o Contador do programa na margem do editor indica sua posição à medida que você avança passo a passo pelo método.

5. Clique em "Mais" no aplicativo Gallery para iniciar um novo thread que atingirá o ponto de interrupção do método.

Quando o novo thread atingir o ponto de interrupção do método, uma notificação de Novo ponto de interrupção atingido será exibida na janela Depuração, informando que outro thread atingiu um ponto de interrupção enquanto você avançava passo a passo pelo método.

Quando você estiver avançando passo a passo por um thread, e um ponto de interrupção for atingido em outro thread, o IDE oferecerá a opção de alternar para o outro thread ou continuar a avançar passo a passo pelo thread atual. Você pode clicar no botão de seta na notificação de Novo ponto de interrupção atingido para alternar para o thread que encontrou o ponto de interrupção. Você pode alternar para o novo thread a qualquer momento selecionando o thread na janela de notificação. Avançar passo a passo pelo thread do ponto de interrupção atual retoma o thread atual, porém o status de outros threads do aplicativo permanecem inalterados.

Observação. Se você observar a janela Depuração, poderá verificar que o thread atual (Thread_Jirka) é indicado por uma barra verde na margem. O thread que invocou a notificação atingindo o ponto de interrupção (Thread_Roman) é indicado por uma barra amarela e o ícone do thread indica que o thread está suspenso por um ponto de interrupção.

6. Clique na seta, na notificação Novo ponto de interrupção atingido, para alternar o thread atual para o novo thread (Thread_Roman).

Quando alternar para o novo thread, você observará o seguinte:

o O contador do programa se move para a posição na linha 175 no novo thread atual (Thread_Roman).

o Uma anotação "thread suspenso" ficará visível na margem, na linha 191, indicando que um thread (Thread_Jirka) está suspenso nessa linha.

7. Clique em Passar sobre algumas vezes para avançar passo a passo pelo novo thread atual (Thread_Roman).

8. Clique com o botão direito do mouse na anotação "thread suspenso" na margem do editor e escolha Definir como thread atual > Thread_Jirka para voltar ao thread

suspenso.

Como alternativa, você pode invocar o Seletor de thread atual (Alt+Shift+T) e alternar para qualquer um dos threads do aplicativo.

Quando você voltar para o Thread_Jirka, a anotação do thread suspenso será exibida ao lado da linha onde o Thread_Roman foi suspenso. Você pode retomar o Thread_Roman clicando em Retomar, na janela Depuração.

A janela Depuração permite que você veja e controle com muita precisão os estados dos threads. O depurador gerencia os threads do aplicativo para simplificar o fluxo de trabalho de depuração e para evitar que o processo de depuração crie impasses. Neste exercício, você observou o seguinte comportamento durante a depuração de um aplicativo no IDE.

Quando um thread atinge um ponto de interrupção, somente o thread do ponto de interrupção é suspenso.

Ao avançar passo a passo pelo apilcativo, o thread atual não é afetado quando outros threads atingem os pontos de interrupção.

O passo a passo retoma somente o thread atual. Quando a etapa é concluída, somente o thread atual é suspenso.

Você pode sair do aplicativo Gallery. No próximo exercício, você irá depurar o aplicativo Deadlock e usará o IDE para ajudar a detectar o impasse.

Detectando impasses

O IDE pode ajudar a identificar possíveis situações de impasse pesquisando automaticamente em todos os threads suspensos. Quando um impasse é detectado, o IDE exibe uma notificação na janela Depuração e identifica os threads envolvidos.

Para demonstrar a detecção de impasses do IDE, você executará o projeto de amostra Deadlock no depurador e criará uma situação de impasse.

1. Expanda o pacote myapplication e abra o Thread1.java e Thread2.java no editor de código-fonte.

2. Defina um ponto de interrupção em Thread1.java, na linha 20, e em Thread2.java, na linha 20

Para definir o ponto de interrupção, clique na margem do editor de código-fone, próximo à linha onde você deseja definir o ponto de interrupção. A anotação do ponto de interrupção é exibida na margem esquerda, perto da linha. Se você abrir a janela Pontos de interrupção (Alt-Shift-5), poderá verificar que os dois pontos de interrupção estão definidos e ativados.

3. Clique com o botão direito do mouse no projeto Deadlock, na janela Projetos, e escolha Depurar.

O método main executará os dois threads e ambos serão suspensos em um dos pontos de interrupção. Você pode visualizar os threads suspensos pelos pontos de interrupção na janela Depuração.

4. Na janela Depuração, retome os threads suspensos (MyThread1 e MyThread2) clicando nos botões Retomar à direita dos threads suspensos na janela Depuração.

A retomada dos threads MyThread1 e MyThread2 criará o estado de impasse.

5. Escolha Depurar\Verificar impasse no menu principal para verificar se há impasses nos threads suspensos.

Se você verificar o aplicativo e detectar um impasse, uma mensagem será exibida na janela Depuração que o informará sobre o impasse. Você pode observar que os threads no impasse são indicados com uma barra vermelha na margem esquerda da janela Depuração.

Este tutorial foi uma introdução básica a alguns dos recursos de depuração do IDE. A janela Depuração permite que você suspenda e retome facilmente os threads ao depurar um aplicativo. Isso pode ser extremamente útil quando você estiver depurando aplicativos multithreaded.

Maven