CUnit в C

Cunit V C



Системата CUnit се използва за извършване на модулно тестване в C, което дава възможност за администриране и изпълнение на тестовете. Той обхваща разнообразен набор от твърдения за тестване на често използвани типове данни и използва проста архитектура за създаване на тестови структури. Кодът за тестване на потребителя е свързан с CUnit, който е проектиран като статична библиотека. Можем да изследваме изпълнението на задачите и функциите на C програмата, използвайки тестовата рамка CUnit. Всяка конкретна задача на C програмата има различни входни обстоятелства и изходни ограничения. За да използваме CUnit за тестване на C програмата, първо трябва да я инсталираме в нашата система. Стъпките за инсталиране на CUnit са описани по-долу.

Как да използвате CUnit Framework в Ubuntu 22.04

За да използваме рамката за тестване на CUnit в нашата система, трябва да следваме стъпките за инсталиране. Тези стъпки се отнасят за системата Ubuntu 22.04. Преди инсталирането първо актуализирахме нашата система. Системата изисква sudo привилегия, за да се актуализира с командата apt.








За да придобие привилегии на sudo, терминалът поиска удостоверяване от потребителя на sudo. След това актуализирайте системните пакети и техните зависимости, както е показано по-долу.




Сега инсталирахме рамката CUnit с помощта на следната команда. Тази команда може да инсталира пакетите libcunitl, libcunitl-doc и libcunitl-dev от хранилището на пакети.




След като се изпълни командата за инсталиране на CUnit, се изисква потребителска парола. Основните пакети на CUnit са инсталирани в нашия Ubuntu 22.04.





Пример 1

Завършихме стъпката на инсталиране на рамката CUnit в предишния раздел. Сега тествахме метода на сумата и разликата, за да видим очакваните резултати в следния пример, използвайки рамката за тестване CUnit.



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

int init_suite ( невалиден ) { връщане 0 ; }
int clean_suite ( невалиден ) { връщане 0 ; }

int MySum ( ти си a1, ти си b1 )

{
int res1;
res1 =a1+b1;
връщане res1;
}

int MyDiff ( int a2, int b2 )

{
int res2;
res2 =a2-b2;
връщане res2;
}

void test_MySum ( невалиден )
{
WITH_ASSERT ( 4 ==Моята сума ( две , две ) ) ;
WITH_ASSERT ( 8 ==Моята сума ( 5 , 3 ) ) ;
WITH_ASSERT ( две ==Моята сума ( - две , 4 ) ) ;
WITH_ASSERT ( 7 ==Моята сума ( 0 , 7 ) ) ;
}


void test_MyDiff ( невалиден )
{
WITH_ASSERT ( 3 ==Моята разлика ( 5 , две ) ) ;
WITH_ASSERT ( - 4 ==Моята разлика ( 4 , 8 ) ) ;
WITH_ASSERT ( - 7 ==Моята разлика ( - 3 , 4 ) ) ;
WITH_ASSERT ( - 9 ==Моята разлика ( 0 , 9 ) ) ;
}


int main ( невалиден )
{

CU_pSuite pSuite1,pSuite2 = NULL;

ако ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
връщане CU_get_error ( ) ;

pSuite1 = CU_add_suite ( „Тест пакет 1“ , init_suite, clean_suite ) ;
ако ( NULL == pSuite1 ) {
CU_cleanup_registry ( ) ;
връщане CU_get_error ( ) ;
}

ако ( ( NULL == CU_add_test ( pSuite1, ' Тестване на функцията на сумата ' , test_MySum ) ) )
{
CU_cleanup_registry ( ) ;
връщане CU_get_error ( ) ;
}

ако ( ( NULL == CU_add_test ( pSuite1, ' Тестване на функцията за разлика ' , test_MyDiff ) ) )
{
CU_cleanup_registry ( ) ;
връщане CU_get_error ( ) ;
}

CU_basic_run_tests ( ) ;

CU_cleanup_registry ( ) ;
връщане CU_get_error ( ) ;
}







Първо, за да генерираме структурата CUnit, вмъкнахме библиотеката CUnit „CUnit/Basic.h“ с включената ключова дума. Тази C библиотека е за рамки за тестване на единици и предлага прост интерфейс за изход на конзолата. След това добавихме две функции, „init_suite“ за инициализация на функцията на пакета и „clean_suite“ за почистване на функцията на пакета, към нашата програма за тестване.

След това създадохме методи „MySum“ и „MyDiff“, които да бъдат тествани от CUnit. Извикахме конструктора за тези функции, който съдържа променливите, върху които са извършени операции за събиране и разлика. След това създадохме функция като „test_MySum“ за тестване. Вътре във функцията сме използвали метода „CU_ASSERT“, където се присвояват началните изрази за сумата. Също като „test_MySum“, създадохме функцията test_MyDiff, за да тестваме израза за различни операции, използвайки метода „CU_ASSERT“.

След това имаме кода на CUnit runner в главния метод. Тук създадохме два пакета, „pSuite1“ и „pSuite2“, от метода „CU_pSuite“ и присвоихме на тези пакети стойност NULL. Създадохме тези пакети за изпълнение на теста CUnit, който трябва да бъде регистриран в регистъра на тестовете. Преди да добавим пакетите към „test_registry“, ние създадохме регистъра и го инициализирахме с „if условие“. Използвахме метода “CU_initialze_registry()” за създаване на регистър за тестване на пакети.

