Cunit em c

O sistema CUNIT é usado para realizar o teste de unidade em C, que permite a administração e a execução dos testes. Ele abrange uma gama diversificada de afirmações para testar tipos de dados comumente usados ​​e utiliza uma arquitetura simples para criar estruturas de teste. O código de teste do usuário está vinculado ao CUNIT, que foi projetado como uma biblioteca estática. Podemos examinar o desempenho das tarefas e funções do programa C usando a estrutura de teste do CUNIT. Cada tarefa em particular do programa C tem diferentes circunstâncias de entrada e limitações de saída. Para usar o CUNIT para testar o programa C, devemos instalá -lo primeiro em nosso sistema. As etapas para a instalação do CUNIT estão descritas abaixo.

Como usar a estrutura do CUNIT no Ubuntu 22.04

Para utilizar a estrutura de teste do CUNIT em nosso sistema, precisamos seguir as etapas de instalação. Essas etapas se aplicam ao Ubuntu 22.04 Sistema. Antes da instalação, primeiro atualizamos nosso sistema. O sistema exigia privilégio de sudo para ser atualizado com o comando apt.

Para adquirir privilégios de sudo, o terminal pediu à autenticação do usuário do sudo. Em seguida, atualize os pacotes do sistema e suas dependências, como mostrado abaixo.

Agora, instalamos a estrutura do CUNIT usando o seguinte comando. Este comando pode instalar os pacotes libcunitl, libcunitl-dout e libcunitl-dev do repositório de pacotes.

Depois que o comando de instalação do CUNIT é executado, a senha do usuário é necessária. Os pacotes essenciais do CUNIT foram instalados em nosso Ubuntu 22.04.

Exemplo 1

Concluímos a etapa de instalação da estrutura do CUNIT na seção anterior. Agora, testamos o método de soma e diferença para ver os resultados esperados no exemplo a seguir usando a estrutura de teste do CUNIT.

#incluir
#incluir
#incluir
#incluir
#include "Cunit/Basic.h "
int init_suite (void) return 0;
int clean_suite (void) return 0;
int mysum (int a1, int b1)

int res1;
res1 = a1+b1;
retornar res1;

int mydiff (int a2, int b2)

int res2;
res2 = a2-b2;
retornar res2;

void test_mysum (void)

Cu_assert (4 == mysum (2,2));
Cu_assert (8 == mysum (5,3));
Cu_assert (2 == mysum (-2,4));
Cu_assert (7 == mysum (0,7));

void test_mydiff (void)

Cu_assert (3 == mydiff (5,2));
Cu_assert (-4 == mydiff (4,8));
Cu_assert (-7 == mydiff (-3,4));
Cu_assert (-9 == mydiff (0,9));

int main (vazio)

Cu_psuite psuite1, psuite2 = null;
if (cue_success != Cu_initialize_registry ())
return cu_get_error ();
psuite1 = Cu_add_suite ("Suite de teste1", init_suite, limpo_suite);
if (null == psuite1)
Cu_cleanup_registry ();
return cu_get_error ();

if ((null == Cu_add_test (psuite1, "\ n \ nsum function Testing \ n \ n", test_mysum))))))

Cu_cleanup_registry ();
return cu_get_error ();

if ((null == Cu_add_test (psuite1, "\ n \ ndifference function Testing \ n \ n", test_mydiff)))))

Cu_cleanup_registry ();
return cu_get_error ();

Cu_basic_run_tests ();
Cu_cleanup_registry ();
return cu_get_error ();

Primeiro, para gerar a estrutura do CUNIT, inserimos a biblioteca do CUNIT “CUNIT/BASIC.H ”com a palavra -chave incluída. Esta biblioteca C é para estruturas de teste de unidade e oferece uma interface de saída de console simples. Em seguida, adicionamos duas funções, "init_suite" para a inicialização da função da suíte e "limpo_suite" para a limpeza da função da suíte, para o nosso programa para testar.

Em seguida, construímos métodos, "Mysum" e "MyDiff", para ser testado pelo Cunit. Chamamos o construtor para essas funções, que contém as variáveis ​​nas quais as operações de soma e diferença foram executadas. Em seguida, estabelecemos uma função como "test_mysum" para testar. Dentro da função, empregamos o método “Cu_assert”, onde as expressões inits para a soma são atribuídas. O mesmo que "test_mysum", construímos a função test_mydiff para testar a expressão para diferentes operações usando o método "Cu_assert".

Em seguida, temos o código do Cunit Runner dentro do método principal. Aqui, criamos duas suítes, “Psuite1” e “Psuite2”, do método “Cu_psuite” e atribuímos a essas suítes um valor nulo. Criamos essas suítes para executar o teste do CUNIT que deve ser registrado no registro de teste. Antes de adicionar as suítes ao “test_registry”, criamos o registro e inicializamos com a “condição se”. Usamos o método “Cu_initialze_registry ()” para criar o registro para testar suítes.

