क्यूनिट: गतिशील परीक्षण लोडिंग के साथ स्वचालित परीक्षण

उद्देश्य: CUnit ढांचे के ऊपर एक "मैत्रीपूर्ण" वातावरण बनाना, डेवलपर्स / परीक्षकों को अतिरिक्त इशारों के बिना नए परीक्षण जोड़ने की अनुमति देना। क्यूनिट का उपयोग रूपरेखा के रूप में क्यों किया जाता है? यह सरल है: सितारे बहुत अभिसरण हैं।

यहां मैं यह वर्णन नहीं करूंगा कि क्यूनिट कैसे काम करता है या इस फ्रेमवर्क का उपयोग करके टेस्ट केस और टेस्ट सूट कैसे लिखना है। यह सब आधिकारिक दस्तावेज में है, जो http://cunit.sourceforge.net/doc/index.html पर स्थित है।


इसलिए, पहले हम निर्देशिकाओं और फ़ाइलों की संरचना पर निर्णय लेते हैं:

.tests |-- suites | |-- CMakeLists.txt | |-- suite1.c | |-- suite2.c | |-- suite3.c |-- main.c |-- utils.c |-- utils.h |-- CMakeLists.txt 

प्रत्येक परीक्षण सूट सुइट निर्देशिका में एक अलग फ़ाइल में स्थित होगा। डेवलपर या टेस्टर का काम केवल एक टेस्ट सूट लिखना और उसे सूट्स फोल्डर में डालना है। डेवलपर / परीक्षक से किसी अन्य इशारों की आवश्यकता नहीं है, परीक्षण सूट को संकलन के लिए निर्माण प्रणाली द्वारा स्वचालित रूप से उठाया जाएगा, और फिर परीक्षण चलने पर स्वयं कार्यक्रम।

इसे असेंबल करने के बाद, हमें रनटैस्ट मिलनी चाहिए - निष्पादन योग्य कार्यक्रम और परीक्षण सूट के साथ मॉड्यूल।

नामकरण सम्मेलन

हम सहमत हैं कि परीक्षण मामलों में उपसर्ग test_ होगा । यही है, अगर हम लाइब्रेरी फंक्शन फू () का परीक्षण करते हैं, तो फ़ंक्शन के परीक्षण मामले को test_foo () कहा जाना चाहिए।

परीक्षण सूट के प्रत्येक गतिशील मॉड्यूल में, रनसुइट () फ़ंक्शन को निर्यात किया जाना चाहिए, जिसे निष्पादन योग्य कार्यक्रम में बुलाया जाएगा। इस फ़ंक्शन में, क्यूनिट का उपयोग करके परीक्षण सूट बनाया जाना चाहिए, जिसके साथ परीक्षण मामले जुड़े हुए हैं। समारोह प्रोटोटाइप:

शून्य रनसुइट (वोद);

डायनामिक मॉड्यूल टेम्पलेट - टेस्ट सूट

suite1.c:

 /*  - */ static void test_foo(void) { /*  - */ } /*  - */ static void test_foo2(void) { /*  - */ } void runSuite(void) { /*  - */ } 

यह कैसे काम करना चाहिए

जब रनटेस्ट निष्पादन योग्य प्रोग्राम लॉन्च किया जाता है, तो यह सभी डायनेमिक मॉड्यूल को लोड करता है - सुइट्स डायरेक्टरी से टेस्ट करता है, अगर पर्यावरण चर TEST_MODULES_DIR सेट नहीं है, और प्रत्येक मॉड्यूल के रनसुइट () फ़ंक्शन करता है। यदि पर्यावरण चर TEST_MODULES_DIR निर्दिष्ट है , तो इस चर द्वारा इंगित निर्देशिका से लोड किया जाएगा

कार्यान्वयन

