Adicionando Testes de Unidade a um Projeto C - Tutorial do NetBeans IDE

Conteúdo

O conteúdo desta página se aplica ao NetBeans IDE 6.8, 6.9, 7.4 e 8.0
Requisitos
Introdução
Instalar o Framework de Teste CUnit
Criar o Projeto para o Tutorial
Adicionar Testes de CUnit ao Projeto Gerenciado do NetBeans
Executar o Teste CUnit
Adicionar Outro Teste CUnit
Depurar um Teste
Adicionar um Teste Simples
Editar o Teste Simples
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) versão 7.4 ou 8.0 do NetBeans com o plug-in C/C++
Java Development Kit (JDK) Versão 7 ou 8
Framework de teste CUnit 2.1 Projetok de Framework de Teste de C Unit no sourceforge.

Consulte Instruções de Instalação do NetBeans IDE e 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 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 http://cunit.sourceforge.net/doc/index.html.

Consulte a seção apropriada para obter instruções de instalação para sua plataforma:

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 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:
    $ 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:
    $ 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 Criar o Projeto para o Tutorial.

Como Instalar CUnit no Oracle Solaris 11

Você deve criar CUnit com o 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:

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 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:
    $ 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:
    $ 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 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 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:
    $ 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.
    $ mount
    Você verá uma saída semelhante à seguinte:
    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=.
    $ ./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:
    $ 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:
    $ 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 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 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 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.
    Caixa de diálogo Tela do Novo Projeto
  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:
    Tela do arquivo main.c antes da edição
  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:
    #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:

    Tela do arquivo main.c após a edição
  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:
    Tela da saída do programa fatorial

    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.
    Tela de criação de novo teste

    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.
A tela de newcunittest.c inclui

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.

    Tela de execução inicial de teste
  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.
    Tela de execução de teste após a alteração de CU_ASSERT

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.
    Tela de adição de novo teste cunit para Arquivos de Teste
  2. Chame o teste Meu Teste CUnit e o nome do arquivo de teste mycunittest e clique em Finalizar.
    Tela do assistente de Criação de Teste
  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.
    void test1()
    {
    CU_ASSERT(2*2 == 4);
    }
    void test2()
    {
    CU_ASSERT(2*2 == 5);
    }    
  5. Execute o teste como antes e você deverá ver:
    Tela de aprovação e falha de testes
  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.
    Tela de anotação para teste com falha
  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 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
    Tela do ícone Depurar step into
  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.
    Tela de criação do Novo Teste Simples
  2. Na janela Selecionar Elementos do assistente, clique na caixa de seleção da função main, em seguida, clique em Próximo.
    Tela da janela Selecionar Elementos do assistente de teste
  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.
    Tela da pasta Novo teste Simples C
  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.
    Tela do código do Novo teste Simples C

    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 é:
    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:
    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:
    #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:
    Tela dos resultados do teste simples

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

    "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 Tutorial de Plug-in de Teste da Unidade C/C ++ no wiki do NetBeans.


get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo