Cunit in c

Das Cunit -System wird verwendet, um die Unit -Tests in C durchzuführen, die die Verabreichung und Ausführung der Tests ermöglicht. Es deckt eine Vielzahl von Behauptungen für Tests häufig verwendete Datentypen ab und verwendet eine einfache Architektur zum Erstellen von Teststrukturen. Der Testcode des Benutzers ist mit Cunit verknüpft, das als statische Bibliothek konzipiert ist. Wir können die Leistung der Aufgaben und Funktionen des C -Programms unter Verwendung des Cunit -Test -Frameworks untersuchen. Jede bestimmte Aufgabe des C -Programms hat unterschiedliche Eingabeumstände und Ausgangsbeschränkungen. Um die Cunit zum Testen des C -Programms zu verwenden, sollten wir es zuerst in unserem System installieren. Die Schritte für die Installation von Cunit sind unten beschrieben.

So verwenden Sie das Cunit -Framework in Ubuntu 22.04

Um das Cunit -Test -Framework in unserem System zu verwenden, müssen wir die Installationsschritte befolgen. Diese Schritte gelten für die Ubuntu 22.04 System. Vor der Installation haben wir unser System zuerst aktualisiert. Das System erforderte sudo -Privileg, um mit dem APT -Befehl aktualisiert zu werden.

Um sudo -Privilegien zu erwerben, fragte das Terminal die Authentifizierung vom Sudo -Benutzer. Aktualisieren Sie dann die Systempakete und deren Abhängigkeiten, wie unten gezeigt.

Jetzt haben wir das Cunit -Framework mit dem folgenden Befehl installiert. Dieser Befehl kann die Pakete libcunitl, libcunitl-doc und libcunitl-dev aus dem Paket-Repository installieren.

Sobald der Befehl cunit installation ausgeführt wurde, ist das Benutzerkennwort erforderlich. Die Cunit Essential Pakete wurden in unserem Ubuntu 22 installiert.04.

Beispiel 1

Wir haben den Installationsschritt des Cunit -Frameworks im vorherigen Abschnitt abgeschlossen. Jetzt haben wir die Summe- und Differenzmethode getestet, um die erwarteten Ergebnisse im folgenden Beispiel mit dem Cunit -Test -Framework anzuzeigen.

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

int res1;
res1 = a1+b1;
Return Res1;

int mydiff (int a2, int b2)

int res2;
res2 = a2-b2;
Return 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 (void)

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

Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite1, "\ n \ nDifferenzfunktionstest \ n \ n", test_mydiff))))

Cu_cleanup_registry ();
return cu_get_error ();

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

Um die Cunit -Struktur zu erzeugen, haben wir die Cunit Library „Cunit/Basic“ eingefügt.H ”mit dem enthaltenen Schlüsselwort. Diese C -Bibliothek ist für Unit -Test -Frameworks gedacht und bietet eine einfache Konsolenausgangsschnittstelle. Dann haben wir zwei Funktionen hinzugefügt, "init_suite" für die Initialisierung der Suite -Funktion und "Clean_Suite" für die Bereinigung der Suite -Funktion zu unserem Testprogramm zum Testen.

Als nächst. Wir haben den Konstruktor für diese Funktionen bezeichnet, wodurch die Variablen, auf denen Summe und Differenzvorgänge durchgeführt wurden. Als nächstes haben wir eine Funktion als „test_mysum“ zum Testen erstellt. In der Funktion haben wir die Methode „Cu_assert“ verwendet, wobei die Initial -Ausdrücke für die Summe zugewiesen sind. Wie "test_mysum" haben wir die Funktion test_mydiff konstruiert, um den Ausdruck für verschiedene Operationen mit der Methode "Cu_assert" zu testen.

Dann haben wir den Cunit Runner Code in der Hauptmethode. Hier haben wir zwei Suiten "psuite1" und "psuite2" aus der Methode "Cu_psuite" erstellt und diese Suiten einen Nullwert zugewiesen. Wir haben diese Suiten erstellt, um den Cunit -Test auszuführen, der im Testregister registriert werden sollte. Bevor wir die Suiten zur "test_registry" hinzufügen, haben wir die Registrierung erstellt und sie mit dem "If -Zustand" initialisiert, das initialisiert wurde. Wir haben die Methode „Cu_initialze_registry ()“ zum Erstellen der Registrierung zum Testen von Suiten verwendet.

Danach haben wir das Testregistrierung das Psuite1 hinzuge. Danach haben wir unsere Tests "test_mysum" und "test_mydiff" zu den angegebenen Suiten hinzugefügt, indem wir die Methode "Cu_Add_test ()" verwenden. Am Ende haben wir die Ergebnisse des Cunit -Tests angezeigt, indem wir die Methode „cu_basic_run_tests ()“ aufgerufen und die Registrierung gereinigt haben, sobald die Ergebnisse erfolgreich angezeigt wurden. Der Fehler beim Durchführen der Cunit -Tests wird von der Funktion „Cu_get_error ()“ abgelegt.

