CEenheid in C

Ceenheid In C



Het CUnit-systeem wordt gebruikt om de unittests in C uit te voeren, wat de administratie en uitvoering van de tests mogelijk maakt. Het omvat een breed scala aan beweringen voor het testen van veelgebruikte gegevenstypen en maakt gebruik van een eenvoudige architectuur voor het maken van teststructuren. De testcode van de gebruiker is gekoppeld aan CUnit, dat is ontworpen als een statische bibliotheek. We kunnen de prestaties van de taken en functies van het C-programma onderzoeken met behulp van het CUnit-testraamwerk. Elke specifieke taak van het C-programma heeft verschillende invoeromstandigheden en uitvoerbeperkingen. Om de CUnit te gebruiken voor het testen van het C-programma, moeten we deze eerst in ons systeem installeren. De stappen voor het installeren van CUnit worden hieronder beschreven.

Hoe het Cunit Framework te gebruiken in Ubuntu 22.04

Om het CUnit-testraamwerk in ons systeem te gebruiken, moeten we de installatiestappen volgen. Deze stappen zijn van toepassing op het Ubuntu 22.04-systeem. Voor de installatie hebben we eerst ons systeem geüpdatet. Het systeem had sudo-rechten nodig om te worden bijgewerkt met de opdracht apt.








Om sudo-rechten te verkrijgen, vroeg de terminal de authenticatie van de sudo-gebruiker. Werk vervolgens de systeempakketten en hun afhankelijkheden bij, zoals hieronder wordt weergegeven.




Nu hebben we het CUnit-framework geïnstalleerd met behulp van de volgende opdracht. Deze opdracht kan de pakketten libcunitl, libcunitl-doc en libcunitl-dev installeren vanuit de pakketrepository.




Zodra de CUnit-installatieopdracht is uitgevoerd, is het gebruikerswachtwoord vereist. De essentiële pakketten van CUnit zijn geïnstalleerd in onze Ubuntu 22.04.





voorbeeld 1

We hebben de installatiestap van het CUnit-framework in de vorige sectie voltooid. Nu hebben we de som- en verschilmethode getest om de verwachte resultaten in het volgende voorbeeld te zien met behulp van het CUnit-testraamwerk.



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

int init_suite ( leegte ) { opbrengst 0 ; }
int clean_suite ( leegte ) { opbrengst 0 ; }

int MijnSum ( jij bent a1, jij bent b1 )

{
int res1;
res1 =a1+b1;
opbrengst res1;
}

int MyDiff ( int a2, int b2 )

{
int res2;
res2 =a2-b2;
opbrengst res2;
}

ongeldig test_MijnSum ( leegte )
{
WITH_ASSERT ( 4 ==MijnSom ( twee , twee ) ) ;
WITH_ASSERT ( 8 ==MijnSom ( 5 , 3 ) ) ;
WITH_ASSERT ( twee ==MijnSom ( - twee , 4 ) ) ;
WITH_ASSERT ( 7 ==MijnSom ( 0 , 7 ) ) ;
}


ongeldige test_MyDiff ( leegte )
{
WITH_ASSERT ( 3 ==MijnVerschil ( 5 , twee ) ) ;
WITH_ASSERT ( - 4 ==MijnVerschil ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==MijnVerschil ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==MijnVerschil ( 0 , 9 ) ) ;
}


int hoofd ( leegte )
{

CU_pSuite pSuite1,pSuite2 = NULL;

als ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
opbrengst CU_get_error ( ) ;

pSuite1 = CU_add_suite ( 'Testsuite1' , init_suite, clean_suite ) ;
als ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
opbrengst CU_get_error ( ) ;
}

als ( ( NULL == CU_add_test ( pSuite1, ' \n \n Somfunctie Testen \n \n ' , test_MijnSum ) ) )
{
CU_cleanup_registry ( ) ;
opbrengst CU_get_error ( ) ;
}

als ( ( NULL == CU_add_test ( pSuite1, ' \n \n Verschilfunctie Testen: \n \n ' , test_MijnVerschil ) ) )
{
CU_cleanup_registry ( ) ;
opbrengst CU_get_error ( ) ;
}