След това добавихме pSuite1 към тестовия регистър, като извикахме метода „CU_add_suite“ на CUnit. След това добавихме нашите тестове, „test_MySum“ и „test_MyDiff“, към посочените пакети, като използвахме метода „CU_add_test()“. В крайна сметка показахме резултатите от теста CUnit, като извикахме метода „CU_basic_run_tests()“ и почистихме системния регистър, след като резултатите бяха показани успешно. Грешката, възникнала при извършване на CUnit тестовете, ще бъде хвърлена от функцията „CU_get_error()“.

Предишният тестов файл CUnit се записва като файл mytest.c. Ние изпълнихме този C файл с командата GCC. Използвахме флага -lcunit за изпълнение на тестов файл на CUnit. С тази команда нашият код се компилира. След това изпълнихме файла mytest и той показа очакваните резултати от теста CUnit, тъй като всички тестове бяха преминати без грешка.

Пример 2

Имаме друг пример, при който сме тествали двата метода за обработка на файлове, „fread“ и „fprintf“, чрез подхода CUnit. Отворихме и затворихме временния файл с помощта на тестовите функции на CUnit. Тестовите операции на CUnit тестват библиотечните функции чрез запис и четене от временния файл.

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

статичен ФАЙЛ * файл = NULL;
int init_suite1 ( невалиден )
{
ако ( NULL == ( файл = fopen ( 'MyFile.txt' , 'w +' ) ) ) {
връщане -1 ;
}
друго {
връщане 0 ;
}
}

int clean_suite1 ( невалиден )
{
ако ( 0 ! = fclose ( файл ) ) {
връщане -1 ;
}
друго {
файл = NULL;
връщане 0 ;
}
}


невалиден test_fprintf ( невалиден )
{
int x1 = 10 ;

ако ( НУЛА ! = файл ) {
WITH_ASSERT ( две == fprintf ( файл , „В ' ) ) ;
WITH_ASSERT ( 7 == fprintf ( файл , 'x1 = %d' , x1 ) ) ;
}
}

void test_fread ( невалиден )
{
неподписан char буфер [ двадесет ] ;

ако ( НУЛА ! = файл ) {
превъртане назад ( файл ) ;
WITH_ASSERT ( 9 == страх ( буфер, sizeof ( неподписан char ) , двадесет , файл ) ) ;
WITH_ASSERT ( 0 == strncmp ( буфер, „В x1 = 10' , 9 ) ) ;
}
}

int main ( )
{
CU_pSuite pSuite = NULL;
ако ( CUE_SUCCESS ! = CU_initialize_registry ( ) )
връщане CU_get_error ( ) ;
pSuite = CU_add_suite ( 'Апартамент 1' , init_suite1, clean_suite1 ) ;
ако ( NULL == pSuite ) {
CU_cleanup_registry ( ) ;
връщане CU_get_error ( ) ;
}
ако ( ( NULL == CU_add_test ( pSuite, 'тест на функцията fprintf()' , test_fprintf ) ) ||
( NULL == CU_add_test ( pSuite, 'тест на функцията fread()' , test_fread ) ) )
{
CU_cleanup_registry ( ) ;
връщане CU_get_error ( ) ;
}
CU_basic_set_mode ( CU_BRM_VERBOSE ) ;
CU_basic_run_tests ( ) ;
CU_cleanup_registry ( ) ;
връщане CU_get_error ( ) ;
}







В рамките на заглавния файл сме дефинирали стандартната библиотека CUnit „CUnit.h/Basic.h“. След това декларирахме „файл“ като указател към файла, използван от тестовете. След това създадохме функцията “init_suite1”, която отваря временния файл “MyFile.txt” и връща стойност нула при успех; в противен случай ще бъде върната ненулева стойност. За да затворим файла, създадохме функцията за почистване на пакета, която също връща ненулева стойност при повреда, докато затваря временния файл. В противен случай при успешно затваряне на временния файл се получава нулева стойност. След това просто внедрихме функция „test_fprintf“, където сме вмъкнали данните във временния файл „MYfile.txt“. Тези тестови функции също така провериха броя байтове, които се опитахме да напишем във файла.

След това създадохме друга функция за функцията „test_fread“, за да тестваме метода fread. Тук сме проверили дали посочените знаци присъстват в предварително записаните данни чрез функцията „test_fprinf()“. След това имаме основната функция, където се обработват настроените и изпълнени тестове. Дефинирахме „pSuite“ в основната функция и инициализирахме системния регистър с помощта на тестовата функция „CU_initialize_resgistry“. Ние също извикахме функцията „CU_add_suite“, за да добавим пакета към регистъра и добавихме посочените тестове към пакетите с помощта на функцията „CU_add_test“.

Основните тестови интерфейси на CUnit се използват в крайна сметка за показване на резултатите от кода. Имайте предвид, че основната функция връща „CUE_SUCCESS“ при успешно изпълнение и различен код „CUnit_error“ при неуспешно изпълнение.

Изпълнихме предишния код за теста CUnit, който показва резюмето на програмата и съобщението за метода на успешните тестове.

Заключение

CUnit е основна рамка, която предоставя различни потребителски интерфейси. Позволява ни да управляваме тестови пакети, тестови случаи и тестови регистри. Тестването на програмите и виждането на резултатите от тези тестове се улесняват от потребителските интерфейси. С тази статия разгледахме тестовата рамка на CUnit в C. Демонстрирахме инсталацията и след това внедрихме две работещи програми на език C. Предишните тествани програми дадоха успешни резултати.