पहली चीज जिसे हम लागू करते हैं, वह है मुख्य कार्यक्रम और गतिशील मॉड्यूल की खोज का सहायक कार्य। कार्यों को main.c फाइल में लागू किया जाएगा:

 #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <unistd.h> #include <dlfcn.h> #include <sys/types.h> #include <sys/stat.h> #include <dirent.h> #include <CUnit/Basic.h> #include "utils.h" int modules_alphasort(const char **a, const char **b) { return strcoll(*a, *b); } void (*runSuite)( void); /*     */ size_t searchModulesInDir( char ***m_list, char *dir ) { DIR *modules_dir = NULL; struct dirent *ent = NULL; size_t count = 0; char **modules_list = NULL; char *error = NULL; void *mem_module = NULL; void *module_handle = NULL; unsigned int allocated_mem = 0; errno = 0; if( !dir ) { return -1; } modules_dir = opendir( dir ); if( !modules_dir ) { fprintf( stderr, "%s: %s\n", dir, strerror(errno)); return -1; } while( ( ent = readdir( modules_dir ) ) ) { if( strncmp( ent->d_name, ".", 1 ) == 0 || strstr( ent->d_name, ".so" ) == NULL ) { continue; } size_t mem_len = ( strlen( ent->d_name ) + strlen( dir ) ) * sizeof( char ) + 2; char *module_path = malloc( mem_len ); memset(module_path, 0, mem_len); if( !module_path ) { fprintf( stderr, "%s\n", strerror(errno) ); return -1; } strncat( module_path, dir, strlen( dir ) * sizeof( char ) ); strncat( module_path, "/", 1 ); strncat( module_path, ent->d_name, strlen( ent->d_name ) * sizeof( char ) ); module_handle = dlopen ( module_path, RTLD_LAZY ); if( !module_handle ) { fprintf( stderr, "Could not load module: '%s'\n", dlerror()); free( module_path ); continue; } dlerror(); runSuite= dlsym( module_handle, "runSuite" ); error = dlerror(); if( error ) { fprintf( stderr, "Could not load module: %s\n", error); dlclose( module_handle ); free( module_path ); continue; } mem_module = realloc( modules_list, allocated_mem + strlen(module_path)); allocated_mem += strlen(module_path); if( !mem_module ) { fprintf( stderr, "%s\n", strerror(errno)); free( module_path ); dlclose( module_handle ); return -1; } modules_list = mem_module; modules_list[ count ] = module_path; count++; dlclose( module_handle ); } closedir( modules_dir ); qsort(modules_list, count, sizeof(char *), (int (*)(const void *, const void *))modules_alphasort); *m_list = modules_list; return count; } int main() { char *modules_dir = NULL; char *env_modules_dir = NULL; struct stat dir_info; size_t modules_total = 0; char **modules = NULL; size_t i = 0; void *module_handle = NULL; env_modules_dir = getenv( "TEST_SUITES_DIR" ); modules_dir = ( env_modules_dir ) ? env_modules_dir : "./suites"; if( stat( modules_dir, &dir_info ) < 0 ) { fprintf( stderr, "%s: %s\n", modules_dir, strerror(errno)); return 1; } if( !S_ISDIR( dir_info.st_mode ) ) { fprintf( stderr, "'%s' is not a directory\n", modules_dir); return 1; } if( access( modules_dir, R_OK | X_OK ) != 0 ) { fprintf( stderr, "Directory '%s' is not accessible\n", modules_dir ); return 1; } modules_total = searchModulesInDir( &modules, modules_dir); if(modules_total <= 0) { fprintf( stderr, "No test suites\n"); return 0; } CUnitInitialize(); for( i = 0; i < modules_total; i++ ) { module_handle = dlopen ( modules[i], RTLD_LAZY ); if( !module_handle ) { fprintf( stderr, "Module '%s'\n", dlerror()); continue; } runSuite = dlsym( module_handle, "runSuite" ); runSuite(); } CU_basic_set_mode(CU_BRM_VERBOSE); CU_basic_run_tests(); CUnitUInitialize(); return CU_get_error(); } 

हेल्पर फ़ंक्शंस और पर्यावरण मैक्रोज़

परीक्षण मामलों के लिए उपसर्ग को मैन्युअल रूप से लिखने या न करने के लिए, यदि बदतर है, यदि उपसर्ग बाद में बदल गया है, तो सभी परीक्षण मामलों का नाम नहीं बदलें, हम एक सहायक मैक्रो TEST_FUNCT लिखते हैं :

 #define TEST_FUNCT(name) \ static void test_##name() 

अब लिखने के बजाय:

 static void test_foo() { /* Some code */ } 

लिखें:

 TEST_FUNCT(foo) { /* Some code */ } 

