Cunit in c

Il sistema CUNIT viene utilizzato per eseguire i test unitari in C, che consente la somministrazione e l'esecuzione dei test. Copre una vasta gamma di affermazioni per i test dei tipi di dati comunemente usati e utilizza una semplice architettura per la creazione di strutture di test. Il codice di test dell'utente è collegato a CUNIT, progettato come una libreria statica. Potremmo esaminare le prestazioni delle attività e delle funzioni del programma C utilizzando il framework di test CUNIT. Ogni compito particolare del programma C ha diverse circostanze di input e limitazioni di output. Per utilizzare la CUNIT per testare il programma C, dovremmo installarlo prima nel nostro sistema. I passaggi per l'installazione di CUNIT sono descritti di seguito.

Come utilizzare il framework Cunit in Ubuntu 22.04

Per utilizzare il framework di test CUNIT nel nostro sistema, dobbiamo seguire le fasi di installazione. Questi passaggi si applicano a Ubuntu 22.04 Sistema. Prima dell'installazione, abbiamo prima aggiornato il nostro sistema. Il sistema richiedeva il privilegio di essere aggiornato con il comando APT.

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

Ora, abbiamo installato il framework CUNIT utilizzando il seguente comando. Questo comando può installare pacchetti LibCunitl, LibCunitl-Doc e LibCunitl-Dev dal repository dei pacchetti.

Una volta eseguito il comando di installazione CUNIT, è richiesta la password dell'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 Sommi e Differenza per vedere i risultati previsti nell'esempio seguente utilizzando il framework di test CUNIT.

#includere
#includere
#includere
#includere
#include "cunit/base.H"
int init_suite (void) return 0;
int clean_suite (void) return 0;
int mysum (int a1, int b1)

int Res1;
Res1 = A1+B1;
restituire res1;

int mydiff (int a2, int b2)

int res2;
Res2 = A2-B2;
restituire 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 (vuoto)

Cu_psuite psuite1, psuite2 = null;
if (cue_success != Cu_initialize_registry ())
return cu_get_error ();
psuite1 = cu_add_suite ("test suite1", init_suite, clean_suite);
if (null == psuite1)
Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite1 ", \ n \ nsum Testing della funzione \ n \ n", test_mysum)))

Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite1, "\ n \ ndifference Testing di funzione \ n \ n", test_mydiff)))

Cu_cleanup_registry ();
return cu_get_error ();

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

Innanzitutto, per generare la struttura CUNIT, abbiamo inserito la biblioteca CUNIT “CUNIT/BASIC.h "con la parola chiave inclusa. Questa libreria C è per i framework di test unitari e offre un'interfaccia di output di una semplice 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 per il test.

Successivamente, abbiamo costruito metodi, "Mysum" e "Mydiff", da testare 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" per testare. All'interno della funzione, abbiamo impiegato il metodo "Cu_assert", in cui sono assegnate le espressioni INIT per la somma. Come "test_mysum", abbiamo costruito la funzione test_mydiff per testare l'espressione per operazioni diverse usando il metodo "Cu_assert".

Quindi, abbiamo il codice Cunit Runner all'interno del metodo principale. Qui, abbiamo creato due suite, "psuite1" e "psuite2", dal metodo "cu_psuite" e assegnato a queste suite un valore nullo. 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 inizializzato con la "condizione if". Abbiamo usato il metodo "Cu_initialze_registry ()" per la creazione del registro per testare le suite.

Successivamente, abbiamo aggiunto il PSuite1 al registro dei 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 mentre si esegue i test CUNIT sarà lanciato dalla funzione "Cu_get_error ()".

Il precedente file di test cunit viene salvato come mytest.file 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, il nostro codice viene compilato. Quindi, abbiamo eseguito il file MyTest e ha mostrato i risultati previsti del test CUNIT poiché tutti i test sono stati superati senza alcun fallimento.

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 CUNIT testano le funzioni della libreria scrivendo e leggendo dal file temporaneo.

#includere
#includere
#includere
#includere
#include "cunit/base.H"
File statico* file = null;
int init_suite1 (void)

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

altro
restituzione 0;


int clean_suite1 (void)

Se (0 != fclose (file))
restituzione -1;

altro
file = null;
restituzione 0;


void test_fprintf (void)

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


void test_fread (void)

BUFFER CHAR non firmato [20];
if (null != file)
riavvolgimento (file);
Cu_assert (9 == Fread (buffer, sizeof (unsigned char), 20, file));
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, pulit_suite1);
if (null == psuite)
Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite, "fprintf () test di funzione", test_fprintf)) ||
(Null == Cu_add_test (psuite, "Fread () Test di funzione", 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 ();

All'interno del file di intestazione, abbiamo definito 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 al successo; Altrimenti, 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 al fallimento mentre si chiude il file temporaneo. Altrimenti, quando chiudono correttamente il file temporaneo, si ottiene un valore zero. Quindi, abbiamo semplicemente implementato una funzione "test_fprintf" in cui 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 e eseguiti. Abbiamo definito lo "psuite" nella funzione principale e inizializzato il registro usando la funzione di test "cu_initialize_resgistry". 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 base all'esecuzione riuscita e un codice "cunit_error" diverso su esecuzione senza successo.

Abbiamo eseguito il codice precedente per il test CUNIT, che ha visualizzato il riepilogo del programma e il messaggio del metodo dei test riusciti.

Conclusione

Cunit è un framework principale che fornisce varie interfacce utente. Ci consente di gestire le suite di prova, i casi di test e i registri di test. Testare i programmi e vedere i risultati di tali test è reso più semplice dalle interfacce utente. Abbiamo coperto il framework di test CUNIT in C con questo articolo. Abbiamo dimostrato l'installazione e quindi implementato due programmi in esecuzione in lingua C. I programmi precedenti testati hanno fornito risultati di successo.