// 
//     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]


image::images/netbeans-stamp-80-74.png[title="O conteúdo desta página se aplica ao NetBeans IDE 7.4 e 8.0"]

|===
|-  |<<requirements,Requisitos>> 

|-  |<<intro,Introdução>> 

|-  |<<cunit,Instalar o Framework de Teste CUnit>> 

|-  |<<project,Criar o Projeto para o Tutorial>> 

|-  |<<addtest,Adicionar Testes de CUnit ao Projeto Gerenciado do NetBeans>> 

|-  |<<runtest,Executar o Teste CUnit>> 

|-  |<<addmore, Adicionar Outro Teste CUnit>> 

|-  |<<debug,Depurar um Teste>> 

|-  |<<addsimple,Adicionar um Teste Simples>> 

|-  |<<editsimple,Editar o Teste Simples>> 

|-  |<<commandline,Executar Testes da Linha de Comandos>> 
|===


== 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
----
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
----
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
----
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.
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

----
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'
$
----
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'
$
----
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[]
4. Clique em Finalizar e o projeto Cpp_Application__x_ será criado.
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[]
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", &amp;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[]
7. Salve o arquivo pressionando Ctrl+S.
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.

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()`.
3. Clique em Próximo.
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.
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.
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[]
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.
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.
4. Altere a linha CU_ASSERT(0) para CU_ASSERT(1) e salve o arquivo (Ctrl+S).
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[]
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[]
3. Uma nova pasta de teste chamada Meu Teste CUnit foi criada e contém um arquivo `mycunittest.c` que é aberto no editor.
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);
}    
----
5. Execute o teste como antes e você deverá ver:
image::images/c-unit-run-mytest1.png[]
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.
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[]
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.
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[]
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[]
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[]
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.

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[]
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.

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.

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");
    
----
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);
}


----
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+]