Die vorherige Cunit -Testdatei wird als MyTest gespeichert.c Datei. Wir haben diese C -Datei mit dem GCC -Befehl ausgeführt. Wir haben das Flag -lcunit -Flag für die Ausführung von Cunit -Testdatei verwendet. Mit diesem Befehl wird unser Code zusammengestellt. Dann haben wir die MyTest -Datei ausgeführt, und sie zeigte die erwarteten Ergebnisse des Cunit -Tests, da alle Tests ohne Fehler bestanden wurden.

Beispiel 2

Wir haben ein weiteres Beispiel, in dem wir die beiden Dateibehandlungsmethoden „Fread“ und „Fprintf“ durch den Cunit -Ansatz getestet haben. Wir haben die temporäre Datei mit den Cunit -Testfunktionen geöffnet und geschlossen. Der Cunit -Testbetrieb testen die Bibliotheksfunktionen durch Schreiben und Lesen aus der temporären Datei.

#enthalten
#enthalten
#enthalten
#enthalten
#include "Cunit/Basic.H"
statische Datei* file = null;
init init_suite1 (void)

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

anders
Rückkehr 0;


int clean_suite1 (void)

if (0 != fcLose (Datei))
Return -1;

anders
Datei = null;
Rückkehr 0;


void test_fprintf (void)

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


void test_fread (void)

vorzeichenloser Zeichenpuffer [20];
if (null != Datei)
Rückspulen (Datei);
Cu_assert (9 == fread (puffer, sizeof (unsigned char), 20, Datei));
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, Clean_Suite1);
if (null == psuite)
Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (psuite, "fprintf () Funktionstest", test_fprintf)) ||
(NULL == Cu_ADD_test (psuite, "fread () Funktionstest", 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 ();

In der Header -Datei haben wir die Cunit Standard Library „Cunit“ definiert.h/grundlegend.H". Anschließend deklarierten wir "Datei" als Zeiger auf die von den Tests verwendete Datei. Als nächstes haben wir die Funktion „init_suite1“ konstruiert, die die temporäre Datei „MyFile.txt ”und gibt den Wert Null für den Erfolg zurück; Andernfalls wird ein Wert ungleich Null zurückgegeben. Um die Datei zu schließen, haben wir die Suite-Reinigungsfunktion erstellt, die beim Schließen der temporären Datei auch einen Wert ungleich Null beim Fehlern zurückgibt. Andernfalls wird bei erfolgreicher Schließung der temporären Datei Nullwert erhalten. Dann haben wir einfach eine Funktion „test_fprintf“ implementiert, in der wir die Daten in die temporäre Datei „MyFile“ eingefügt haben.txt". Diese Testfunktionen verifizierten auch die Anzahl der Bytes, die wir in die Datei schreiben wollten.

Danach haben wir eine weitere Funktion für die Funktion „test_fread“ erstellt, um die freie Methode zu testen. Hier haben wir überprüft, ob die angegebenen Zeichen in den zuvor geschriebenen Daten der Funktion „test_fprinf ()“ vorhanden sind. Dann haben wir die Hauptfunktion, bei der die Tests eingerichtet und ausgeführt werden. Wir haben die "psuite" in der Hauptfunktion definiert und die Registrierung mit der Testfunktion „cu_initialize_resgistry“ initialisiert. Wir haben auch die Funktion "Cu_Add_Suite" bezeichnet, um die Suite zur Registrierung hinzuzufügen, und die angegebenen Tests mit Hilfe der Funktion "Cu_Add_Test" zu den Suiten hinzugefügt.

Die grundlegenden Cunit -Testoberflächen werden am Ende verwendet, um die Ergebnisse des Codes anzuzeigen. Beachten Sie, dass die Hauptfunktion bei einer erfolgreichen Ausführung einen „Cue_Success“ und einen anderen Code „cunit_error“ bei erfolgloser Ausführung zurückgibt.

Wir haben den vorherigen Code für den Cunit -Test ausgeführt, in dem die Programmzusammenfassung und die Methode der erfolgreichen Tests angezeigt wurden.

Abschluss

Cunit ist ein Kernrahmen, das verschiedene Benutzeroberflächen bietet. Es ermöglicht uns, Testsuiten, Testfälle und Testregister zu verwalten. Das Testen der Programme und das Sehen der Ergebnisse dieser Tests wird von den Benutzeroberflächen erleichtert. Wir haben den Cunit -Test -Framework in C mit diesem Artikel behandelt. Wir haben die Installation demonstriert und dann zwei laufende Programme in der C -Sprache implementiert. Die getesteten vorherigen Programme haben erfolgreiche Ergebnisse erzielt.