TUtorial Java 2

Importando projetos do Eclipse para o
NetBeans IDE
Conteú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ária

NetBeans IDE versão 6.5
versão 6 ou
Java Development Kit (JDK)
versã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

Clique com o botão direito do mouse no nó do
projeto e escolha Resolver problema de servidor
Resolver problema de servidor ausente
ausente. Em seguida, navegue até o arquivo ou
pasta que contém o servidor.
Clique com o botão direito do mouse no nó do
projeto e escolha Resolver problema de
Resolver problema de referência 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
Caso queira alterar a plataforma que o NetBeans
ProjectName não pode ser usada. Ela é
usa para o projeto, escolha Ferramentas >
um JRE e o projeto NetBeans requer
Plataformas e especifique uma plataforma
um JDK. O NetBeans usará a
diferente.
plataforma padrão.
O projeto Eclipse ProjecName afirma Caso queira alterar a plataforma que o NetBeans
usar o JDK a partir do diretório "{1}". usa para o projeto, escolha Ferramentas >
Mas esse diretório não existe. O Plataformas e especifique uma plataforma
NetBeans usará a plataforma padrão. diferente.
No NetBeans, inclusões e exclusões são
O NetBeans não oferece suporte a
declaradas em um local para todo o projeto. Para
inclusões/exclusões de código-fonte
verificar as inclusões e exclusões no projeto
por raiz de código-fonte como o
NetBeans, clique com o botão direito do mouse
Eclipse. Elas foram mescladas e é
no nó do projeto e, na janela Projetos, escolha
recomendável que você as verifique no
Propriedades. Na caixa de diálogo Propriedades
painel Código-fonte das propriedades
do projeto, selecione a aba Códigos-fonte e, em
do projeto.
seguida, clique no botão Inclusões/exclusões.
Falha na importação devido a .... Mais
Você pode abrir o arquivo de registro do IDE
detalhes podem ser encontrados no
escolhendo Visualizar > Registro do IDE.
arquivo de log do IDE.
Você pode importar apenas os seguintes tipos de
Tipo de projeto desconhecido, ele não projeto Eclipse: Projeto Java, Projeto Java de um
pode ser importado. 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.
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">
 ->
<property name="store.jar.name" value="MarsRoverViewer"/>
<property name="store.jar.name" value="MarsRoverViewer"/>
 <! - 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
IDE
Este 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.
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() {
testScalarMultiplication()");
10. assertEquals( 0, Vectors.scalarMultiplication(new int[]
{ 0, 0}, new int[] { 0, 0}));
{ 3, 4}, new int[] { 5, 6}));
12. assertEquals(-39, Vectors.scalarMultiplication(new int[] {-
3, 4}, new int[] { 5,-6}));
{ 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}));
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.
{0, 0, 1}));
{0, 1, 0}));
{1, 0, 0}));
{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. @Override
3. protected void setUp() throws Exception {
4. super.setUp();
5. System.out.println("* UtilsJUnit3Test: setUp() method");
6. }
7.
8. @Override
9. 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() {
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 {
testWithTimeout()");
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;
6. fail("IllegalArgumentException was expected");
7. } catch (IllegalArgumentException ex) {
8. }
}
10. public void testExpectedException() {
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 {
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
{
}
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 {
}
@AfterClass
public 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. @Test
4. public void ScalarMultiplicationCheck() {
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. @Test
9. public void ScalarMultiplicationCheck() {
ScalarMultiplicationCheck()");
{ 0, 0}, new int[] { 0, 0}));
{ 3, 4}, new int[] { 5, 6}));
13. assertEquals(-39, Vectors.scalarMultiplication(new int[] {-
3, 4}, new int[] { 5,-6}));
{ 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:
@Test
public void equalsCheck() {
System.out.println("* VectorsJUnit4Test: equalsCheck()");
}
18. Modifique o método equalsCheck adicionando as asserções a seguir (exibidas em

negrito).
19. @Test
20. 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}));
0, 0}));
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}));
{0, 0}));
32. assertFalse(Vectors.equal(new int[] {0, 0}, new int[]
{0}));
33. assertFalse(Vectors.equal(new int[] {0}, new int[] {}));
34.
{0, 0, 1}));
{0, 1, 0}));
{1, 0, 0}));
{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.
@BeforeClass
public static void setUpClass() throws Exception {
System.out.println("* UtilsJUnit4Test: @BeforeClass method");
}
@AfterClass
public static void tearDownClass() throws Exception {
System.out.println("* UtilsJUnit4Test: @AfterClass method");
}
@Before
public void setUp() {
System.out.println("* UtilsJUnit4Test: @Before method");
}
@After
public 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. @Test
4. 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. @Test
8. public void helloWorldCheck() {
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. @Test
4. public void testWithTimeout() {
}
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)
final int factorialOf = 1 + (int) (30000 * Math.random());
Você pode observar que o tempo de espera foi definido em 1000 milissegundos.
12. @Test(timeout=1000)
testWithTimeout()");
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. @Test
3. public void checkExpectedException() {
}
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)
}
12. @Test (expected=IllegalArgumentException.class)
}
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. @Test
4. public void temporarilyDisabledTest() throws Exception {
}
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. @Ignore
9. @Test
10. public void temporarilyDisabledTest() throws Exception {
}
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 IDE
Este 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.
NetBeans IDE 6.7/6.5 Java
versão 6 ou
Java Development Kit (JDK)
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 iniciado
MyThread2 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