CU_basic_run_tests ( ) ;

CU_cleanup_registry ( ) ;
opbrengst CU_get_error ( ) ;
}







Om de CUnit-structuur te genereren, hebben we eerst de CUnit-bibliotheek 'CUnit/Basic.h' ingevoegd met het meegeleverde sleutelwoord. Deze C-bibliotheek is bedoeld voor unit-testframeworks en biedt een eenvoudige console-uitvoerinterface. Vervolgens hebben we twee functies toegevoegd, 'init_suite' voor de initialisatie van de suite-functie en 'clean_suite' voor het opschonen van de suite-functie, aan ons testprogramma.

Vervolgens hebben we methoden geconstrueerd, 'MySum' en 'MyDiff', om te testen door de CUnit. We hebben de constructor voor deze functies aangeroepen, die de variabelen bevat waarop som- en verschilbewerkingen zijn uitgevoerd. Vervolgens hebben we een functie opgezet als 'test_MySum' om te testen. Binnen de functie hebben we de methode 'CU_ASSERT' gebruikt, waarbij de init-expressies voor de som worden toegewezen. Hetzelfde als 'test_MySum', we hebben de test_MyDiff-functie geconstrueerd om de expressie voor verschillende bewerkingen te testen met behulp van de 'CU_ASSERT' -methode.

Dan hebben we de CUnit runner-code in de hoofdmethode. Hier hebben we twee suites gemaakt, 'pSuite1' en 'pSuite2', op basis van de 'CU_pSuite'-methode en deze suites een NULL-waarde toegewezen. We hebben deze suites gemaakt om de CUnit-test uit te voeren die in het testregister moet worden geregistreerd. Voordat we de suites aan de 'test_registry' toevoegden, hebben we het register gemaakt en geïnitialiseerd met de 'if-voorwaarde'. We hebben de methode 'CU_initialze_registry()' gebruikt voor het maken van het register voor testsuites.

Daarna hebben we de pSuite1 toegevoegd aan het testregister door de 'CU_add_suite' -methode van CUnit aan te roepen. Daarna hebben we onze tests, 'test_MySum' en 'test_MyDiff', toegevoegd aan de opgegeven suites door gebruik te maken van de 'CU_add_test()'-methode. Uiteindelijk hebben we de resultaten van de CUnit-test weergegeven door de methode 'CU_basic_run_tests()' aan te roepen en het register opgeschoond zodra de resultaten met succes werden weergegeven. De fout die is opgetreden tijdens het uitvoeren van de CUnit-tests wordt gegenereerd door de functie 'CU_get_error()'.

Het vorige CUnit-testbestand wordt opgeslagen als het mytest.c-bestand. We hebben dit C-bestand uitgevoerd met het GCC-commando. We hebben de vlag -lcunit gebruikt voor het uitvoeren van het CUnit-testbestand. Met dit commando wordt onze code gecompileerd. Vervolgens hebben we het mytest-bestand uitgevoerd en het toonde de verwachte resultaten van de CUnit-test, aangezien alle tests zonder enige fout waren doorstaan.

Voorbeeld 2

We hebben nog een voorbeeld waarbij we de twee bestandsverwerkingsmethoden, 'fread' en 'fprintf', hebben getest met de CUnit-aanpak. We hebben het tijdelijke bestand geopend en gesloten met behulp van de CUnit-testfuncties. De CUnit-testbewerkingen testen de bibliotheekfuncties door uit het tijdelijke bestand te schrijven en te lezen.

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

statisch BESTAND * het dossier = NUL;
int init_suite1 ( leegte )
{
als ( NULL == ( het dossier = foppen ( 'MijnBestand.txt' , 'w +' ) ) ) {
opbrengst -1 ;
}
anders {
opbrengst 0 ;
}
}

int clean_suite1 ( leegte )
{
als ( 0 ! = fsluiten ( het dossier ) ) {
opbrengst -1 ;
}
anders {
het dossier = NUL;
opbrengst 0 ;
}
}


