Unità in C

Unita In C



Il sistema CUnit viene utilizzato per eseguire lo unit test in C, che consente l'amministrazione e l'esecuzione dei test. Copre una vasta gamma di asserzioni per testare i tipi di dati comunemente usati e utilizza un'architettura semplice per creare strutture di test. Il codice di test dell'utente è collegato a CUnit, che è progettata come una libreria statica. Possiamo esaminare le prestazioni dei compiti e delle funzioni del programma C utilizzando il framework di test CUnit. Ogni particolare attività del programma C ha diverse circostanze di input e limitazioni di output. Per utilizzare CUnit per testare il programma C, dobbiamo prima installarlo nel nostro sistema. I passaggi per l'installazione di CUnit sono descritti di seguito.

Come utilizzare CUnit Framework in Ubuntu 22.04

Per utilizzare il framework di test CUnit nel nostro sistema, dobbiamo seguire i passaggi di installazione. Questi passaggi si applicano al sistema Ubuntu 22.04. Prima dell'installazione, abbiamo prima aggiornato il nostro sistema. Il sistema richiedeva il privilegio sudo per essere aggiornato con il comando apt.








Per acquisire i privilegi sudo, il terminale ha chiesto l'autenticazione all'utente sudo. Quindi, aggiorna i pacchetti di sistema e le relative dipendenze, come mostrato di seguito.




Ora abbiamo installato il framework CUnit usando il comando seguente. Questo comando può installare i pacchetti libcunitl, libcunitl-doc e libcunitl-dev dal repository dei pacchetti.




Una volta eseguito il comando di installazione di CUnit, viene richiesta la password utente. I pacchetti essenziali CUnit sono stati installati nel nostro Ubuntu 22.04.





Esempio 1

Abbiamo completato la fase di installazione del framework CUnit nella sezione precedente. Ora, abbiamo testato il metodo di somma e differenza per vedere i risultati attesi nell'esempio seguente usando il framework di test CUnit.



#include
#include
#include
#include
#include 'CUnit/Basic.h'

init init_suite ( vuoto ) { Restituzione 0 ; }
int clean_suite ( vuoto ) { Restituzione 0 ; }

int MySum ( tu sei a1, tu sei b1 )

{
int res1;
ris1 =a1+b1;
Restituzione ris1;
}

int MyDiff ( int a2, int b2 )

{
int res2;
ris2 =a2-b2;
Restituzione ris2;
}

void test_MySum ( vuoto )
{
CON_ASSISTENZA ( 4 ==La mia somma ( Due , Due ) ) ;
CON_ASSISTENZA ( 8 ==La mia somma ( 5 , 3 ) ) ;
CON_ASSISTENZA ( Due ==La mia somma ( - Due , 4 ) ) ;
CON_ASSISTENZA ( 7 ==La mia somma ( 0 , 7 ) ) ;
}


void test_MyDiff ( vuoto )
{
CON_ASSISTENZA ( 3 ==MioDiff ( 5 , Due ) ) ;
CON_ASSISTENZA ( - 4 ==MioDiff ( 4 , 8 ) ) ;
CON_ASSISTENZA ( - 7 ==MioDiff ( - 3 , 4 ) ) ;
CON_ASSISTENZA ( - 9 ==MioDiff ( 0 , 9 ) ) ;
}


int principale ( vuoto )
{

CU_pSuite pSuite1,pSuite2 = NULL;

Se ( CUE_SUCCESS ! = CU_inizializza_registro ( ) )
Restituzione CU_get_error ( ) ;

pSuite1 = CU_add_suite ( 'Suite di prova1' , init_suite, clean_suite ) ;
Se ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
Restituzione CU_get_error ( ) ;
}

Se ( ( NULL == CU_add_test ( pSuite1, ' \n \n Funzione somma Test \n \n ' , test_MySum ) ) )
{
CU_cleanup_registry ( ) ;
Restituzione CU_get_error ( ) ;
}