TUtorial Java 2

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

TUtorial Java 2

Enviado por

Direitos autorais:

Formatos disponíveis

Importando projetos do Eclipse para o

 Assistente de importação de projetos do Eclipse

Software ou recurso Versão necessária

Assistente de importação de projetos do Eclipse

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

Como funciona o Assistente de importação

Importando e configurando projetos

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

2. Escolha Arquivo > Importar projeto > Projeto Eclipse.

4. Na página Projetos a importar, selecione os projetos que você deseja importar.

 Problemas de importação. Esse diálogo oferece informações sobre as

 Resolver problemas de referência. Essa caixa de diálogo alerta você sobre um

Construindo e executando um projeto

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

 Executar projeto. Testa a execução do aplicativo no IDE.

Arquivos do projeto NetBeans

 Arquivo build.xml ou arquivo nb-build.xml. O script de construção principal

Considerações sobre o controle de versão

Se o projeto estiver sob os sistemas de controle de versão CVS, Subversion ou

Sincronizando um projeto novamente

A ressincronização do projeto é unidirecional, de projetos Ecilpse para projetos

O IDe também ressincroniza os projetos automaticamente se as alterações na

Para sincronizar novamente de modo manual os projetos NetBeans com projetos

 Escolha Arquivo > Importar projeto > Ressincronizar projetos Eclipse.

Observações: quando você ressincronizar um projeto, a ressincronização é realizada em

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

Mensagem do problema Solução

Construindo, depurando e testando

Neste tutorial, utilizamos um aplicativo Java simples, um conversor, que converte as

Este tutorial leva aproximadamente 20 minutos para ser completado.

Para concluir este tutorial, são necessários o software e os recursos apresentados

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

1. Baixe do arquivo zip que contém a demonstração do aplicativo Convertor empacotado

Configurando o projeto para habilitar o Java Web

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

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

Explorando os arquivos Java Web Start

 launch.jnlp: este é um arquivo XML com elementos especiais e atributos que

É possível tentar o seguinte: fora do IDE, vá para o arquivo launch.html no sistema,

Modificando o arquivo JNLP

Em nosso exemplo, carregaremos os arquivos do aplicativo no projeto netbeans-

Carregando os arquivos do código-fonte

Agora nós iremos carregar os arquivos do código-fonte em um projeto Kenai e executar

1. Faça o logon no Kenai.com e vá à área de download do seu projeto.

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

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

<!-- Change the value of this property to be the name of your

<property name="store.dir" value="store"/> <property

<echo message="Packaging ${application.title} into a single

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

<zip destfile="${store.jar}"> destfile="${store.jar}"> <zip

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

</target> </ Target>

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

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

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 de biblioteca de classe Java

1. Escolha Arquivo > Novo projeto no menu principal.