| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| |
| = Adicionando Testes de Unidade a um Projeto C - Tutorial do NetBeans IDE |
| :jbake-type: tutorial |
| :jbake-tags: tutorials |
| :jbake-status: published |
| :icons: font |
| :syntax: true |
| :source-highlighter: pygments |
| :toc: left |
| :toc-title: |
| :description: Adicionando Testes de Unidade a um Projeto C - Tutorial do NetBeans IDE - Apache NetBeans |
| :keywords: Apache NetBeans, Tutorials, Adicionando Testes de Unidade a um Projeto C - Tutorial do NetBeans IDE |
| |
| _Colaboração de link:mailto:susanm@netbeans.org[+_Susan Morgan_+] |
| Março de 2014_ [Número da revisão: V8.0-1] |
| |
| |
| |
| == Requisitos |
| |
| *Para seguir este tutorial, você precisa do software a seguir.* |
| |
| |=== |
| |Software |Versão Necessária |
| |
| |NetBeans IDE (incluindo o suporte ao C/C++/Fortran) |link:https://netbeans.org/downloads/index.html[+versão 7.4 ou 8.0 do NetBeans com o plug-in C/C+++] |
| |
| |Java Development Kit (JDK) |link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+Versão 7 ou 8+] |
| |
| |Framework de teste CUnit 2.1 |link:http://sourceforge.net/projects/cunit/[+Projetok de Framework de Teste de C Unit no sourceforge.+] |
| |=== |
| |
| |
| Consulte link:../../../community/releases/80/install.html[+Instruções de Instalação do NetBeans IDE+] e link:../../../community/releases/80/cpp-setup-instructions.html[+Configurando o NetBeans IDE para C/C++/Fortran+] |
| para obter informações sobre o download e a instalação do software NetBeans exigido. |
| |
| |
| == Introdução |
| |
| O NetBeans IDE com o plug-in C/C++/Fortran suporta os testes da unidade nos projetos C/C++. Você pode executar o IDE para criar, executar, depurar e exibir resultados em seus testes C e C++. Este artigo mostra como usar testes da unidade no IDE com seus projetos C/C++. |
| |
| Um projeto gerenciado é criado com uma pasta lógica chamada Arquivos de Teste, na qual você pode gerenciar testes da unidade para o projeto. Você pode criar testes diretamente nesta pasta Arquivos de Teste ou organizá-los em subpastas lógicas. Um nó de teste na pasta Arquivos de Teste é uma pasta especial com ações relacionadas ao teste. Quando um teste for criado, ele excluirá o arquivo principal do projeto e usará todas as outras definições do projeto. |
| |
| O IDE suporta só CUnit, CppUnit e seu próprio formato de saída "simples", o que significa que seus testes devem produzir a saída de um desses tipos de testes. O IDE fornece modelos para testes de unidade: |
| |
| * Teste simples C |
| * Teste simples C++ |
| * Teste CUnit |
| * Teste CppUnit |
| * Executor de teste de CppUnit |
| |
| Este tutorial usa o framework de teste CUnit e os Testes Simples de NetBeans C no Ubuntu Linux, mas as técnicas demonstradas também podem ajudar você com outros tipos de testes em outras plataformas. O tutorial não explica os frameworks de teste CUnit ou CppUnit. Você precisa consultar a documentação desses frameworks para obter informações sobre como usá-los. |
| |
| |
| == Instalar o Framework de Teste CUnit |
| |
| Para seguir este tutorial, primeiro você deve instalar CUnit em seu sistema. Consulte mais informações sobre o framework de CUnit em link:http://sourceforge.net/projects/cunit/[+Projeto de Framework de Teste de C Unit no sourceforge.+] |
| |
| A documentação do CUnit está incluída no download de CUnit, ou você pode exibi-la em link:http://cunit.sourceforge.net/doc/index.html[+http://cunit.sourceforge.net/doc/index.html+]. |
| |
| Consulte a seção apropriada para obter instruções de instalação para sua plataforma: |
| |
| * <<linux,Como Instalar CUnit no Linux ou no Mac OS>> |
| * <<solaris,Como Instalar CUnit no Oracle Solaris 11>> |
| * <<mingw,Como Instalar CUnit no Windows e no MinGW>> |
| * <<cygwin,Como Instalar CUnit no Windows e no Cygwin>> |
| |
| |
| === Como Instalar CUnit no Linux ou no Mac OS |
| |
| Em sistema Linux, você deve estar apto a instalar os pacotes libcunitl, libcunitl-doc e libcunitl-dev de seu repositório de pacote. |
| |
| No Mac OS ou no Linux, se os pacotes libcunitl* não estiverem disponíveis, é possível fazer download da origem de CUnit e criá-la, conforme descrito aqui. |
| |
| As instruções abaixo consideram que você fez download do arquivo CUnit-2.1-2-src.tar.bz2 no diretório /tmp. Se seu arquivo de download tiver um nome diferente, certifique-se de especificar seu arquivo de download de CUnit e o diretório real no qual você o salvou. |
| |
| 1. Faça download da origem CUnit-2.1-2-src.tar.bz2 da link:http://sourceforge.net/projects/cunit/files[+página de arquivos de CUnit+] e salve no diretório temporário, com /tmp, por exemplo. |
| 2. Em uma janela do terminal, descompacte o arquivo ``CUnit-2.1-2-src.tar.bz2`` como segue: |
| |
| [source,shell] |
| ---- |
| |
| $ cd /tmp |
| $ bunzip2 CUnit-2.1-2-src.tar.bz2 |
| $ tar -xvf CUnit-2.1-2-src.tar |
| ---- |
| |
| [start=3] |
| . Configure, crie e instale CUinit de /tmp, como segue: |
| |
| [source,shell] |
| ---- |
| |
| $ cd CUnit-2.1-2 |
| $ ./configure --prefix=/usr |
| $ make |
| $ sudo make install |
| ---- |
| |
| Quando 'make install' termina, o framework de teste CUnit está pronto para uso no IDE e você pode continuar a <<project,Criar o Projeto para o Tutorial>>. |
| |
| |
| [[solaris]] |
| === Como Instalar CUnit no Oracle Solaris 11 |
| |
| Você deve criar CUnit com o link:http://en.wikipedia.org/wiki/GNU_build_system[+sistema de build de GNU+] antes de usar os testes de CUnit. Nos sistemas Oracle Solaris 11, o sistema de build de GNU geralmente não é instalado por default. Você pode obter os componentes do sistema build de GNU do repositório de pacotes do Oracle Solaris 11 com os seguintes comandos: |
| |
| |
| [source,java] |
| ---- |
| |
| pkg install pkg://solaris/developer/build/gnu-make |
| pkg install pkg://solaris/developer/build/make |
| pkg install pkg://solaris/developer/gcc-45 |
| pkg install pkg://solaris/system/header |
| pkg install pkg://solaris/developer/build/autoconf |
| pkg install pkg://solaris/developer/build/automake-110 |
| ---- |
| |
| As instruções abaixo consideram que você fez download do arquivo CUnit-2.1-2-src.tar.bz2 no diretório /tmp. Se seu arquivo de download tiver um nome diferente, certifique-se de especificar seu arquivo de download de CUnit e o diretório real no qual você o salvou. |
| |
| 1. Faça download da origem CUnit-2.1-2-src.tar.bz2 da link:http://sourceforge.net/projects/cunit/files[+página de arquivos de CUnit+] e salve no diretório temporário, com /tmp, por exemplo. |
| 2. Em uma janela do terminal, descompacte o arquivo ``CUnit-2.1-2-src.tar.bz2`` como segue: |
| |
| [source,shell] |
| ---- |
| |
| $ cd /tmp |
| $ bunzip2 CUnit-2.1-2-src.tar.bz2 |
| $ tar -xvf CUnit-2.1-2-src.tar |
| ---- |
| |
| [start=3] |
| . Configure, crie e instale CUinit de /tmp, como segue: |
| |
| [source,shell] |
| ---- |
| |
| $ cd CUnit-2.1-2 |
| $ ./configure --prefix=/usr |
| $ make |
| $ make install |
| ---- |
| |
| Quando 'make install' termina, o framework de teste CUnit está pronto para uso no IDE e você pode continuar a <<project,Criar o Projeto para o Tutorial>>. |
| |
| |
| === Como Instalar CUnit no Windows e no MinGW |
| |
| Estas instruções consideram que você fez download do arquivo CUnit-2.1-2-src.tar.bz2 para o diretório C:/distr. Se seu arquivo de download tiver um nome diferente, certifique-se de especificar seu arquivo de download de CUnit e o diretório real no qual você o salvou. |
| |
| 1. Faça download da origem CUnit-2.1-2-src.tar.bz2 da link:http://sourceforge.net/projects/cunit/files[+página de arquivos de CUnit+] e salve no diretório temporário, como o C:/distr, por exemplo. |
| 2. Inicie a aplicação MinGW shell no Windows, escolhendo Iniciar > Todos os Programas > MinGW > MinGW Shell. |
| 3. Em uma janela do MinGW Shell, descompacte o arquivo ``CUnit-2.1-2-src.tar.bz2`` como segue: |
| |
| [source,shell] |
| ---- |
| |
| $ cd c:/distr |
| $ bunzip2.exe CUnit-2.1-2-src.tar.bz2 |
| $ tar xvf CUnit-2.1-2-src.tar |
| $ cd ./CUnit-2.1-2 |
| ---- |
| |
| [start=4] |
| . Localize o caminho do Unix para MinGW usando o comando mount. |
| |
| [source,shell] |
| ---- |
| |
| $ mount |
| ---- |
| Você verá uma saída semelhante à seguinte: |
| |
| [source,java] |
| ---- |
| |
| C:\Users\username\AppData\Local\Temp on /tmp type user (binmode,noumount) |
| C:\MinGW\msys\1.0 on /usr type user (binmode,noumount) |
| C:\MinGW\msys\1.0 on / type user (binmode,noumount) |
| *C:\MinGW on /mingw type user (binmode)* |
| ---- |
| A última linha em negrito acima mostra que o caminho UNIX é /mingw. Seu sistema pode reportar algo diferente, então anote porque talvez você precise especificar o caminho no próximo comando. |
| |
| [start=5] |
| . Configure o Makefile com o seguinte comando. |
| Se seu MinGW não estiver em /mingw, certifique-se de especificar a localização de Unix apropriada de seu MinGW com a opção --prefix=. |
| |
| [source,shell] |
| ---- |
| |
| $ ./configure --prefix=/mingw |
| _(lots of output about checking and configuring) |
| ..._ |
| config.status: executing depfiles commands |
| config.status: executing libtool commands |
| |
| ---- |
| |
| [start=6] |
| . Crie a biblioteca para CUnit: |
| |
| [source,shell] |
| ---- |
| |
| $ make |
| make all-recursive |
| make[1]: Entering directory 'c/distr/CUnit-2.1-2' |
| Making all in CUnit |
| ... |
| _(lots of other output)_ |
| make[1]: Leaving directory 'c/distr/CUnit-2.1-2' |
| $ |
| ---- |
| |
| [start=7] |
| . Instale a biblioteca CUnit em C:/MinGW/include/CUnit, C:/MinGW/share/CUnit e C:/MinGW/doc/CUnit executando make install: |
| |
| [source,shell] |
| ---- |
| |
| $ make install |
| Making install in CUnit |
| make[1]: Entering directory 'c/distr/CUnit-2.1-2/CUnit' |
| Making install in Sources |
| make[1]: Entering directory 'c/distr/CUnit-2.1-2/Cunit/Sources' |
| ... |
| _(lots of other output)_ |
| make[1]: Leaving directory 'c/distr/CUnit-2.1-2' |
| $ |
| ---- |
| |
| [start=8] |
| . Se usar a atualização 21, 25 ou 40 de Java execute a seguinte solução em decorrência do link:https://netbeans.org/bugzilla/show_bug.cgi?id=236867[+problema 236867+] para obter CUnit e este tuturial funcionar. |
| |
| 1. Vá para Ferramentas > Opções > C/C++ > Ferramentas de Construção e selecione o conjunto de ferramentas MinGW. |
| 2. Altere a entrada do Comando Make para make.exe sem um caminho completo. |
| 3. Saia do IDE. |
| 4. No Windows 7 e superior, digite *var* na caixa de pesquisa do menu Iniciar para localizar rapidamente um link para Editar as variáveis do ambiente do sistema. |
| 5. Selecione a guia Avançado e clique em Variáveis de Ambiente. |
| 6. No painel Variáveis do Sistema da caixa de diálogo Variáveis do Ambiente, clique em Novo. |
| 7. Defina o Nome da Variável para MAKE e o Valor da Variável para make.exe. |
| 8. Clique em OK em cada caixa de diálogo para salvar a alteração. |
| 9. Inicie o IDE e continue na próxima seção. |
| |
| Quando 'make install' termina, seu CUnit está pronto para uso no IDE e você pode continuar a <<project,Criar o Projeto para o Tutorial>>. |
| |
| |
| === Como Instalar CUnit no Windows e no Cygwin |
| |
| No Cygwin você pode instalar o CUnit usando o instalador Cygwin padrão, setup-x86.exe ou setup-x86_64.exe, disponível em http://cygwin.com/install.html. O pacote CUnit está localizado na categoria "Libs" e você pode instalá-lo da mesma forma que instala os outros pacotes. |
| |
| Certifique-se de usar a versão correta. Use Cygwin e CUnit de 64 bits se estiver executando o NetBeans IDE de 64 bits. |
| |
| Se você ainda não instalou o Cygwin, consulte as informações gerais de instalação dele em link:../../../community/releases/80/cpp-setup-instructions.html#cygwin[+Configurando o NetBeans IDE 7.4 para C/C++/Fortran+]. Você pode instalar CUnit, selecionando-o na categoria Libs no programa de instalação. |
| |
| |
| == Criar o Projeto para o Tutorial |
| |
| Para explorar as funcionalidades de teste da unidade, primeiro você deve criar uma nova aplicação C: |
| |
| 1. Escolha Arquivo > Novo Projeto. |
| 2. No assistente do projeto, clique em C/C++ e, em seguida, selecione a Aplicação C/C++. |
| 3. Na caixa de diálogo Nova Aplicação C/C++, selecione Criar Arquivo Principal e selecione a linguagem C. Aceite os defaults para todas as outras opções. |
| image::images/c-unit-new-project.png[] |
| |
| [start=4] |
| . Clique em Finalizar e o projeto Cpp_Application__x_ será criado. |
| |
| [start=5] |
| . Na janela Projetos, abra a pasta Arquivos de Origem e clique duas vezes no arquivo `main.c` para abri-lo no editor. O conteúdo do arquivo é semelhante ao mostrado aqui: |
| image::images/c-unit-mainc-initial.png[] |
| |
| [start=6] |
| . Para fornecer algo para o programa fazer, substitua o código no arquivo `main.c` pelo seguinte código para criar uma calculadora fatorial simples: |
| |
| [source,c] |
| ---- |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| long factorial(int arg) { |
| long result = 1; |
| int i; |
| for (i = 2; i <= arg; ++i) { |
| result *= i; |
| } |
| return result; |
| } |
| |
| int main(int argc, char** argv) { |
| printf("Type an integer and press Enter to calculate the integer's factorial: \n"); |
| int arg; |
| fflush(stdout); |
| scanf("%d", &arg); |
| |
| printf("factorial(%d) = %ld\n", arg, factorial(arg)); |
| |
| return (EXIT_SUCCESS); |
| } |
| |
| ---- |
| |
| O arquivo deve parecer com o seguinte após a edição: |
| |
| image::images/c-unit-mainc-edited.png[] |
| |
| [start=7] |
| . Salve o arquivo pressionando Ctrl+S. |
| |
| [start=8] |
| . Construa e execute o projeto para certificar-se de que ele funciona, clicando no botão Executar na barra de ferramentas IDE. |
| A saída deve ser semelhante ao seguinte, se você inserir 8 como inteiro: |
| image::images/c-unit-output-factorial.png[] |
| |
| Pode ser necessário pressionar Enter duas vezes em algumas plataformas. |
| |
| |
| == Adicionar Testes de CUnit ao Projeto Gerenciado do NetBeans |
| |
| Quando estiver desenvolvendo uma aplicação, é conveniente adicionar unidades de teste como parte de seu processo de desenvolvimento. |
| |
| Cada teste deve conter uma função `principal` e gerar um executável. |
| |
| 1. Na janela Projetos, clique com o botão direito do mouse no arquivo de origem `main.c` e selecione Criar Teste > Novo Teste CUnit. |
| image::images/c-unit-create-test.png[] |
| |
| Um assistente é aberto para ajudá-lo a criar o teste. |
| |
| |
| [start=2] |
| . Na janela Selecionar Elementos do assistente, clique na caixa de seleção da função `principal`. Isso faz com que todas as funções dentro da `principal` também sejam selecionadas. Neste programa, há só uma outra função, `factorial()`. |
| |
| [start=3] |
| . Clique em Próximo. |
| |
| [start=4] |
| . Mantenha o nome default Novo Teste CUnit e clique em Finalizar. |
| |
| O nó Novo Teste CUnit é exibido na pasta Arquivos de Teste. |
| |
| A pasta Novo Teste CUnit contém os arquivos do modelo para o teste. Você pode adicionar novos arquivos à pasta da mesma forma que você adiciona arquivos em um projeto, clicando com o botão direito do mouse na pasta. |
| |
| [start=5] |
| . Expanda a pasta Novo Teste CUnit e veja se ela contém um arquivo `newcunittest.c` que deve ser aberto no editor de origem. |
| |
| [start=6] |
| . No arquivo `newcunittest.c`, observe a instrução `#include "CUnit/Basic.h"` para acessar a biblioteca CUnit. O arquivo `newcunittest.c` contém uma função de teste gerada automaticamente, `testFactorial`, para a função `factorial()` de `main.c`. |
| |
| image::images/c-unit-includes.png[] |
| |
| Se o IDE não encontrou o arquivo `CUnit/Basic.h`, você pode editar o caminho de inclusão para apontar para o local correto. Por exemplo, se você instalou CUnit no Windows para `C:\Tools\CUnit-2.1-2` você edita o caminho para: |
| |
| `#include <C:\Tools\CUnit-2.1-2\CUnit\Headers\Basic.h>` |
| |
| O teste gerado é um stub que você deve editar para criar testes úteis, mas o teste gerado pode ser executado com sucesso, mesmo sem edição. |
| |
| |
| == Executar o Teste de C Unit |
| |
| O IDE oferece algumas forma de executar testes. Você pode clicar com o botão direito do mouse no nó do projeto ou na pasta Arquivos de Teste, ou em uma subpasta de teste e selecionar Teste. Você também pode usar a barra de menus e selecionar Executar > Testar Projeto ou pressionar Alt+F6. |
| |
| 1. Execute o teste clicando com o botão direito do mouse na pasta Teste CUnit e selecionando Teste. |
| |
| O IDE abre uma nova janela Resultados de Teste e você deverá ver uma saída semelhante à seguinte, que mostrará se o teste falhar. |
| |
| Caso não veja a janela Resultados do Teste, abra-a escolhendo Janela > Ferramentas IDE > Resultados de Teste, ou pressionando Alt+Shift+R. |
| |
| image::images/c-unit-run-test-orig.png[] |
| |
| [start=2] |
| . Observe que a janela Resultados do Teste é dividida em dois painéis. |
| O painel direito exibe a saída da console dos testes. O painel esquerdo exibe um resumo de testes com falha e aprovados e a descrição de testes com falha. |
| |
| [start=3] |
| . Na janela Resultados do Teste, clique duas vezes no nó `testFactorial causou um ERRO` para ir direto para a função `testFactorial` no editor de origem. |
| Se observar a função você verificará que ela não testa nada, mas simplesmente afirma que o teste da unidade falhou, definindo CU_ASSERT(0). A condição é avaliada como 0 que é equivalente a FALSO, dessa forma, o framework CUnit interpreta isso como uma falha de teste. |
| |
| [start=4] |
| . Altere a linha CU_ASSERT(0) para CU_ASSERT(1) e salve o arquivo (Ctrl+S). |
| |
| [start=5] |
| . Execute o teste novamente clicando com o botão direito na pasta Novo Teste CUnit e selecionando Testar. |
| A janela Resultados do Teste deve indicar que o teste foi aprovado. |
| image::images/c-unit-run-test-pass.png[] |
| |
| |
| == Adicionar Outro Teste CUnit |
| |
| 1. Crie um modelo de teste CUnit genérico clicando com o botão direito na pasta Arquivos de Teste e selecionando Novo Teste CUnit. |
| image::images/c-unit-new-cunit-test.png[] |
| |
| [start=2] |
| . Chame o teste Meu Teste CUnit e o nome do arquivo de teste `mycunittest` e clique em Finalizar. |
| image::images/c-unit-create-mycunittest.png[] |
| |
| [start=3] |
| . Uma nova pasta de teste chamada Meu Teste CUnit foi criada e contém um arquivo `mycunittest.c` que é aberto no editor. |
| |
| [start=4] |
| . Examine o arquivo de teste `mycunittest.c` e veja se ele contém dois testes. O teste1 passará porque foi avaliado como VERDADEIRO, e o teste2 falhará porque foi avaliado como FALSO, pois 2*2 não é igual a 5. |
| |
| [source,java] |
| ---- |
| |
| void test1() |
| { |
| CU_ASSERT(2*2 == 4); |
| } |
| void test2() |
| { |
| CU_ASSERT(2*2 == 5); |
| } |
| ---- |
| |
| [start=5] |
| . Execute o teste como antes e você deverá ver: |
| image::images/c-unit-run-mytest1.png[] |
| |
| [start=6] |
| . Execute todos os testes do menu principal IDE selecionando Executar > Testar Projeto (Cpp_Application__x_) e veja quais conjuntos de testes foram executados e exiba o êxito e a falha na janela Resultados do Teste. |
| |
| [start=7] |
| . Passe o mouse sobre o teste com falha para ver mais informações sobre a falha. |
| image::images/c-unit-test-fail-annotation.png[] |
| |
| [start=8] |
| . Clique nos botões na margem esquerda da janela Resultados do Teste para mostrar e ocultar os testes que passaram ou falharam. |
| |
| |
| == Depurar Meu Teste CUnit |
| |
| Você pode depurar os testes usando as mesmas técnicas que usa para depurar seus arquivos de origem do projeto, conforme descrito no link:https://netbeans.org/kb/docs/cnd/debugging.html[+Tutorial Depurando Projetos C/C+++]. |
| |
| 1. Na janela Projetos, clique com o botão direito na pasta Meu Teste CUnit e selecione Teste Step Into. |
| |
| Também é possível executar o depurador clicando com o botão direito no teste na janela Resultados do Teste e selecionando Depurar. |
| |
| |
| A barra de ferramentas do depurador será exibida. |
| |
| [start=2] |
| . Clique no botão Step Into para executar a instrução de um programa cada vez que clicar no botão |
| image::images/c-unit-debug-icons.png[] |
| |
| [start=3] |
| . Abra a janela Pilha de Chamada selecionando Janela > Depurando > Pilha de Chamada, assim você pode verificar as chamadas de função, conforme percorre pelo teste. |
| |
| |
| == Adicionar um Teste Simples |
| |
| O teste simples C usa o próprio framework de teste simples do IDE. Você não precisa fazer download de nenhum framework de teste para usar os testes simples. |
| |
| 1. Na janela Projetos, clique com o botão direito do mouse no arquivo de origem ``main.c`` e selecione Criar Teste > Novo Teste Simples C. |
| image::images/c-unit-mainc-new-simple-test.png[] |
| |
| [start=2] |
| . Na janela Selecionar Elementos do assistente, clique na caixa de seleção da função ``main`` , em seguida, clique em Próximo. |
| image::images/c-unit-mainc-new-simple-test-select.png[] |
| |
| [start=3] |
| . Na janela Nome e Local, mantenha o nome default Novo Teste Simples C e clique em Finalizar. |
| |
| O nó Novo Teste Simples C é exibido na pasta Testar Arquivos. |
| |
| |
| [start=4] |
| . Expanda a pasta Novo Teste Simples C e veja se ela contém um arquivo `newsimpletest.c`. Este arquivo deve ser aberto no editor de código-fonte. |
| image::images/c-unit-mainc-new-simple-test-folder.png[] |
| |
| [start=5] |
| . Observe que o arquivo `newsimpletest.c` contém uma função de teste gerada automaticamente, `testFactorial`, para a função `factorial()` de `main.c`, como no teste CUnit. |
| image::images/c-unit-mainc-new-simple-test-code.png[] |
| |
| A instrução ``if`` deve testar uma condição que, se verdadeira, indica que o teste falhou. O token ``%%TEST_FAILED%%`` aciona a exibição do indicador gráfico de falhas de teste na janela Resultados do Teste. A instrução ``if`` no teste gerado defina a condição como verdadeira, definindo-a como 1, dessa forma o teste sempre falha quando você executá-lo sem modificação. |
| |
| Os outros tokens na função ``main`` , como ``%%TEST_STARTED%%`` e ``%%TEST_FINISHED%%`` são para ajudar a ler a saída da linha de comandos ao executar os testes. |
| |
| A opção ``time=0`` é usada para adicionar a medição de tempo ao teste. |
| |
| A opção ``message`` permite que você imprima um teste sobre a falha no teste. |
| |
| |
| [start=6] |
| . Execute o teste para ver se ele gera uma falha mostrada na janela Resultados do Teste. |
| |
| Em seguida, você edita o arquivo de teste para ver os testes aprovados. |
| |
| |
| == Editar o Teste Simples C |
| |
| 1. Copie e cole uma nova função abaixo da função `testFactorial`. |
| A nova função é: |
| |
| [source,java] |
| ---- |
| |
| void testNew() { |
| int arg = 8; |
| long result = factorial(arg); |
| if(result != 40320) { |
| printf("%%TEST_FAILED%% time=0 testname=testNew (newsimpletest) message=Error calculating %d factorial.\n", arg); |
| } |
| } |
| ---- |
| |
| A função `main` também deve ser modificada para chamar a nova função de teste. |
| |
| |
| [start=2] |
| . Na função `main`, copie as linhas: |
| |
| [source,java] |
| ---- |
| |
| printf("%%TEST_STARTED%% testFactorial (newsimpletest)\n"); |
| testFactorial(); |
| printf("%%TEST_FINISHED%% time=0 testFactorial (newsimpletest)\n"); |
| |
| ---- |
| |
| [start=3] |
| . Cole as linhas logo abaixo das linhas copiadas e altere o nome `testFactorial` para `testNew` nas linhas coladas. Há três ocorrências que precisam ser alteradas. |
| O arquivo concluído `newsimpletest.c` deve parecer com o seguinte: |
| |
| [source,c] |
| ---- |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| |
| /* |
| * Simple C Test Suite |
| */ |
| |
| long factorial(int arg); |
| |
| void testFactorial() { |
| int arg; |
| long result = factorial(arg); |
| if(1 /*check result*/) { |
| printf("%%TEST_FAILED%% time=0 testname=testFactorial (newsimpletest) message=When value is 1 this statement is executed.\n"); |
| } |
| } |
| |
| |
| void testNew() { |
| int arg = 8; |
| long result = factorial(arg); |
| if(result != 40320) { |
| printf("%%TEST_FAILED%% time=0 testname=testNew (newsimpletest) message=Error calculating %d factorial.\n", arg); |
| } |
| } |
| |
| |
| int main(int argc, char** argv) { |
| printf("%%SUITE_STARTING%% newsimpletest\n"); |
| printf("%%SUITE_STARTED%%\n"); |
| |
| printf("%%TEST_STARTED%% testFactorial (newsimpletest)\n"); |
| testFactorial(); |
| printf("%%TEST_FINISHED%% time=0 testFactorial (newsimpletest)\n"); |
| |
| printf("%%TEST_STARTED%% testNew (newsimpletest)\n"); |
| testNew(); |
| printf("%%TEST_FINISHED%% time=0 testNew (newsimpletest)\n"); |
| |
| printf("%%SUITE_FINISHED%% time=0\n"); |
| |
| return (EXIT_SUCCESS); |
| } |
| |
| |
| ---- |
| |
| [start=4] |
| . Na janela Projetos, execute o teste clicando com o botão direito do mouse em Novo Teste Simples C e escolhendo Testar. |
| Os Resultados do Teste devem parecer com o seguinte: |
| image::images/c-unit-simpletest-results.png[] |
| |
| Se você não vir testNew aprovado, clique no botão de verificação verde na margem esquerda da janela Resultados do Teste para exibir os testes que foram aprovados. |
| |
| O token %%TEST_FAILED%% aciona a exibição de uma falha de teste na janela Resultados do Teste. A instrução if testa uma condição; caso não seja verdadeira, o teste falhará. |
| |
| O token %%SUITE_STARTING%% e outros semelhantes não serão mostrados na saída no IDE. São usadas para a saída da console. |
| |
| |
| == Executar Testes da Linha de Comandos |
| |
| Você pode criar testes na linha de comandos fora do IDE com `make build-tests` e executá-los com `make test`. Quando os projetos estão em ~/NetBeansProjects/Cpp_Application__x_ em um sistema Linux, os exemplos deste artigo devem ser criados e executados, conforme abaixo. |
| |
| 1. Abra uma janela terminal no IDE, selecionando Janela > Saída e clicando no botão Terminal na margem esquerda da janela de Saída. Será aberta uma janela terminal no diretório de trabalho do projeto atual. |
| 2. No terminal, digite os comandos mostrados em negrito: |
| |
| [source,java] |
| ---- |
| |
| *make test* |
| ---- |
| |
| A saída de criação e execução do teste deve parecer com a seguinte. Observe que a saída `make` foi deletada. |
| |
| |
| [source,java] |
| ---- |
| |
| "make" -f nbproject/Makefile-Debug.mk QMAKE= SUBPROJECTS= .build-conf |
| make[1]: Entering directory `/home/tester/NetBeansProjects/CppApplication_1' |
| "make" -f nbproject/Makefile-Debug.mk dist/Debug/GNU-Linux-x86/cppapplication_1 |
| make[2]: Entering directory `/home/tester/NetBeansProjects/CppApplication_1' |
| make[2]: `dist/Debug/GNU-Linux-x86/cppapplication_1' is up to date. |
| ... |
| |
| CUnit - A Unit testing framework for C - Version 2.1-2 |
| http://cunit.sourceforge.net/ |
| |
| |
| Suite: mycunittest |
| Test: test1 ... passed |
| Test: test2 ... FAILED |
| 1. tests/mycunittest.c:33 - 2*2 == 5 |
| Test: test3 ... passed |
| |
| --Run Summary: Type Total Ran Passed Failed |
| suites 1 1 n/a 0 |
| tests 3 3 2 1 |
| asserts 3 3 2 1 |
| %SUITE_STARTING% newsimpletest |
| %SUITE_STARTED% |
| %TEST_STARTED% testFactorial (newsimpletest) |
| %TEST_FAILED% time=0 testname=testFactorial (newsimpletest) message=error message sample |
| %TEST_FINISHED% time=0 testFactorial (newsimpletest) |
| %SUITE_FINISHED% time=0 |
| |
| |
| CUnit - A Unit testing framework for C - Version 2.1-2 |
| http://cunit.sourceforge.net/ |
| |
| |
| Suite: newcunittest |
| Test: testFactorial ... passed |
| |
| --Run Summary: Type Total Ran Passed Failed |
| suites 1 1 n/a 0 |
| tests 1 1 1 0 |
| asserts 1 1 1 0 |
| make[1]: Leaving directory `/home/tester/NetBeansProjects/CppApplication_1' |
| |
| |
| ---- |
| |
| |
| == Adicionando Suporte para Outros Frameworks de Teste |
| |
| Você pode adicionar suporte ao seu framework de tese C/C++ favorito, criando um módulo do NetBeans. Consulte o link:http://wiki.netbeans.org/CND69UnitTestsPluginTutotial[+Tutorial de Plug-in de Teste da Unidade C/C +++] no wiki do NetBeans. |
| |
| link:mailto:users@cnd.netbeans.org?subject=Feedback:%20Adding%20Unit%20Tests%20to%20a%20C/C++%20Project%20-%20NetBeans%20IDE%207.4%20Tutorial[+Enviar Feedback neste Tutorial+] |
| |
| |