ongeldig test_fprintf ( leegte )
{
int x1 = 10 ;

als ( NUL ! = het dossier ) {
WITH_ASSERT ( twee == fprintf ( het dossier , 'Q \n ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( het dossier , 'x1 = %d' , x1 ) ) ;
}
}

ongeldig test_fread ( leegte )
{
niet-ondertekende char buffer [ twintig ] ;

als ( NUL ! = het dossier ) {
terugspoelen ( het dossier ) ;
WITH_ASSERT ( 9 == fread ( buffer, grootte van ( Ongetekend char ) , twintig , het dossier ) ) ;
WITH_ASSERT ( 0 == strncmp ( buffer, 'Q \n x1 = 10' , 9 ) ) ;
}
}

int hoofd ( )
{
CU_pSuite pSuite = NULL;
als ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
opbrengst CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Suite1' , init_suite1, clean_suite1 ) ;
als ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
opbrengst CU_get_error ( ) ;
}
als ( ( NULL == CU_add_test ( pSuite, 'fprintf() functietest' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'fread() functietest' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
opbrengst CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
opbrengst CU_get_error ( ) ;
}







Binnen het headerbestand hebben we de CUnit-standaardbibliotheek 'CUnit.h/Basic.h' gedefinieerd. Vervolgens hebben we 'bestand' gedeclareerd als een verwijzing naar het bestand dat door de tests wordt gebruikt. Vervolgens hebben we de functie 'init_suite1' geconstrueerd die het tijdelijke bestand 'MyFile.txt' opent en de waarde nul retourneert bij succes; anders wordt een waarde die niet nul is geretourneerd. Om het bestand te sluiten, hebben we de suite-opruimfunctie gemaakt, die ook een niet-nulwaarde retourneert bij een fout tijdens het sluiten van het tijdelijke bestand. Anders wordt bij het succesvol sluiten van het tijdelijke bestand een nulwaarde verkregen. Vervolgens hebben we eenvoudig een functie 'test_fprintf' geïmplementeerd waarbij we de gegevens in het tijdelijke bestand 'MYfile.txt' hebben ingevoegd. Deze testfuncties hebben ook het aantal bytes geverifieerd dat we in het bestand probeerden te schrijven.

Daarna hebben we een andere functie gemaakt voor de functie 'test_fread' om de fread-methode te testen. Hier hebben we gecontroleerd of de opgegeven tekens aanwezig zijn in de eerder geschreven gegevens door de functie 'test_fprinf()'. Vervolgens hebben we de hoofdfunctie waar de opgezette en uitgevoerde tests worden afgehandeld. We hebben de 'pSuite' in de hoofdfunctie gedefinieerd en het register geïnitialiseerd met behulp van de testfunctie 'CU_initialize_resgistry'. We hebben ook de functie 'CU_add_suite' genoemd om de suite aan het register toe te voegen en de gespecificeerde tests aan de suites toegevoegd met behulp van de functie 'CU_add_test'.

De basis CUnit-testinterfaces worden uiteindelijk gebruikt om de resultaten van de code weer te geven. Merk op dat de hoofdfunctie een 'CUE_SUCCESS' retourneert bij een succesvolle uitvoering en een andere 'CUnit_error'-code bij een mislukte uitvoering.

We hebben de vorige code voor de CUnit-test uitgevoerd, die de programma-samenvatting en het bericht over de succesvolle testmethode weergaf.

Conclusie

CUnit is een kernraamwerk dat verschillende gebruikersinterfaces biedt. Hiermee kunnen we testsuites, testcases en testregisters beheren. Het testen van de programma's en het zien van de resultaten van die tests wordt vergemakkelijkt door de gebruikersinterfaces. We hebben het CUnit-testraamwerk in C met dit artikel behandeld. We hebben de installatie gedemonstreerd en vervolgens twee actieve programma's in C-taal geïmplementeerd. De eerder geteste programma's hebben succesvolle resultaten opgeleverd.