परीक्षण सूट में परीक्षण के मामलों को जोड़ने के लिए एक और मैक्रो ADD_SUITE_TEST जोड़ें:

 #define ADD_SUITE_TEST(suite, name) \ if ((NULL == CU_add_test(suite, #name, (CU_TestFunc)test_##name))) {\ CU_cleanup_registry();\ return;\ }\ 

ठीक है, आखिरी चीज जो हमें चाहिए वह है टेस्ट सूट क्यूनाइट क्रिएटसुइट () बनाने के लिए एक हेल्पर फंक्शन।

सहायक कार्यों के मैक्रोज़ और प्रोटोटाइप utils.h फ़ाइल में स्थित हैं:

 #ifndef __UTILS_H__ #define __UTILS_H__ #include <stdio.h> #include <stdlib.h> #include <CUnit/Basic.h> #define TEST_FUNCT(name) \ static void test_##name() #define ADD_SUITE_TEST(suite, name) \ if ((NULL == CU_add_test(suite, #name, (CU_TestFunc)test_##name))) {\ CU_cleanup_registry();\ return;\ }\ CU_pSuite CUnitCreateSuite(const char* title); void CUnitInitialize(void); void CUnitUInitialize(void); #endif 

Utils.c फ़ाइल में, हम सहायक कार्यों को लागू करते हैं:

 #include <string.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <CUnit/Basic.h> #include "utils.h" void CUnitUInitialize(void) { CU_cleanup_registry(); } void CUnitInitialize(void) { if (CU_initialize_registry() != CUE_SUCCESS) { fprintf(stderr, "Failed to initialize the CUnit registry: %d\n", CU_get_error()); exit(1); } } static int initSuite(void) { return 0; } static int cleanSuite(void) { return 0; } CU_pSuite CUnitCreateSuite(const char* title) { CU_pSuite suite = NULL; suite = CU_add_suite(title, initSuite, cleanSuite); if (suite == NULL) { CU_cleanup_registry(); return NULL; } return suite; } 

अब एक परीक्षण सूट लिखते हैं:

 #include <stdio.h> #include <stdlib.h> #include <CUnit/Basic.h> #include "utils.h" TEST_FUNCT(foo) { /*   */ CU_ASSERT_EQUAL(0, 1); } TEST_FUNCT(foo2) { /*   */ CU_ASSERT_EQUAL(1, 1); } void runSuite(void) { CU_pSuite suite = CUnitCreateSuite("Suite1"); if (suite) { ADD_SUITE_TEST(suite, foo) ADD_SUITE_TEST(suite, foo2) } } 

सभा

फ़ाइल मुकदमा / CMakeLists.txt:

 MACRO(ADD_MODULE file) ADD_LIBRARY( ${file} MODULE ${file}.c ../utils.c ) TARGET_LINK_LIBRARIES( ${file} cunit ) SET_TARGET_PROPERTIES( ${file} PROPERTIES PREFIX "" LIBRARY_OUTPUT_DIRECTORY "." ) ENDMACRO(ADD_MODULE file) FILE(GLOB C_FILES RELATIVE "${CMAKE_SOURCE_DIR}/suites" "${CMAKE_SOURCE_DIR}/suites/*.c") INCLUDE_DIRECTORIES ( "${CMAKE_SOURCE_DIR}" ) FOREACH ( module ${C_FILES} ) STRING( REGEX REPLACE ".c$" "" module "${module}" ) MESSAGE(STATUS "Found test suite: ${module}") ADD_MODULE(${module}) ENDFOREACH ( module ${MODULES} ) 

CMakeLists.txt फ़ाइल:

 CMAKE_MINIMUM_REQUIRED (VERSION 2.6) SET(CMAKE_VERBOSE_MAKEFILE ON) PROJECT("runtest") SET(CMAKE_C_FLAGS " -std=c99 -O3 -Wall -Wextra -Wimplicit") INCLUDE_DIRECTORIES ( "/usr/include" ) ADD_EXECUTABLE(runtests main.c utils.c) TARGET_LINK_LIBRARIES(runtests cunit dl) ADD_CUSTOM_TARGET(test "./runtests" WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" VERBATIM) ADD_SUBDIRECTORY(suites) 

 antonio: परीक्षण antonio $ cmake।
 एंटोनियो: परीक्षण एंटोनियो $ मेक
 एंटोनियो: एंटोनियो $ ./runtests का परीक्षण करता है