Se ( ( NULL == CU_add_test ( pSuite1, ' \n \n Test di funzione differenziale \n \n ' , test_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
Restituzione CU_get_error ( ) ;
}

CU_basic_run_tests ( ) ;

CU_cleanup_registry ( ) ;
Restituzione CU_get_error ( ) ;
}







Innanzitutto, per generare la struttura CUnit, abbiamo inserito la libreria CUnit “CUnit/Basic.h” con la keyword inclusa. Questa libreria C è per framework di unit test e offre una semplice interfaccia di output della console. Quindi abbiamo aggiunto due funzioni, 'init_suite' per l'inizializzazione della funzione suite e 'clean_suite' per la pulizia della funzione suite, al nostro programma di test.

Successivamente, abbiamo costruito metodi, 'MySum' e 'MyDiff', che devono essere testati dalla CUnit. Abbiamo chiamato il costruttore per queste funzioni, che contiene le variabili su cui sono state eseguite operazioni di somma e differenza. Successivamente, abbiamo stabilito una funzione come 'test_MySum' da testare. All'interno della funzione abbiamo impiegato il metodo “CU_ASSERT”, dove vengono assegnate le espressioni init per la somma. Come per 'test_MySum', abbiamo costruito la funzione test_MyDiff per testare l'espressione per diverse operazioni usando il metodo 'CU_ASSERT'.

Quindi, abbiamo il codice corridore CUnit all'interno del metodo principale. Qui, abbiamo creato due suite, 'pSuite1' e 'pSuite2', dal metodo 'CU_pSuite' e assegnato a queste suite un valore NULL. Abbiamo creato queste suite per eseguire il test CUnit che dovrebbe essere registrato nel registro dei test. Prima di aggiungere le suite al “test_registry”, abbiamo creato il registro e lo abbiamo inizializzato con la condizione “if”. Abbiamo utilizzato il metodo 'CU_initialze_registry()' per creare il registro per le suite di test.

Successivamente, abbiamo aggiunto pSuite1 al registro di test invocando il metodo 'CU_add_suite' di CUnit. Successivamente, abbiamo aggiunto i nostri test, 'test_MySum' e 'test_MyDiff', alle suite specificate utilizzando il metodo 'CU_add_test()'. Alla fine, abbiamo visualizzato i risultati del test CUnit chiamando il metodo 'CU_basic_run_tests()' e pulito il registro una volta che i risultati sono stati visualizzati correttamente. L'errore riscontrato durante l'esecuzione dei test CUnit verrà generato dalla funzione 'CU_get_error()'.

Il file di test CUnit precedente viene salvato come file mytest.c. Abbiamo eseguito questo file C con il comando GCC. Abbiamo usato il flag -lcunit per l'esecuzione del file di test CUnit. Con questo comando viene compilato il nostro codice. Quindi, abbiamo eseguito il file mytest e ha mostrato i risultati attesi del test CUnit poiché tutti i test sono stati superati senza alcun errore.

Esempio 2

Abbiamo un altro esempio in cui abbiamo testato i due metodi di gestione dei file, 'fread' e 'fprintf', con l'approccio CUnit. Abbiamo aperto e chiuso il file temporaneo utilizzando le funzioni di test CUnit. Le operazioni di test di CUnit testano le funzioni della libreria scrivendo e leggendo dal file temporaneo.

#include
#include
#include
#include
#include 'CUnit/Basic.h'

FILE statico * file = NULLA;
int init_suite1 ( vuoto )
{
Se ( NULLO == ( file = aperto ( 'MyFile.txt' , 'w +' ) ) ) {
Restituzione -1 ;
}
altro {
Restituzione 0 ;
}
}

int clean_suite1 ( vuoto )
{
Se ( 0 ! = vicino ( file ) ) {
Restituzione -1 ;
}
altro {
file = NULLA;
Restituzione 0 ;
}
}


vuoto test_fprintf ( vuoto )
{
int x1 = 10 ;

Se ( NULLO ! = file ) {
CON_ASSISTENZA ( Due == fprintf ( file , 'Q \n ' ) ) ;
CON_ASSISTENZA ( 7 == fprintf ( file , 'x1 = %d' , x1 ) ) ;
}
}

vuoto test_fread ( vuoto )
{
buffer di caratteri senza segno [ venti ] ;

Se ( NULLO ! = file ) {
riavvolgere ( file ) ;
CON_ASSISTENZA ( 9 == spaventato ( buffer, sizeof ( carattere non firmato ) , venti , file ) ) ;
CON_ASSISTENZA ( 0 == strncmp ( respingente, 'Q \n x1 = 10' , 9 ) ) ;
}
}

int principale ( )
{
CU_pSuite pSuite = NULL;
Se ( CUE_SUCCESS ! = CU_inizializza_registro ( ) )
Restituzione CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Suite1' , init_suite1, clean_suite1 ) ;
Se ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
Restituzione CU_get_error ( ) ;
}
Se ( ( NULL == CU_add_test ( pSuite, 'Test della funzione fprintf()' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'test della funzione fread()' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
Restituzione CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
Restituzione CU_get_error ( ) ;
}







All'interno del file di intestazione è stata definita la libreria standard CUnit “CUnit.h/Basic.h”. Quindi, abbiamo dichiarato 'file' come puntatore al file utilizzato dai test. Successivamente, abbiamo costruito la funzione “init_suite1” che apre il file temporaneo “MyFile.txt” e restituisce il valore zero in caso di successo; in caso contrario, verrà restituito un valore diverso da zero. Per chiudere il file, abbiamo creato la funzione di pulizia della suite, che restituisce anche un valore diverso da zero in caso di errore durante la chiusura del file temporaneo. In caso contrario, chiudendo correttamente il file temporaneo, si ottiene un valore zero. Quindi, abbiamo semplicemente implementato una funzione “test_fprintf” dove abbiamo inserito i dati nel file temporaneo “MYfile.txt”. Queste funzioni di test hanno anche verificato il numero di byte che abbiamo tentato di scrivere nel file.

Successivamente, abbiamo creato un'altra funzione per la funzione 'test_fread' per testare il metodo fread. Qui abbiamo verificato che i caratteri specificati siano presenti nei dati precedentemente scritti dalla funzione “test_fprinf()”. Quindi, abbiamo la funzione principale in cui vengono gestiti i test impostati ed eseguiti. Abbiamo definito 'pSuite' nella funzione principale e inizializzato il registro utilizzando la funzione di test 'CU_initialize_registry'. Abbiamo anche chiamato la funzione 'CU_add_suite' per aggiungere la suite al registro e aggiunto i test specificati alle suite con l'aiuto della funzione 'CU_add_test'.

Le interfacce di test CUnit di base vengono utilizzate alla fine per visualizzare i risultati del codice. Si noti che la funzione principale restituisce un 'CUE_SUCCESS' in caso di esecuzione riuscita e un codice 'CUnit_error' diverso in caso di esecuzione non riuscita.

Abbiamo eseguito il codice precedente per il test CUnit, che mostrava il riepilogo del programma e il messaggio del metodo dei test riusciti.

Conclusione

CUnit è un framework di base che fornisce varie interfacce utente. Ci consente di gestire suite di test, casi di test e registri di test. Testare i programmi e vedere i risultati di tali test è facilitato dalle interfacce utente. Abbiamo trattato il framework di test CUnit in C con questo articolo. Abbiamo dimostrato l'installazione e quindi implementato due programmi in esecuzione in linguaggio C. I precedenti programmi testati hanno dato risultati positivi.