CUnité en C

Cunite En C



Le système CUnit est utilisé pour effectuer les tests unitaires en C, ce qui permet l'administration et l'exécution des tests. Il couvre une gamme variée d'assertions pour tester les types de données couramment utilisés et utilise une architecture simple pour créer des structures de test. Le code de test de l'utilisateur est lié à CUnit, qui est conçu comme une bibliothèque statique. Nous pouvons examiner les performances des tâches et des fonctions du programme C à l'aide du framework de test CUnit. Chaque tâche particulière du programme C a des circonstances d'entrée et des limitations de sortie différentes. Pour utiliser le CUnit pour tester le programme C, nous devons d'abord l'installer dans notre système. Les étapes d'installation de CUnit sont décrites ci-dessous.

Comment utiliser le framework CUnit dans Ubuntu 22.04

Pour utiliser le framework de test CUnit dans notre système, nous devons suivre les étapes d'installation. Ces étapes s'appliquent au système Ubuntu 22.04. Avant l'installation, nous avons d'abord mis à jour notre système. Le système nécessitait le privilège sudo pour être mis à jour avec la commande apt.








Pour acquérir les privilèges sudo, le terminal a demandé l'authentification à l'utilisateur sudo. Ensuite, mettez à jour les packages système et leurs dépendances, comme indiqué ci-dessous.




Maintenant, nous avons installé le framework CUnit en utilisant la commande suivante. Cette commande peut installer les packages libcunitl, libcunitl-doc et libcunitl-dev à partir du référentiel de packages.




Une fois la commande d'installation de CUnit exécutée, le mot de passe de l'utilisateur est requis. Les packages essentiels de CUnit ont été installés dans notre Ubuntu 22.04.





Exemple 1

Nous avons terminé l'étape d'installation du framework CUnit dans la section précédente. Maintenant, nous avons testé la méthode de la somme et de la différence pour voir les résultats attendus dans l'exemple suivant en utilisant le framework de test CUnit.



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

int init_suite ( annuler ) { revenir 0 ; }
int clean_suite ( annuler ) { revenir 0 ; }

int MaSomme ( tu es a1, tu es b1 )

{
int res1 ;
res1 =a1+b1 ;
revenir rés1 ;
}

int MaDiff ( entier a2, entier b2 )

{
int res2 ;
res2 =a2-b2 ;
revenir rés2 ;
}

annuler test_MySum ( annuler )
{
WITH_ASSERT ( 4 ==Ma somme ( deux , deux ) ) ;
WITH_ASSERT ( 8 ==Ma somme ( 5 , 3 ) ) ;
WITH_ASSERT ( deux ==Ma somme ( - deux , 4 ) ) ;
WITH_ASSERT ( sept ==Ma somme ( 0 , sept ) ) ;
}


annuler test_MyDiff ( annuler )
{
WITH_ASSERT ( 3 ==MaDiff ( 5 , deux ) ) ;
WITH_ASSERT ( - 4 ==MaDiff ( 4 , 8 ) ) ;
WITH_ASSERT ( - sept ==MaDiff ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==MaDiff ( 0 , 9 ) ) ;
}


int main ( annuler )
{

CU_pSuite pSuite1,pSuite2 = NULL ;

si ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
revenir CU_get_error ( ) ;

pSuite1 = CU_add_suite ( 'Suite d'essais1' , init_suite, clean_suite ) ;
si ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
revenir CU_get_error ( ) ;
}

si ( ( NULL == CU_add_test ( pSuite1, ' \n \n Test de la fonction somme \n \n ' , test_MaSomme ) ) )
{
CU_cleanup_registry ( ) ;
revenir CU_get_error ( ) ;
}

si ( ( NULL == CU_add_test ( pSuite1, ' \n \n Test de fonction de différence \n \n ' , test_MaDiff ) ) )
{
CU_cleanup_registry ( ) ;
revenir CU_get_error ( ) ;
}

CU_basic_run_tests ( ) ;

CU_cleanup_registry ( ) ;
revenir CU_get_error ( ) ;
}







Tout d'abord, pour générer la structure CUnit, nous avons inséré la bibliothèque CUnit 'CUnit/Basic.h' avec le mot-clé inclus. Cette bibliothèque C est destinée aux frameworks de test unitaire et offre une interface de sortie de console simple. Ensuite, nous avons ajouté deux fonctions, 'init_suite' pour l'initialisation de la fonction suite et 'clean_suite' pour le nettoyage de la fonction suite, à notre programme de test.

Ensuite, nous avons construit des méthodes, 'MySum' et 'MyDiff', à tester par le CUnit. Nous avons appelé le constructeur de ces fonctions, qui contient les variables sur lesquelles les opérations de somme et de différence ont été effectuées. Ensuite, nous avons établi une fonction comme 'test_MySum' à tester. À l'intérieur de la fonction, nous avons utilisé la méthode 'CU_ASSERT', où les expressions init pour la somme sont assignées. Identique à 'test_MySum', nous avons construit la fonction test_MyDiff pour tester l'expression pour différentes opérations à l'aide de la méthode 'CU_ASSERT'.

Ensuite, nous avons le code du coureur CUnit dans la méthode principale. Ici, nous avons créé deux suites, 'pSuite1' et 'pSuite2', à partir de la méthode 'CU_pSuite' et attribué à ces suites une valeur NULL. Nous avons créé ces suites pour exécuter le test CUnit qui doit être enregistré dans le registre des tests. Avant d'ajouter les suites au 'test_registry', nous avons créé le registre et l'avons initialisé avec la 'condition if'. Nous avons utilisé la méthode 'CU_initialze_registry()' pour créer le registre des suites de test.

