Cunit 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 un éventail diversifié d'affirmations 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 fonctions du programme C à l'aide du cadre de test CUNIT. Chaque tâche particulière du programme C a différentes circonstances d'entrée et limitations de sortie. Pour utiliser le CUNIT pour tester le programme C, nous devons l'installer d'abord dans notre système. Les étapes d'installation de CUNIT sont décrites ci-dessous.

Comment utiliser le cadre CUNIT dans Ubuntu 22.04

Pour utiliser le cadre de test CUNIT dans notre système, nous devons suivre les étapes d'installation. Ces étapes s'appliquent à l'ubuntu 22.04 Système. Avant l'installation, nous avons d'abord mis à jour notre système. Le système a exigé le privilège sudo pour être mis à jour avec la commande APT.

Pour acquérir des privilèges sudo, le terminal a demandé à l'authentification de 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-div à partir du référentiel de package.

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

Exemple 1

Nous avons terminé l'étape d'installation du cadre 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 cadre de test CUNIT.

#inclure
#inclure
#inclure
#inclure
#include "CUNIT / BASIC.H "
int 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 (vide)

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 Fonction Test \ n \ n", test_mysum)))

Cu_cleanup_registry ();
return cu_get_error ();

if ((null == cu_add_test (PSUITE1, "\ n \ nDifférence Fonction Test \ n \ n", test_mydiff))))

Cu_cleanup_registry ();
return cu_get_error ();

Cu_basic_run_tests ();
Cu_cleanup_registry ();
return 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 cadres de test unitaires et propose une interface de sortie de console simple. Ensuite, nous avons ajouté deux fonctions, «init_suite» pour l'initialisation de la fonction de la 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 des opérations de somme et de différence ont été effectuées. Ensuite, nous avons établi une fonction de «test_mysum» pour tester. À l'intérieur de la fonction, nous avons utilisé la méthode «Cu_assert», où les expressions d'initiés pour la somme sont attribuées. Identique à «test_mysum», nous avons construit la fonction test_mydiff pour tester l'expression de différentes opérations en utilisant la méthode «Cu_assert».

Ensuite, nous avons le code du coureur cunit à l'intérieur de 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 nulle. Nous avons créé ces suites pour exécuter le test CUNIT qui devrait ê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_inialze_registry ()» pour créer le registre pour tester les suites.

Après cela, nous avons ajouté le PSUITE1 au registre des tests en invoquant 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 ()". En fin de compte, nous avons affiché les résultats du test CUNIT en appelant la méthode «cu_basic_run_tests ()» et nettoyé le registre une fois que les résultats ont été affichés avec succès. L'erreur rencontrée lors des tests CUNIT sera lancée par la fonction «CU_GET_ERROR ()».

Le fichier de test CUNIT précédent est enregistré comme le mytest.c fichier. 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é passés sans aucun échec.

Exemple 2

Nous avons un autre exemple où nous avons testé les deux méthodes de traitement des 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.

#inclure
#inclure
#inclure
#inclure
#include "CUNIT / BASIC.H "
fichier statique * fichier = null;
int init_suite1 (void)

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

autre
retour 0;


int Clean_suite1 (void)

if (0 != fclose (fichier))
retour -1;

autre
file = null;
retour 0;


void test_fprintf (void)

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


void test_fread (void)

tampon char non signé [20];
si (null != fichier)
Rewind (fichier);
CU_ASSERT (9 == Fread (tampon, sizeof (char non signé), 20, fichier));
Cu_assert (0 == strncmp (tampon, "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 () Function Test", test_fprintf)) ||
(Null == CU_ADD_TEST (PSuite, "Fread () Function Test", 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 ();

Dans le fichier d'en-tête, nous avons défini la bibliothèque standard CUNIT «CUNIT.h / basique.h ”. Ensuite, nous avons déclaré «fichier» 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 sur le succès; Sinon, une valeur non nulle sera retournée. Pour fermer le fichier, nous avons créé la fonction de nettoyage de la suite, qui renvoie également une valeur non nulle en cas de défaillance tout en fermant le fichier temporaire. Sinon, en fermant avec succès le fichier temporaire, une 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.SMS". 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» pour tester la méthode Fread. Ici, nous avons vérifié que les caractères spécifiés sont présents dans les données précédemment écrites par la fonction "test_fprinf ()". Ensuite, nous avons la fonction principale où les tests configurés et exécutés sont gérés. Nous avons défini le «psuite» dans la fonction principale et initialisé le registre à l'aide de la fonction de test «cu_inialize_resgistry». Nous avons également appelé la fonction «Cu_add_suite» pour ajouter la suite au registre et ajouter les tests spécifiés aux suites à l'aide de la fonction «CU_ADD_TEST».

Les interfaces de test CUNIT de base sont utilisées à la fin pour afficher les résultats du code. Notez que la fonction principale renvoie un «cue_success» lors de l'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 a affiché le résumé du programme et le message de méthode des tests réussis.

Conclusion

CUNIT est un cadre central qui fournit diverses interfaces utilisateur. Il nous permet de gérer les suites de tests, les cas de test et les registres de test. Tester les programmes et voir les résultats de ces tests est facilité par les interfaces utilisateur. Nous avons couvert le cadre de test CUNIT en C avec cet article. Nous avons démontré l'installation, puis mis en œuvre deux programmes de course en C en C. Les programmes précédents testés ont donné des résultats réussis.