Depois disso, adicionamos o psuite1 ao registro de teste, invocando o método "Cu_add_suite" do CUNIT. Depois disso, adicionamos nossos testes, "test_mysum" e "test_mydiff", aos suítes especificados, utilizando o método "Cu_add_test ()". No final, exibimos os resultados do teste do CUNIT, chamando o método “Cu_basic_run_tests ()” e limpamos o registro depois que os resultados foram exibidos com sucesso. O erro encontrado ao fazer os testes do CUNIT será lançado pela função "Cu_Get_error ()".

O arquivo de teste do CUNIT anterior é salvo como o MyTest.Arquivo C. Nós executamos este arquivo C com o comando gcc. Utilizamos o sinalizador -lcunit para execução do arquivo de teste do CUNIT. Com este comando, nosso código é compilado. Em seguida, executamos o arquivo mytest e mostrou os resultados esperados do teste do CUNIT, pois todos os testes foram passados ​​sem falha.

Exemplo 2

Temos outro exemplo em que testamos os dois métodos de manuseio de arquivos, "Fread" e "fprintf", pela abordagem da Cunit. Abrimos e fechamos o arquivo temporário usando as funções de teste do CUNIT. As operações de teste do CUNIT testam as funções da biblioteca escrevendo e lendo o arquivo temporário.

#incluir
#incluir
#incluir
#incluir
#include "Cunit/Basic.h "
arquivo estático* arquivo = null;
int init_suite1 (vazio)

if (null == (arquivo = fopen ("myfile.txt "," w+"))
retornar -1;

outro
retornar 0;


int clean_suite1 (vazio)

se (0 != fclose (arquivo))
retornar -1;

outro
arquivo = nulo;
retornar 0;


void test_fprintf (void)

int x1 = 10;
if (nulo != arquivo)
Cu_assert (2 == fprintf (arquivo, "q \ n"));
Cu_assert (7 == fprintf (arquivo, "x1 = %d", x1));


void test_fread (void)

buffer de char não assinado [20];
if (nulo != arquivo)
rebobinar (arquivo);
Cu_assert (9 == Fread (buffer, sizeof (char não assinado), 20, arquivo));
Cu_assert (0 == strncmp (buffer, "q \ nx1 = 10", 9));


int main ()

Cu_psuite psuite = null;
if (cue_success != Cu_initialize_registry ())
return cu_get_error ();
psuite = Cu_add_suite ("suite1", init_suite1, limpo_suite1);
if (null == psuite)
Cu_cleanup_registry ();
return cu_get_error ();

if ((null == Cu_add_test (Psuite, "Teste de função fprintf ()", test_fprintf)) ||
(Null == Cu_add_test (Psuite, "Teste de função fread ()", test_fread))))))

Cu_cleanup_registry ();
return cu_get_error ();

Cu_basic_set_mode (Cu_brm_verbose);
Cu_basic_run_tests ();
Cu_cleanup_registry ();
return cu_get_error ();

Dentro do arquivo de cabeçalho, definimos a biblioteca padrão do CUNIT “CUNIT.h/básico.h ". Em seguida, declaramos "arquivo" como um ponteiro para o arquivo usado pelos testes. Em seguida, construímos a função "init_suite1" que abre o arquivo temporário "MyFile.txt ”e retorna o valor zero no sucesso; Caso contrário, um valor diferente de zero será devolvido. Para fechar o arquivo, criamos a função de limpeza da suíte, que também retorna um valor diferente de zero na falha ao fechar o arquivo temporário. Caso contrário, ao fechar com sucesso o arquivo temporário, o valor zero é obtido. Em seguida, simplesmente implementamos uma função "test_fprintf", onde inserimos os dados no arquivo temporário "MyFile.TXT". Essas funções de teste também verificaram o número de bytes que tentamos escrever no arquivo.

Depois disso, criamos outra função para a função "test_fread" para testar o método Fread. Aqui, verificamos se os caracteres especificados estão presentes nos dados escritos anteriormente pela função "test_fprinf ()". Em seguida, temos a principal função em que os testes configurados e executados são tratados. Definimos o “psuite” na função principal e inicializamos o registro usando a função de teste “Cu_initialize_resgistry”. Também chamamos a função “Cu_add_suite” para adicionar a suíte ao registro e adicionamos os testes especificados às suítes com a ajuda da função “Cu_add_test”.

As interfaces básicas de teste do CUNIT são usadas no final para exibir os resultados do código. Observe que a função principal retorna um "CUE_SUCCESS" após a execução bem -sucedida e um código diferente "CUNIT_ERROR" após a execução malsucedida.

Executamos o código anterior para o teste CUNIT, que exibiu o resumo do programa e a mensagem de método dos testes bem -sucedida.

Conclusão

Cunit é uma estrutura principal que fornece várias interfaces de usuário. Ele nos permite gerenciar suítes de teste, casos de teste e registros de teste. Testar os programas e ver os resultados desses testes é facilitado pelas interfaces do usuário. Cobrimos a estrutura de teste do CUNIT em C com este artigo. Demonstramos a instalação e, em seguida, implementamos dois programas de execução no idioma C. Os programas anteriores testados deram resultados bem -sucedidos.