Après cela, nous avons ajouté le pSuite1 au registre de test en appelant la méthode « CU_add_suite » de CUnit. Après cela, nous avons ajouté nos tests, 'test_MySum' et 'test_MyDiff', aux suites spécifiées en utilisant la méthode 'CU_add_test()'. Au final, nous avons affiché les résultats du test CUnit en appelant la méthode « CU_basic_run_tests() » et nettoyé le registre une fois les résultats affichés avec succès. L'erreur rencontrée lors des tests CUnit sera générée par la fonction 'CU_get_error()'.

Le fichier de test CUnit précédent est enregistré en tant que fichier mytest.c. Nous avons exécuté ce fichier C avec la commande GCC. Nous avons utilisé l'indicateur -lcunit pour l'exécution du fichier de test CUnit. Avec cette commande, notre code est compilé. Ensuite, nous avons exécuté le fichier mytest, et il a montré les résultats attendus du test CUnit car tous les tests ont été réussis sans aucun échec.

Exemple 2

Nous avons un autre exemple où nous avons testé les deux méthodes de gestion de fichiers, 'fread' et 'fprintf', par l'approche CUnit. Nous avons ouvert et fermé le fichier temporaire à l'aide des fonctions de test CUnit. Les opérations de test CUnit testent les fonctions de la bibliothèque en écrivant et en lisant à partir du fichier temporaire.

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

FICHIER statique * dossier = NUL ;
entier init_suite1 ( annuler )
{
si ( NUL == ( dossier = fopen ( 'MonFichier.txt' , 'w +' ) ) ) {
revenir -1 ;
}
autre {
revenir 0 ;
}
}

int propre_suite1 ( annuler )
{
si ( 0 ! = ffermer ( dossier ) ) {
revenir -1 ;
}
autre {
dossier = NUL ;
revenir 0 ;
}
}


annuler test_fprintf ( annuler )
{
entier x1 = dix ;

si ( NUL ! = dossier ) {
WITH_ASSERT ( deux == fprintf ( dossier , 'Q \n ' ) ) ;
WITH_ASSERT ( sept == fprintf ( dossier , 'x1 = %d' , x1 ) ) ;
}
}

annuler test_fread ( annuler )
{
tampon de caractères non signé [ vingt ] ;

si ( NUL ! = dossier ) {
rembobiner ( dossier ) ;
WITH_ASSERT ( 9 == peur ( tampon, taille de ( caractère non signé ) , vingt , dossier ) ) ;
WITH_ASSERT ( 0 == strncmp ( amortir, 'Q \n x1 = 10' , 9 ) ) ;
}
}

int main ( )
{
CU_pSuite pSuite = NULL ;
si ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
revenir CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Suite1' , init_suite1, clean_suite1 ) ;
si ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
revenir CU_get_error ( ) ;
}
si ( ( NULL == CU_add_test ( pSuite, 'Test de la fonction fprintf()' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'Test de la fonction fread()' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
revenir CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
revenir CU_get_error ( ) ;
}







Dans le fichier d'en-tête, nous avons défini la bibliothèque standard CUnit 'CUnit.h/Basic.h'. Ensuite, nous avons déclaré « file » comme pointeur vers le fichier utilisé par les tests. Ensuite, nous avons construit la fonction 'init_suite1' qui ouvre le fichier temporaire 'MyFile.txt' et renvoie la valeur zéro en cas de succès ; sinon, une valeur différente de zéro sera renvoyée. Pour fermer le fichier, nous avons créé la fonction de nettoyage de la suite, qui renvoie également une valeur non nulle en cas d'échec lors de la fermeture du fichier temporaire. Sinon, lors de la fermeture réussie du fichier temporaire, la valeur zéro est obtenue. Ensuite, nous avons simplement implémenté une fonction « test_fprintf » où nous avons inséré les données dans le fichier temporaire « MYfile.txt ». Ces fonctions de test ont également vérifié le nombre d'octets que nous avons tenté d'écrire dans le fichier.

Après cela, nous avons créé une autre fonction pour la fonction 'test_fread' afin de tester la méthode fread. Ici, nous avons vérifié que les caractères spécifiés sont bien présents dans les données précédemment écrites par la fonction « test_fprinf() ». Ensuite, nous avons la fonction principale où sont gérés les tests mis en place et exécutés. Nous avons défini la « pSuite » dans la fonction principale et initialisé le registre à l'aide de la fonction de test « CU_initialize_resgistry ». Nous avons également appelé la fonction 'CU_add_suite' pour ajouter la suite au registre et ajouté les tests spécifiés aux suites à l'aide de la fonction 'CU_add_test'.

Les interfaces de test de base de CUnit sont utilisées au final pour afficher les résultats du code. Notez que la fonction principale renvoie un 'CUE_SUCCESS' lors d'une exécution réussie et un code 'CUnit_error' différent lors d'une exécution infructueuse.

Nous avons exécuté le code précédent pour le test CUnit, qui affichait le résumé du programme et le message de méthode des tests réussis.

Conclusion

CUnit est un framework de base qui fournit diverses interfaces utilisateur. Il nous permet de gérer des suites de tests, des cas de test et des registres de test. Tester les programmes et voir les résultats de ces tests est facilité par les interfaces utilisateur. Nous avons couvert le framework de test CUnit en C avec cet article. Nous avons démontré l'installation puis implémenté deux programmes en cours d'exécution en langage C. Les programmes précédents testés ont donné de bons résultats.