#ifndef __TOOLS_T_C_H__ #define __TOOLS_T_C_H__ #include #include #include #include #include #include // to define DEBUG in gcc cli do: gcc -D DEBUG=1 or 0 if need! #ifndef DEBUG #define DEBUG 0 #endif // F_OUT file (stream) to log #ifndef F_OUT #define F_OUT stdout #endif // F_ERR file (stream) to log #ifndef F_ERR #define F_ERR stderr #endif /* #ifndef SECOND #define SECOND 0 #endif #ifndef NANOSECOND #define NANOSECOND 0 #endif double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start); double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start); long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start); */ #if 1 extern long int PRECISION_TYPE_FLOAT ; extern long int PRECISION_TYPE_DOUBLE ; extern long int PRECISION_TYPE_L_DOUBLE ; #endif //void get_cursor_position(int *col, int *rows); #if DEBUG #define debug_print(fmt, ...) \ do { /*if (DEBUG)*/ fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \ __LINE__, __func__, __VA_ARGS__); } while (0) #define PRINT_DEBUG_(fmt, ...) \ do { /*if (DEBUG)*/ fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \ __LINE__, __func__, __VA_ARGS__); } while (0) #else #define debug_print(fmt, ...) {} #define PRINT_DEBUG_(fmt, ...) {} #endif #define error_print(fmt, ...) \ fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \ __LINE__, __func__, __VA_ARGS__); #define PRINT_ERROR(fmt, ...) \ fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \ __LINE__, __func__, __VA_ARGS__); #define PRINT_LOC_T(fmt, ...) \ fprintf(F_OUT, "%s:%d:%s(): " fmt, __FILE__, \ __LINE__, __func__, __VA_ARGS__); #define TYPE_CHAR char #define TYPE_U_CHAR unsigned char #define TYPE_INT int #define TYPE_U_INT unsigned int #define TYPE_L_INT long int #define TYPE_U_L_INT unsigned long int #define TYPE_SIZE_T size_t #define TYPE_FLOAT float #define TYPE_DOUBLE double #define TYPE_L_DOUBLE long double #define TYPE_STRING char* #define FREE(x) { free((x)); (x) = NULL;} #define FOREACH(array, size, function)\ for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]); #define MIN(X, Y) (((Y) < (X)) ? (Y) : (X)) #define MAX(X, Y) (((Y) > (X)) ? (Y) : (X)) #define GENERATE_ALL(type)\ int COMPARE_N_##type(const void *,const void*);\ void COPY_ARRAY_##type(type* dst, const type* src, size_t size);\ type MAX_ARRAY_##type(const type *array, size_t size);\ size_t ARG_MAX_ARRAY_##type(const type *array, size_t size);\ type MIN_ARRAY_##type(const type *array, size_t size);\ size_t ARG_MIN_ARRAY_##type(const type *array, size_t size);\ TYPE_STRING type##_TO_STR(type var);\ GENERATE_ALL(TYPE_CHAR) GENERATE_ALL(TYPE_U_CHAR) GENERATE_ALL(TYPE_INT) GENERATE_ALL(TYPE_U_INT) GENERATE_ALL(TYPE_L_INT) GENERATE_ALL(TYPE_U_L_INT) GENERATE_ALL(TYPE_SIZE_T) GENERATE_ALL(TYPE_FLOAT) GENERATE_ALL(TYPE_DOUBLE) GENERATE_ALL(TYPE_L_DOUBLE) GENERATE_ALL(TYPE_STRING) /* strto_type */ int strto_TYPE_INT(char *str, char **endptr); unsigned int strto_TYPE_U_INT(char *str, char **endptr); long int strto_TYPE_L_INT(char *str, char **endptr); unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr); size_t strto_TYPE_SIZE_T(char *str, char **endptr); float strto_TYPE_FLOAT(char *str, char **endptr); double strto_TYPE_DOUBLE(char *str, char **endptr); long double strto_TYPE_L_DOUBLE(char *str, char **endptr); /* * time calucl */ double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start); double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start); long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start); #endif /*__TOOLS_T_C_H__*/ #ifndef __BAR_PROGRESS_H__ #define __BAR_PROGRESS_H__ #include #include #include //#include #include #include /* * Prepares screen for progress bar. */ void bar_progress_start(void); void bar_progress_step_msg(int step_progress, int all_progress, char *msg, char fill_bar, char fill_dot, int colored); /* * progress value 0 to 100 */ void bar_progress_step(float step_percent); /* * Removes progress bar and restores original screen size. */ void bar_progress_stop(void); #define bg_red "\033[0;41m" #define bg_green "\033[0;42m" #define bg_yellow "\033[0;43m" #define bg_blue "\033[0;44m" #define bg_magenta "\033[0;45m" #define bg_cyan "\033[0;46m" #define bg_white "\033[30;47m" #define bg_gray "\033[37;40m" #define BG_GREEN "\033[42;30m" #define BG_RED "\033[41m" #endif /* __BAR_PROGRESS_H */ #ifndef __TEST_C_H__ #define __TEST_C_H__ #include #include #include #include //#include #include //#include #include /* to have size of screen, for progress bar */ #include #define DEFAULT_K "\033[0m" /*Resets the text to default color*/ #define GREEN_K "\033[0;32m" #define RED_K "\033[0;31m" #define YELLOW_K "\033[0;33m" #define BLUE_K "\033[0;34m" #define NOTHING_K "" #define COLOR_SZ 6 #define Dknothing COLOR_SZ - 1 #define SZ_TAB_HK 8 /*#ifdef HK*/ #define gHK_EQ "[==========]" #define gHK_TR "[----------]" #define gHK_RN "[RUN ]" #define gHK_DN "[ DONE]" #define gHK_OK "[ OK ]" #define gHK_FL "[ FAILED ]" #define gHK_PS "[ PASSED ]" #define gHK_SK "[ SKIP ]" /*#else*/ #define HK_EQ "==========" #define HK_TR "----------" #define HK_RN "====== RUN" #define HK_DN "===== DONE" #define HK_OK "======= OK" #define HK_FL "===== FAIL" #define HK_PS "===== PASS" #define HK_SK "===== SKIP" /*#endif*/ /* HK */ /* * compare symbol */ #define EQ == #define LT < #define GT > #define LE <= #define GE >= #define NE != #define NORMAL 0 #define VERB 1 #define NOVERB 2 extern long int verb; extern FILE **f_ou_th; extern bool debug; extern bool unicolour; extern bool ordered; extern bool log_parallel; extern bool only_usage; extern char *savelog; extern char *colors_f[]; extern char *tab_hk_f[]; extern int k_DEFAULT, k_GREEN, k_RED, k_YELLOW, k_BLUE, k_NOTHING; extern int hk_EQ, hk_TR, hk_RN, hk_DN, hk_OK, hk_FL, hk_PS, hk_SK; extern char *varHK_EQ, *varHK_TR, *varHK_RN, *varHK_DN, *varHK_OK, *varHK_FL, *varHK_PS, *varHK_SK; /* * */ /* * to execute once in print functions in the case of log_parallel (printing on screen and recording in file), we have to copy to stream -> string before copy it, * so I have tried using fopen a file in memory location '/dev/shm' and remove it after use! * /dev/shm/tmp_PTHREAD_SELF() but it prints twice sometimes, * here a solution with open_memstream which is better */ #define PRINTF( ...) \ do{ \ FILE *stream ;\ size_t len;\ char *buf ;\ stream = open_memstream (&buf, &len);\ if (stream == NULL) { fprintf(stderr," error open_memstream %s:%d:%s \n",__FILE__,__LINE__,__func__); exit(0); }\ fprintf(stream, __VA_ARGS__); \ fflush(stream);\ if(is_parallel_nb){\ long int id_thread=id_of_thread_executed(__func__);\ if(log_parallel){\ fprintf(F_OUT, "%s",buf);\ if(id_thread >= 0){\ fprintf(f_ou_th[id_thread], "%s",buf);\ fflush(f_ou_th[id_thread]);\ }else{\ fprintf(f_ou_th[parallel_nb], "%s",buf);\ fflush(f_ou_th[parallel_nb]);\ }\ }\ else{\ if(id_thread >= 0){\ fprintf(f_ou_th[id_thread], "%s",buf);\ fflush(f_ou_th[id_thread]);\ }\ else {\ fprintf(F_OUT, "%s",buf);\ fprintf(f_ou_th[parallel_nb], "%s",buf);\ fflush(f_ou_th[parallel_nb]);\ }\ }\ } \ else{\ if(savelog){\ FILE *f_savelog = fopen(savelog,"a");\ fprintf(f_savelog, "%s",buf);\ fclose(f_savelog);\ }\ fprintf(F_OUT, "%s",buf);\ }\ fclose(stream);\ free(buf);\ }while(0) #define LOG(...) PRINTF(__VA_ARGS__) #define PRINT_LOC(fmt, ...) \ PRINTF( "%s:%d:%s(): " fmt, __FILE__, __LINE__, __func__, __VA_ARGS__) #define PRINT_HK_C(color,hk,fmt,...)\ PRINTF("%s%s%s" fmt, color,hk,colors_f[k_DEFAULT],__VA_ARGS__) #define PRINT_DEBUG(fmt, ...)\ do{ if(debug) PRINT_LOC(fmt, __VA_ARGS__);} while(0) /* * to skip the bloc test function */ #define SKIP(fmt,...)\ PRINT_HK_C(colors_f[k_GREEN], tab_hk_f[hk_SK], fmt, ## __VA_ARGS__);\ PRINT_LOC("%s\n\n" DEFAULT_K," Skiped "); return; struct func { char *name; void (*run)(void); struct func *next; }; extern bool is_parallel_nb; extern size_t parallel_nb ; long int id_of_thread_executed(const char *func_call_name); void parse_options(int argc, char **argv); void run_all_tests(); void execute_all(struct func *fun); void append_func(void (*run)(void), char *name); char* extract_func_edited_TEST_from_exec_func_name(char* func_name); /* TEST_funcname___NUM -> TEST(funcname) */ /* void run_some_tests(size_t cnt, ... ); void run_all_tests_exept(size_t cnt, ... ); void run_some_tests_ordered(size_t cnt, ... ); */ void run_all_tests_parallel(size_t parallel /*, int max_col*/); /* * to launch test with different parameters without re-compile it * it can print help if need! * */ void run_all_tests_args(int argc, char **argv); bool expected_true_f(bool val); bool expected_false_f(bool val); bool expected_true_f_name(bool val, const char *name); bool expected_false_f_name(bool val, const char *name); #define GEN_EXPECTED_OP_TYPE_FUNC(OP,type)\ bool expected_##OP##_##type(type var1, type var2);\ bool expected_##OP##_name_##type(type var1, type var2, const char *name);\ \ bool expected_array_##OP##_##type(type *var1, long int sz1, type *var2, long int sz2);\ bool expected_array_##OP##_name_##type(type *var1, long int sz1, type *var2, long int sz2, const char *name); /* * ***** generate signature of expected functions EQ *********** */ GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_U_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_INT) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_U_INT) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_U_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_SIZE_T) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_FLOAT) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_L_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_STRING) /* * ******************** end EQ generation ************************ */ /* * ***** generate signature of expected functions LT *********** */ GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_U_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_INT) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_U_INT) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_U_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_SIZE_T) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_FLOAT) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_L_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_STRING) /* * ******************** end LT generation ************************ */ /* * ***** generate signature of expected functions GT *********** */ GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_U_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_INT) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_U_INT) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_U_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_SIZE_T) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_FLOAT) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_L_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_STRING) /* * ******************** end GT generation ************************ */ /* * ***** generate signature of expected functions LE *********** */ GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_U_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_INT) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_U_INT) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_U_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_SIZE_T) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_FLOAT) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_L_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_STRING) /* * ******************** end LE generation ************************ */ /* * ***** generate signature of expected functions GE *********** */ GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_U_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_INT) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_U_INT) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_U_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_SIZE_T) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_FLOAT) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_L_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_STRING) /* * ******************** end GE generation ************************ */ /* * ***** generate signature of expected functions NE *********** */ GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_U_CHAR) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_INT) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_U_INT) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_U_L_INT) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_SIZE_T) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_FLOAT) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_L_DOUBLE) GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING) /* * ******************** end NE generation ************************ */ /* * only expect */ #define IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call) \ do{ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ }while(0); #define IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call) \ do{\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ }while(0); #define HANDLE_OP_EXPECT_NAME(OP,type,var1,var2,name_f,msg_call) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ \ } \ else{ \ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ } else { \ if(expected_##OP##_name_##type(var1, var2, name_f)){ \ /*IFTESTPASS_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_NAME(OP,type,var1,var2,name_f,msg_call);*/ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 %s failed %s \n",name_f,msg_call); \ } \ }\ }while(0); //#define EXPECT_OP_(OP,type,var1,var2) HANDLE_OP_EXPECT_(OP,type,var1,var2) /** * old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT * is_assert : 0 for EXPECT and 1 for ASSERT */ #define IFTESTPASS_ \ do{\ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ }while(0); #define IFTESTFAIL_ \ do{\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ }while(0); #define HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ /*IFTESTPASS_(var1,var2);*/ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ \ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ }\ }while(0); // ******************************************************************************************************************* /** * new HANDLE_OP_ EXPECT and ASSERT separated */ #define HANDLE_OP_EXPECT_(OP,type,var1,var2) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ /*IFTESTPASS_ ;*/ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_ ;*/ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ }while(0); #define HANDLE_OP_ASSERT_(OP,type,var1,var2) \ do{ \ if(is_parallel_nb == 0){\ if(expected_##OP##_##type(var1, var2)){ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ }else { \ if(expected_##OP##_name_##type(var1, var2, __func__)){ \ /*IFTESTPASS_(var1,var2) ; */ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC(" test passed : (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ }\ } \ else{ \ /*IFTESTFAIL_(var1,var2) ; */ \ char *str_var1 = type##_TO_STR(var1) , *str_var2 = type##_TO_STR(var2);\ PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\ ,#var1,STRFY(OP),#var2,#var1, str_var1, #var2, str_var2 ); \ free(str_var1); free(str_var2);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ }\ }while(0); // ******************************************************************************************************************** // *********************** begin EQ ************************ // ============== EXPECT ============================== #define EXPECT_EQ_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_CHAR,var1, var2) #define EXPECT_EQ_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_U_CHAR,var1, var2) #define EXPECT_EQ_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_INT,var1, var2) #define EXPECT_EQ_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_U_INT,var1, var2) #define EXPECT_EQ_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_L_INT,var1, var2) #define EXPECT_EQ_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_U_L_INT,var1, var2) #define EXPECT_EQ_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_SIZE_T,var1, var2) #define EXPECT_EQ_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_FLOAT,var1, var2) #define EXPECT_EQ_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_DOUBLE,var1, var2) #define EXPECT_EQ_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_L_DOUBLE,var1, var2) #define EXPECT_EQ_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_STRING,var1, var2) #define EXPECT_EQ(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_L_INT,var1, var2) // ============== ASERT ===================== #define ASSERT_EQ_TYPE_CHAR(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_CHAR,var1, var2) #define ASSERT_EQ_TYPE_U_CHAR(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_U_CHAR,var1, var2) #define ASSERT_EQ_TYPE_INT(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_INT,var1, var2) #define ASSERT_EQ_TYPE_U_INT(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_U_INT,var1, var2) #define ASSERT_EQ_TYPE_L_INT(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_L_INT,var1, var2) #define ASSERT_EQ_TYPE_U_L_INT(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_U_L_INT,var1, var2) #define ASSERT_EQ_TYPE_SIZE_T(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_SIZE_T,var1, var2) #define ASSERT_EQ_TYPE_FLOAT(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_FLOAT,var1, var2) #define ASSERT_EQ_TYPE_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_DOUBLE,var1, var2) #define ASSERT_EQ_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_L_DOUBLE,var1, var2) #define ASSERT_EQ_TYPE_STRING(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_STRING,var1, var2) #define ASSERT_EQ(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_L_INT,var1, var2) // ************************ end EQ ********************** // *********************** begin LT ************************ // ============== EXPECT ============================== #define EXPECT_LT_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_CHAR,var1, var2) #define EXPECT_LT_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_U_CHAR,var1, var2) #define EXPECT_LT_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_INT,var1, var2) #define EXPECT_LT_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_U_INT,var1, var2) #define EXPECT_LT_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_L_INT,var1, var2) #define EXPECT_LT_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_U_L_INT,var1, var2) #define EXPECT_LT_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_SIZE_T,var1, var2) #define EXPECT_LT_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_FLOAT,var1, var2) #define EXPECT_LT_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_DOUBLE,var1, var2) #define EXPECT_LT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_L_DOUBLE,var1, var2) #define EXPECT_LT_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_STRING,var1, var2) #define EXPECT_LT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_L_INT,var1, var2) // ============== ASERT ===================== #define ASSERT_LT_TYPE_CHAR(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_CHAR,var1, var2) #define ASSERT_LT_TYPE_U_CHAR(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_U_CHAR,var1, var2) #define ASSERT_LT_TYPE_INT(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_INT,var1, var2) #define ASSERT_LT_TYPE_U_INT(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_U_INT,var1, var2) #define ASSERT_LT_TYPE_L_INT(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_L_INT,var1, var2) #define ASSERT_LT_TYPE_U_L_INT(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_U_L_INT,var1, var2) #define ASSERT_LT_TYPE_SIZE_T(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_SIZE_T,var1, var2) #define ASSERT_LT_TYPE_FLOAT(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_FLOAT,var1, var2) #define ASSERT_LT_TYPE_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_DOUBLE,var1, var2) #define ASSERT_LT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_L_DOUBLE,var1, var2) #define ASSERT_LT_TYPE_STRING(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_STRING,var1, var2) #define ASSERT_LT(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_L_INT,var1, var2) // ************************ end LT ********************** // *********************** begin GT ************************ // ============== EXPECT ============================== #define EXPECT_GT_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_CHAR,var1, var2) #define EXPECT_GT_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_U_CHAR,var1, var2) #define EXPECT_GT_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_INT,var1, var2) #define EXPECT_GT_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_U_INT,var1, var2) #define EXPECT_GT_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_L_INT,var1, var2) #define EXPECT_GT_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_U_L_INT,var1, var2) #define EXPECT_GT_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_SIZE_T,var1, var2) #define EXPECT_GT_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_FLOAT,var1, var2) #define EXPECT_GT_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_DOUBLE,var1, var2) #define EXPECT_GT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_L_DOUBLE,var1, var2) #define EXPECT_GT_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_STRING,var1, var2) #define EXPECT_GT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_L_INT,var1, var2) // ============== ASERT ===================== #define ASSERT_GT_TYPE_CHAR(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_CHAR,var1, var2) #define ASSERT_GT_TYPE_U_CHAR(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_U_CHAR,var1, var2) #define ASSERT_GT_TYPE_INT(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_INT,var1, var2) #define ASSERT_GT_TYPE_U_INT(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_U_INT,var1, var2) #define ASSERT_GT_TYPE_L_INT(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_L_INT,var1, var2) #define ASSERT_GT_TYPE_U_L_INT(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_U_L_INT,var1, var2) #define ASSERT_GT_TYPE_SIZE_T(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_SIZE_T,var1, var2) #define ASSERT_GT_TYPE_FLOAT(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_FLOAT,var1, var2) #define ASSERT_GT_TYPE_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_DOUBLE,var1, var2) #define ASSERT_GT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_L_DOUBLE,var1, var2) #define ASSERT_GT_TYPE_STRING(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_STRING,var1, var2) #define ASSERT_GT(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_L_INT,var1, var2) // ************************ end GT ********************** // *********************** begin LE ************************ // ============== EXPECT ============================== #define EXPECT_LE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_CHAR,var1, var2) #define EXPECT_LE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_U_CHAR,var1, var2) #define EXPECT_LE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_INT,var1, var2) #define EXPECT_LE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_U_INT,var1, var2) #define EXPECT_LE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_L_INT,var1, var2) #define EXPECT_LE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_U_L_INT,var1, var2) #define EXPECT_LE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_SIZE_T,var1, var2) #define EXPECT_LE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_FLOAT,var1, var2) #define EXPECT_LE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_DOUBLE,var1, var2) #define EXPECT_LE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_L_DOUBLE,var1, var2) #define EXPECT_LE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_STRING,var1, var2) #define EXPECT_LE(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_L_INT,var1, var2) // ============== ASERT ===================== #define ASSERT_LE_TYPE_CHAR(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_CHAR,var1, var2) #define ASSERT_LE_TYPE_U_CHAR(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_U_CHAR,var1, var2) #define ASSERT_LE_TYPE_INT(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_INT,var1, var2) #define ASSERT_LE_TYPE_U_INT(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_U_INT,var1, var2) #define ASSERT_LE_TYPE_L_INT(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_L_INT,var1, var2) #define ASSERT_LE_TYPE_U_L_INT(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_U_L_INT,var1, var2) #define ASSERT_LE_TYPE_SIZE_T(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_SIZE_T,var1, var2) #define ASSERT_LE_TYPE_FLOAT(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_FLOAT,var1, var2) #define ASSERT_LE_TYPE_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_DOUBLE,var1, var2) #define ASSERT_LE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_L_DOUBLE,var1, var2) #define ASSERT_LE_TYPE_STRING(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_STRING,var1, var2) #define ASSERT_LE(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_L_INT,var1, var2) // ************************ end LE ********************** // *********************** begin GE ************************ // ============== EXPECT ============================== #define EXPECT_GE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_CHAR,var1, var2) #define EXPECT_GE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_U_CHAR,var1, var2) #define EXPECT_GE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_INT,var1, var2) #define EXPECT_GE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_U_INT,var1, var2) #define EXPECT_GE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_L_INT,var1, var2) #define EXPECT_GE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_U_L_INT,var1, var2) #define EXPECT_GE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_SIZE_T,var1, var2) #define EXPECT_GE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_FLOAT,var1, var2) #define EXPECT_GE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_DOUBLE,var1, var2) #define EXPECT_GE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_L_DOUBLE,var1, var2) #define EXPECT_GE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_STRING,var1, var2) #define EXPECT_GE(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_L_INT,var1, var2) // ============== ASERT ===================== #define ASSERT_GE_TYPE_CHAR(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_CHAR,var1, var2) #define ASSERT_GE_TYPE_U_CHAR(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_U_CHAR,var1, var2) #define ASSERT_GE_TYPE_INT(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_INT,var1, var2) #define ASSERT_GE_TYPE_U_INT(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_U_INT,var1, var2) #define ASSERT_GE_TYPE_L_INT(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_L_INT,var1, var2) #define ASSERT_GE_TYPE_U_L_INT(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_U_L_INT,var1, var2) #define ASSERT_GE_TYPE_SIZE_T(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_SIZE_T,var1, var2) #define ASSERT_GE_TYPE_FLOAT(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_FLOAT,var1, var2) #define ASSERT_GE_TYPE_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_DOUBLE,var1, var2) #define ASSERT_GE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_L_DOUBLE,var1, var2) #define ASSERT_GE_TYPE_STRING(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_STRING,var1, var2) #define ASSERT_GE(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_L_INT,var1, var2) // ************************ end GE ********************** // *********************** begin NE ************************ // ============== EXPECT ============================== #define EXPECT_NE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_CHAR,var1, var2) #define EXPECT_NE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_U_CHAR,var1, var2) #define EXPECT_NE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_INT,var1, var2) #define EXPECT_NE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_U_INT,var1, var2) #define EXPECT_NE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_L_INT,var1, var2) #define EXPECT_NE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_U_L_INT,var1, var2) #define EXPECT_NE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_SIZE_T,var1, var2) #define EXPECT_NE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_FLOAT,var1, var2) #define EXPECT_NE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_DOUBLE,var1, var2) #define EXPECT_NE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_L_DOUBLE,var1, var2) #define EXPECT_NE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_STRING,var1, var2) #define EXPECT_NE(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_L_INT,var1, var2) // ============== ASERT ===================== #define ASSERT_NE_TYPE_CHAR(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_CHAR,var1, var2) #define ASSERT_NE_TYPE_U_CHAR(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_U_CHAR,var1, var2) #define ASSERT_NE_TYPE_INT(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_INT,var1, var2) #define ASSERT_NE_TYPE_U_INT(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_U_INT,var1, var2) #define ASSERT_NE_TYPE_L_INT(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_L_INT,var1, var2) #define ASSERT_NE_TYPE_U_L_INT(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_U_L_INT,var1, var2) #define ASSERT_NE_TYPE_SIZE_T(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_SIZE_T,var1, var2) #define ASSERT_NE_TYPE_FLOAT(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_FLOAT,var1, var2) #define ASSERT_NE_TYPE_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_DOUBLE,var1, var2) #define ASSERT_NE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_L_DOUBLE,var1, var2) #define ASSERT_NE_TYPE_STRING(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_STRING,var1, var2) #define ASSERT_NE(var1, var2) HANDLE_OP_ASSERT_(NE, TYPE_L_INT,var1, var2) // ************************ end NE ********************** /* * ============== bool =================== * bellow old combined EXPECT and ASSERT macros */ #define HANDLE_EXPECT_NOT_EXPECT_ASSERT(expect,not_expect,var1,is_assert) \ do{ \ if(is_parallel_nb==0){\ if(expected_##expect##_f(var1)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ }\ else{\ if(expected_##expect##_f_name(var1, __func__)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ }\ }while(0); // ******************************************************************************************************* /* * new macro HANDEL ASSERT and EXPECT separated */ #define HANDLE_EXPECT_NOT_EXPECT_(expect,not_expect,var1) \ do{ \ if(is_parallel_nb==0){ \ if(expected_##expect##_f(var1)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n\n",__func__); \ } \ } \ else{ \ size_t id_thread=id_of_thread_executed(__func__); \ if(expected_##expect##_f_name(var1, __func__)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s, on thread[%ld]\n\n",__func__,id_thread); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s, on thread[%ld]\n\n",__func__,id_thread); \ } \ } \ }while(0); #define HANDLE_ASSERT_EXPECT_NOT_EXPECT_(expect,not_expect,var1) \ do{ \ if(is_parallel_nb==0){ \ if(expected_##expect##_f(var1)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n\n",__func__); \ return; \ } \ }\ else{\ size_t id_thread=id_of_thread_executed(__func__); \ if(expected_##expect##_f_name(var1, __func__)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s, on thread[%ld]\n\n",__func__,id_thread); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s, on thread[%ld]\n\n",__func__, id_thread); \ return; \ } \ }\ }while(0); // ******************************************************************************************************* #define EXPECT_TRUE(var1) HANDLE_EXPECT_NOT_EXPECT_(true, false, var1) #define EXPECT_FALSE(var1) HANDLE_EXPECT_NOT_EXPECT_(false, true, var1) #define ASSERT_TRUE(var1) HANDLE_ASSERT_EXPECT_NOT_EXPECT_(true, false, var1) #define ASSERT_FALSE(var1) HANDLE_ASSERT_EXPECT_NOT_EXPECT_(false, true, var1) //******************************************************************************** /* #define EXPECT_TRUE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(true, false, var1, 0) #define EXPECT_FALSE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(false, true, var1, 0) #define ASSERT_TRUE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(true, false, var1, 1) #define ASSERT_FALSE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(false, true, var1, 1) */ #define CONCAT(x,y) x ## y #define STRFY(x) # x //#define test_label test #define FTEST_(count, name_f) \ void CONCAT(test_##name_f##____,count)(void); \ __attribute__((constructor)) \ void CONCAT(append_test_##name_f,count)(void){ \ append_func(CONCAT(test_##name_f##____,count),STRFY(name_f test count)); \ } \ void CONCAT(test_##name_f##____,count)(void) #define FTEST__(count, name_f) \ void CONCAT(TEST_##name_f##____,count)(void); \ __attribute__((constructor)) \ void CONCAT(append_test_##name_f,count)(void){ \ append_func(CONCAT(TEST_##name_f##____,count),STRFY (TEST(name_f): test N° count| ) ); \ } \ void CONCAT(TEST_##name_f##____,count)(void) /*#define TEST(name_f)\ FTEST_(__COUNTER__,name_f) */ #define TEST(name_f) \ FTEST__(__COUNTER__,name_f) // HIDE_TEST // to not execute test, it helps to manualy avoid test in code, // instead of comment or #if 0 #endif #define H__TEST__(count, name_f) \ void CONCAT(TEST_##name_f##____,count)(void) \ #define HIDE_TEST(name_f)\ H__TEST__(__COUNTER__,name_f) /* #define ASSERT_TRUE(val)\ if(expected_true_f(val,#val,__func__) == false) {error_print("%s\n\n","Failure"); return;} #define ASSERT_FALSE(val)\ if(expected_false_f(val,#val,__func__) == false) {error_print("%s\n\n","Failure"); return;} */ #endif /* __TEST_C_H__ */ #ifndef __TEST_ARRAY_C_H__ #define __TEST_ARRAY_C_H__ #include "ftest/ftest.h" #ifndef min #define min(a,b) (((a)<(b)) ? (a) : (b)) #endif /* * only expect */ #define HANDLE_OP_EXPECT_ARRAY_NAME(OP,type,var1, sz1, var2, sz2,name_f,msg_call) \ do{ \ if(is_parallel_nb == 0){\ if(expected_array_##OP##_##type(var1, sz1, var2, sz2)){ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ }\ \ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ \ }else { \ if(expected_array_##OP##_name_##type(var1, sz1, var2, sz2, name_f)){ \ if(verb==NORMAL){PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);} \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call);\ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ }while(0); //#define EXPECT_ARRAY_OP_(OP,type,var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(OP,type,var1, sz1, var2, sz2) // ******************************************************************************************************************* /** * new HANDLE_OP_ EXPECT_ARRAY and ASSERT_ARRAY separated */ #define HANDLE_OP_EXPECT_ARRAY_(OP,type,var1, sz1, var2, sz2) \ do{ \ if(is_parallel_nb == 0){\ if(expected_array_##OP##_##type(var1, sz1, var2, sz2)){ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }else { \ if(expected_array_##OP##_name_##type(var1, sz1, var2, sz2, __func__)){ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ } \ }\ }while(0); #define HANDLE_OP_ASSERT_ARRAY_(OP,type,var1, sz1, var2, sz2) \ do{ \ if(is_parallel_nb == 0){\ if(expected_array_##OP##_##type(var1, sz1, var2, sz2)){ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ }else { \ if(expected_array_##OP##_name_##type(var1, sz1, var2, sz2, __func__)){ \ if(verb==NORMAL){ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__);} \ else if(verb==VERB){\ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ PRINT_LOC("test passed: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF("Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ }\ } \ else{ \ PRINT_LOC("Failure\nExpected: (%s) %s (%s) \n\n",#var1,STRFY(OP),#var2); \ for(size_t i=0; i < min(sz1,sz2);++i)\ if (!(COMPARE_N_##type((void*)(var1 + i),(void*)(var2 + i)) OP 0)) {\ char *str_var1 = type##_TO_STR(var1[i]), *str_var2 = type##_TO_STR(var2[i]);\ PRINTF(" Value of %s[%ld]: %s \n Value of %s[%ld]: %s\n\n"\ ,#var1,i, str_var1, #var2,i, str_var2); \ free(str_var1); free(str_var2);\ }\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ return; \ } \ }\ }while(0); // ******************************************************************************************************************** // *********************** begin EQ ************************ // ============== EXPECT_ARRAY ============================== #define EXPECT_ARRAY_EQ_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_U_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_U_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_U_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_SIZE_T,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_FLOAT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_STRING,var1, sz1, var2, sz2) #define EXPECT_ARRAY_EQ(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(EQ, TYPE_L_INT,var1, sz1, var2, sz2) // ============== ASERT ===================== #define ASSERT_ARRAY_EQ_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_U_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_U_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_U_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_SIZE_T,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_FLOAT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_STRING,var1, sz1, var2, sz2) #define ASSERT_ARRAY_EQ(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(EQ, TYPE_L_INT,var1, sz1, var2, sz2) // ************************ end EQ ********************** // *********************** begin LT ************************ // ============== EXPECT_ARRAY ============================== #define EXPECT_ARRAY_LT_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_U_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_U_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_U_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_SIZE_T,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_FLOAT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_STRING,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LT, TYPE_L_INT,var1, sz1, var2, sz2) // ============== ASERT ===================== #define ASSERT_ARRAY_LT_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_U_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_U_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_U_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_SIZE_T,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_FLOAT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_STRING,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LT, TYPE_L_INT,var1, sz1, var2, sz2) // ************************ end LT ********************** // *********************** begin GT ************************ // ============== EXPECT_ARRAY ============================== #define EXPECT_ARRAY_GT_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_U_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_U_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_U_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_SIZE_T,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_FLOAT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_STRING,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GT, TYPE_L_INT,var1, sz1, var2, sz2) // ============== ASERT ===================== #define ASSERT_ARRAY_GT_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_U_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_U_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_U_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_SIZE_T,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_FLOAT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_STRING,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GT, TYPE_L_INT,var1, sz1, var2, sz2) // ************************ end GT ********************** // *********************** begin LE ************************ // ============== EXPECT_ARRAY ============================== #define EXPECT_ARRAY_LE_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_U_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_U_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_U_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_SIZE_T,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_FLOAT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_STRING,var1, sz1, var2, sz2) #define EXPECT_ARRAY_LE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(LE, TYPE_L_INT,var1, sz1, var2, sz2) // ============== ASERT ===================== #define ASSERT_ARRAY_LE_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_U_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_U_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_U_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_SIZE_T,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_FLOAT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_STRING,var1, sz1, var2, sz2) #define ASSERT_ARRAY_LE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(LE, TYPE_L_INT,var1, sz1, var2, sz2) // ************************ end LE ********************** // *********************** begin GE ************************ // ============== EXPECT_ARRAY ============================== #define EXPECT_ARRAY_GE_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_U_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_U_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_U_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_SIZE_T,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_FLOAT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_STRING,var1, sz1, var2, sz2) #define EXPECT_ARRAY_GE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(GE, TYPE_L_INT,var1, sz1, var2, sz2) // ============== ASERT ===================== #define ASSERT_ARRAY_GE_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_U_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_U_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_U_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_SIZE_T,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_FLOAT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_STRING,var1, sz1, var2, sz2) #define ASSERT_ARRAY_GE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(GE, TYPE_L_INT,var1, sz1, var2, sz2) // ************************ end GE ********************** // *********************** begin NE ************************ // ============== EXPECT_ARRAY ============================== #define EXPECT_ARRAY_NE_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_U_CHAR,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_U_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_U_L_INT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_SIZE_T,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_FLOAT,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_STRING,var1, sz1, var2, sz2) #define EXPECT_ARRAY_NE(var1, sz1, var2, sz2) HANDLE_OP_EXPECT_ARRAY_(NE, TYPE_L_INT,var1, sz1, var2, sz2) // ============== ASERT ===================== #define ASSERT_ARRAY_NE_TYPE_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_U_CHAR(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_U_CHAR,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_U_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_U_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_U_L_INT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_U_L_INT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_SIZE_T(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_SIZE_T,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_FLOAT(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_FLOAT,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_L_DOUBLE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_L_DOUBLE,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE_TYPE_STRING(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_STRING,var1, sz1, var2, sz2) #define ASSERT_ARRAY_NE(var1, sz1, var2, sz2) HANDLE_OP_ASSERT_ARRAY_(NE, TYPE_L_INT,var1, sz1, var2, sz2) // ************************ end NE ********************** /* * ============== bool =================== * bellow old combined EXPECT_ARRAY and ASSERT_ARRAY macros */ #define HANDLE_EXPECT_ARRAY_NOT_EXPECT_ARRAY_ASSERT_ARRAY(expect,not_expect,var1,is_assert) \ do{ \ if(is_parallel_nb==0){\ if(expected_array_##expect##_f(var1)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ }\ else{\ if(expected_array_##expect##_f_name(var1, __func__)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n",__func__); \ if(is_assert) return; \ } \ }\ }while(0); // ******************************************************************************************************* /* * new macro HANDEL ASSERT_ARRAY and EXPECT_ARRAY separated */ #define HANDLE_EXPECT_ARRAY_NOT_EXPECT_ARRAY_(expect,not_expect,var1) \ do{ \ if(is_parallel_nb==0){ \ if(expected_array_##expect##_f(var1)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n\n",__func__); \ } \ } \ else{ \ size_t id_thread=id_of_thread_executed(); \ if(expected_array_##expect##_f_name(var1, __func__)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s, on thread[%ld]\n\n",__func__,id_thread); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s, on thread[%ld]\n\n",__func__,id_thread); \ } \ } \ }while(0); #define HANDLE_ASSERT_ARRAY_EXPECT_ARRAY_NOT_EXPECT_ARRAY_(expect,not_expect,var1) \ do{ \ if(is_parallel_nb==0){ \ if(expected_array_##expect##_f(var1)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect); \ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s \n\n",__func__); \ return; \ } \ }\ else{\ size_t id_thread=id_of_thread_executed(); \ if(expected_array_##expect##_f_name(var1, __func__)){ \ PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s, on thread[%ld]\n\n",__func__,id_thread); \ } \ else{ \ PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\ PRINT_HK_C(colors_f[k_RED],tab_hk_f[hk_TR]," 1 test failed from %s, on thread[%ld]\n\n",__func__, id_thread); \ return; \ } \ }\ }while(0); // ******************************************************************************************************* #define EXPECT_ARRAY_TRUE(var1) HANDLE_EXPECT_ARRAY_NOT_EXPECT_ARRAY_(true, false, var1) #define EXPECT_ARRAY_FALSE(var1) HANDLE_EXPECT_ARRAY_NOT_EXPECT_ARRAY_(false, true, var1) #define ASSERT_ARRAY_TRUE(var1) HANDLE_ASSERT_ARRAY_EXPECT_ARRAY_NOT_EXPECT_ARRAY_(true, false, var1) #define ASSERT_ARRAY_FALSE(var1) HANDLE_ASSERT_ARRAY_EXPECT_ARRAY_NOT_EXPECT_ARRAY_(false, true, var1) //******************************************************************************** #endif /* __TEST_ARRAY_C_H__ */ #ifndef __MOCK_C_H__ #define __MOCK_C_H__ //#include "ftest/ftest.h" //#include "tools_t/tools_t.h" #define ININITY_REPS -8 #define INITSTATE -1 #define DONOTHING 0 #define PRE_ID ___line_ /* * list of each variable called * use str_print_current_variables attibute function pointer to record variable * so if STR_PRINT_CUR_VAR is not defined, this list is empty! */ struct list_current_variable{ char *str_current_variables; struct list_current_variable *next; }; /* * list to store info abou mock function */ struct func_mock_info_struct{ long id; bool used; char *str_namefunc; char *str_conditions; char *str_caller; //char *str_current_variables; struct list_current_variable *l_current_var; int expect_call;/* 1 if EXPECT_MOCK_CALL and 0 if WILL_MOCK_CALL */ long call;/* increment when call (try to executed) and 0 if not : init value */ long failed_call;/* increment when condition not fill and 0 if not : init value */ long init_times_left;/* DONOTHING do nothing (pass to -> next), ININITY_REPS every time; INITSTATE init; > 0 execute and decrement */ long times_left;/* DONOTHING do nothing (pass to -> next), ININITY_REPS every time; INITSTATE init; > 0 execute and decrement */ struct func_mock_info_struct *next; }; /* * to list all mock responses of all mock functions in one list */ struct list_base_fmock{ struct func_mock_info_struct *info_mock; struct list_base_fmock *next; }; int parse_count_args_(char *input); void append_fmock_to_listmock(struct func_mock_info_struct **f_mock_list, struct func_mock_info_struct *f_mock); void append_list_base_fmock(struct list_base_fmock **l_fmock, struct func_mock_info_struct *f_mock); void append_variable_current(struct list_current_variable **lcurrent_var, char *current_var); void clear_fmock_info_list(struct func_mock_info_struct **f_mock_list); void clear_list_base_fmock(struct list_base_fmock **l_fmock); void clear_variable_current(struct list_current_variable **lcurrent_var); // if input == functioname___line_NBLINE return functioname, else it return the input //char* extract_name_func_mock(char *input); extern struct func_mock_info_struct *f_mock_glist; extern struct list_base_fmock *g_list_base_fmock; #if 0 int expect_call; /* 1 if EXPECT_MOCK_CALL and 0 if WILL_MOCK_CALL */\ long init_times_left; /* DONOTHING do nothing (pass to -> next), ININITY_REPS every time; INITSTATE init; > 0 execute and decrement */\ long times_left; /* DONOTHING do nothing (pass to -> next), ININITY_REPS every time; INITSTATE init; > 0 execute and decrement */\ #endif #define INIT_MOCK_INFO_IF_NO__(tmp__mock, namefunction, pre_id, id) \ (tmp__mock)->run = NULL;\ (tmp__mock)->call_mock_condition = NULL;\ /*(tmp__mock)->str_print_current_variables = list_mo_ ## namefunction .str_print_current_variables;*/\ ((tmp__mock)->info_mock)->expect_call = -1;\ ((tmp__mock)->info_mock)->used = true;\ ((tmp__mock)->info_mock)->call = 0;\ ((tmp__mock)->info_mock)->failed_call = 0;\ ((tmp__mock)->info_mock)->str_namefunc = malloc(strlen(#namefunction) + 43 + strlen(#pre_id));\ sprintf(((tmp__mock)->info_mock)->str_namefunc,"%s%s%d",#namefunction,#pre_id,id);\ ((tmp__mock)->info_mock)->str_conditions = NULL;\ ((tmp__mock)->info_mock)->str_caller = NULL;\ ((tmp__mock)->info_mock)->l_current_var= NULL;\ ((tmp__mock)->info_mock)->next = NULL;\ /*(tmp__mock)->next = NULL;*/\ append_fmock_to_listmock(&f_mock_glist, (tmp__mock)->info_mock);\ append_list_base_fmock( &g_list_base_fmock ,(tmp__mock)->info_mock); #define INIT_MOCK_INFO_IF_NO_(tmp_new_mock, namefunction, pre_id) \ INIT_MOCK_INFO_IF_NO__(tmp_new_mock, namefunction, pre_id, __LINE__) \ #define MOCK_FUNC(returntype, namefunction, args_prototype_with_parenthesis, args_call_with_parenthesis)\ /*typedef returntype FUNC_type_ ## namefunction args_prototype_with_parenthesis ;*/\ /*typedef args_prototype_with_parenthesis args_ ## namefunction;*/\ struct list_mock_return_ ## namefunction{\ returntype (*run) args_prototype_with_parenthesis;\ int (*call_mock_condition) args_prototype_with_parenthesis ;/* to store condition */\ char* (*str_print_current_variables) args_prototype_with_parenthesis ;/* to store current variables CREATE by macro STR_PRINT_CUR_VAR same arguments as MOCK_FUNC without returntype whoch is always char * */\ struct func_mock_info_struct *info_mock;\ struct list_mock_return_ ## namefunction *next;\ } list_mo_ ## namefunction;\ __attribute__((constructor)) void init_list_m_ ## namefunction(void){\ list_mo_ ## namefunction.info_mock = malloc(sizeof(struct func_mock_info_struct));\ (list_mo_ ## namefunction.info_mock)->used = false;\ (list_mo_ ## namefunction.info_mock)->times_left = INITSTATE;\ (list_mo_ ## namefunction.info_mock)->init_times_left = INITSTATE;\ list_mo_ ## namefunction.str_print_current_variables = NULL;\ list_mo_ ## namefunction.next = NULL;\ }\ \ __attribute__((destructor)) void destruct_list_m_ ## namefunction(void){ \ /*free(list_mo_ ## namefunction.info_mock);*/ \ struct list_mock_return_ ## namefunction *tmp_nn = list_mo_ ## namefunction.next, *ttmp_nn;\ if((list_mo_ ## namefunction.info_mock)->used == false ){\ free(list_mo_ ## namefunction.info_mock);\ }\ while(tmp_nn){\ ttmp_nn = tmp_nn;\ tmp_nn = tmp_nn->next;\ /*free(ttmp_nn->info_mock);*/\ free(ttmp_nn);\ }\ PRINT_DEBUG(" purge list mo_ %s done!\n",#namefunction);\ \ }\ \ returntype namefunction args_prototype_with_parenthesis {\ static size_t count_call_f=0;\ ++count_call_f;\ PRINT_DEBUG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>count call of %s: %ld\n",#namefunction,count_call_f);\ struct list_mock_return_ ## namefunction *tmp_mock = &list_mo_ ## namefunction;\ if( (tmp_mock->info_mock)->times_left == INITSTATE ){\ PRINT_HK_C(colors_f[k_YELLOW],tab_hk_f[hk_TR]," WARNING, %s, no EXPECT_MOCK_CALL or WILL_MOCK_CALL, but called %ld times.\n",#namefunction, count_call_f);\ if(count_call_f==1){\ PRINT_HK_C(colors_f[k_YELLOW],tab_hk_f[hk_TR]," For instance:\n"\ "%s EXPECT_MOCK_CALL(%s,%s,%s,true,1){\n"\ "%s\t %s ret;\n%s \t ...do something with %s;\n"\ "%s\t return ret;\n"\ "%s }\n"\ "%s if call once and accept all args, the same args with WILL_MOCK_CALL \n\n",\ tab_hk_f[hk_TR], #returntype, #namefunction,#args_prototype_with_parenthesis, tab_hk_f[hk_TR],#returntype, \ tab_hk_f[hk_TR], #args_call_with_parenthesis, tab_hk_f[hk_TR], tab_hk_f[hk_TR], tab_hk_f[hk_TR] ); \ /*return (returntype)0;*/ \ INIT_MOCK_INFO_IF_NO_(tmp_mock,namefunction, PRE_ID);\ }/* to have log */\ /*if(list_mo_ ## namefunction.next ) PRINT_ERROR(" %s .next SHOULD BE NULL\n",STRFY(list_mo_ ## namefunction));*/\ }\ while(tmp_mock->next && (tmp_mock->info_mock)->times_left == 0) {tmp_mock = tmp_mock->next ;}\ ++((tmp_mock->info_mock)->call);\ if(tmp_mock->str_print_current_variables){\ append_variable_current(&((tmp_mock->info_mock)->l_current_var), tmp_mock->str_print_current_variables args_call_with_parenthesis);\ }\ else if(count_call_f == 1){\ PRINT_HK_C(colors_f[k_YELLOW],tab_hk_f[hk_TR]," no printer variable function defined, to define it:\n"\ "%s STR_PRINT_CUR_VAR(%s,%s,%s){\n"\ "%s\t char* ret=malloc(256);/*for instance*/;\n"\ "%s\t ... sprintf(ret,...., %s);/*for instance*/ \n"\ "%s\t return ret;\n"\ "%s }\n"\ "%s same prototype as MOCK_FUNC whithout returntype which always char* i\n\n",\ tab_hk_f[hk_TR], #namefunction,#args_prototype_with_parenthesis, #args_call_with_parenthesis, \ tab_hk_f[hk_TR], tab_hk_f[hk_TR], #args_call_with_parenthesis, tab_hk_f[hk_TR], tab_hk_f[hk_TR], tab_hk_f[hk_TR] ); \ }\ /*LOG("condition_func:%d\n", tmp_mock->call_mock_condition args_call_with_parenthesis);*/ /*LOG("%s\n","failure condition");*/\ /*EXPECT_EQ_TYPE_INT(1, tmp_mock->call_mock_condition args_call_with_parenthesis);*/ /*LOG("%s\n","failure condition");*/\ /*if ((tmp_mock->info_mock)->times_left == 0)*/ /*no longer response, default return */ \ /*return (returntype)0;*//* default return */\ if( (tmp_mock->info_mock)->str_caller == NULL){ \ if(count_call_f == 1){\ PRINT_HK_C(colors_f[k_YELLOW],tab_hk_f[hk_TR]," WARNING, no INIT_CALLER_MOCK; you can put it like this: \n"\ "%s TEST(nametest){\n"\ "%s\t INIT_CALLER_MOCK(%s); \n"\ "%s\t %s%s; \n"\ "%s }\n"\ "%s i.e before calling %s in this TEST, to have explicit logs\n",\ tab_hk_f[hk_TR], tab_hk_f[hk_TR], #namefunction, tab_hk_f[hk_TR],#namefunction,#args_call_with_parenthesis, tab_hk_f[hk_TR], tab_hk_f[hk_TR], #namefunction);} \ /*return (returntype)0;*/ \ }\ else if (((tmp_mock->info_mock)->times_left != 0) && ((tmp_mock->info_mock)->times_left != INITSTATE )) {\ size_t len0 = strlen((tmp_mock->info_mock)->str_conditions);\ size_t len1 = strlen("when checking condition call: aa");\ char *msg_call=malloc(len0 + len1 + strlen(__func__)+1);\ sprintf(msg_call,"when checking %s condition call: %s",__func__,(tmp_mock->info_mock)->str_conditions);\ HANDLE_OP_EXPECT_NAME(EQ,TYPE_INT,1, tmp_mock->call_mock_condition args_call_with_parenthesis, (tmp_mock->info_mock)->str_caller, msg_call); /*LOG("%s\n","failure condition");*/\ free(msg_call);\ }\ /*if(0 == tmp_mock->call_mock_condition args_call_with_parenthesis){\ PRINT_LOC("Failure, arguments not expected\ncondition ( %s ) not verified\n\n", (tmp_mock->info_mock)->str_conditions);\ PRINT_HK_C(RED_K,tab_hk_f[hk_TR]," 1 argument check failed from %s \n",__func__); \ }*/\ PRINT_DEBUG(" %*c VALUES: mock function:%s, conditions:%s t_left:%ld, init_left:%ld| args:%s\n",8,'^',(tmp_mock->info_mock)->str_namefunc, (tmp_mock->info_mock)->str_conditions, (tmp_mock->info_mock)->times_left,(tmp_mock->info_mock)->init_times_left, #args_call_with_parenthesis);\ if (((tmp_mock->info_mock)->times_left <= ININITY_REPS) || ((tmp_mock->info_mock)->times_left > 0)){\ --((tmp_mock->info_mock)->times_left);\ PRINT_DEBUG(" %*c VALUES: mock function:%s, conditions:%s t_left:%ld, init_left:%ld| args:%s\n",8,'v',(tmp_mock->info_mock)->str_namefunc, (tmp_mock->info_mock)->str_conditions, (tmp_mock->info_mock)->times_left,(tmp_mock->info_mock)->init_times_left, #args_call_with_parenthesis);\ if(1 == tmp_mock->call_mock_condition args_call_with_parenthesis){\ return tmp_mock->run args_call_with_parenthesis;\ }\ else ++((tmp_mock->info_mock)->failed_call);\ }\ return (returntype)0;/* default return */\ } char* extract_name_func_mock(char *input); /* * used in mock functions to check the conditions */ #define EXPECT_EQ_IN_MOCKF(var1,var2, name_f_mocked)\ do{ \ if((list_mo_ ## name_f_mocked.info_mock)->str_caller) {\ HANDLE_OP_EXPECT_NAME(EQ,TYPE_INT,var1,var2,(list_mo_ ## name_f_mocked.info_mock)->str_caller,"mock test");\ }\ else\ HANDLE_OP_EXPECT_NAME(EQ,TYPE_INT,var1,var2,__func__,"mock test");\ }while(0) /* * to inject the name TEST caller in the mock attribute info, usefull in logs and stats */ #define INIT_CALLER_MOCK(namefunction)/* */\ do{\ struct list_mock_return_ ## namefunction *tmp_mock = &list_mo_ ## namefunction;\ while(tmp_mock){\ (tmp_mock->info_mock)->str_caller=malloc(strlen(__func__)+1);\ strcpy((tmp_mock->info_mock)->str_caller,__func__);\ tmp_mock = tmp_mock->next;\ }\ }while(0); /* * to create/ define str_print_current_variables functions * prototype: char* str_print_current_variables (prototype of mock function) * the args of the macro are the same of MOCK_FUNC without the returntype which is always (char*). * It need to be defined after MOCK_FUNC but need to be before EXPECT_MOCK_CALL or WILL_MOCK_CALL */ #define STR_PRINT_CUR_VAR(namefunction, args_prototype_with_parenthesis, args_call_with_parenthesis)\ char* str_print_variables ## namefunction args_prototype_with_parenthesis;\ __attribute__((constructor)) void create_str_print_variables ## namefunction(){\ list_mo_ ## namefunction .str_print_current_variables = str_print_variables ## namefunction;\ }\ char* str_print_variables ## namefunction args_prototype_with_parenthesis #define FILL_MOCK_INFO(tmp_new_mock, namefunction, condition_on_args_expression , repeat, f_expect_call, pre_id, id, is_init) \ (tmp_new_mock)->run = CONCAT(run_ ## namefunction ## pre_id, id);\ (tmp_new_mock)->call_mock_condition = CONCAT(namefunction ## _cond_, id);\ if(!is_init)\ (tmp_new_mock)->str_print_current_variables = list_mo_ ## namefunction .str_print_current_variables;\ /*(tmp_new_mock)->info_mock = malloc(sizeof(struct func_mock_info_struct));*/\ ((tmp_new_mock)->info_mock)->expect_call = f_expect_call;\ ((tmp_new_mock)->info_mock)->used = true;\ ((tmp_new_mock)->info_mock)->call = 0;\ ((tmp_new_mock)->info_mock)->failed_call = 0;\ ((tmp_new_mock)->info_mock)->init_times_left = repeat;\ ((tmp_new_mock)->info_mock)->times_left = repeat;\ ((tmp_new_mock)->info_mock)->str_namefunc = malloc(strlen(#namefunction) + 43 + strlen(#pre_id));\ sprintf(((tmp_new_mock)->info_mock)->str_namefunc,"%s%s%d",#namefunction,#pre_id,id);\ ((tmp_new_mock)->info_mock)->str_conditions = malloc(strlen(#condition_on_args_expression)+1);\ strcpy(((tmp_new_mock)->info_mock)->str_conditions, #condition_on_args_expression);\ ((tmp_new_mock)->info_mock)->str_caller = NULL;\ ((tmp_new_mock)->info_mock)->l_current_var= NULL;\ ((tmp_new_mock)->info_mock)->next = NULL;\ (tmp_new_mock)->next = NULL;\ append_fmock_to_listmock(&f_mock_glist, (tmp_new_mock)->info_mock); #define ADD_RESPONSE_(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression , repeat, f_expect_call, pre_id, id)\ /*FUNC_type_ ## namefunction CONCAT(run_ ## namefunction ## pre_id , id);*/\ returntype CONCAT(run_ ## namefunction ## pre_id , id) args_prototype_with_parenthesis; \ int CONCAT(namefunction ## _cond_ , id) args_prototype_with_parenthesis {/*LOG("cond:%d\n",condition_on_args_expression);*/ return condition_on_args_expression;}\ __attribute__((constructor)) void CONCAT(append_list_ ## namefunction , id)(void){\ PRINT_DEBUG(" in constructor fmock : func :%s\n",#namefunction);\ struct list_mock_return_ ## namefunction *tmp_mock = &list_mo_ ## namefunction;\ if((tmp_mock->info_mock)->times_left == INITSTATE){/* init state */\ FILL_MOCK_INFO(tmp_mock, namefunction, condition_on_args_expression , repeat, f_expect_call, pre_id, id, true);\ append_list_base_fmock( &g_list_base_fmock ,(tmp_mock->info_mock));\ }\ else{\ while(tmp_mock->next) tmp_mock = tmp_mock->next;\ tmp_mock->next = malloc(sizeof(list_mo_ ## namefunction));\ (tmp_mock->next)->info_mock = malloc(sizeof(struct func_mock_info_struct));\ FILL_MOCK_INFO(tmp_mock->next, namefunction, condition_on_args_expression , repeat, f_expect_call, pre_id, id, false);\ /*(tmp_mock->info_mock)->next = (tmp_mock->next)->info_mock ;*/\ }\ }\ returntype CONCAT(run_ ## namefunction ## pre_id, id) args_prototype_with_parenthesis /* * have to define this below macro to rewrite the right macro identifier (PRE_ID) */ #define ADD_RESPONSE(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression , repeat, f_expect_call, pre_id, id)\ ADD_RESPONSE_(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression , repeat, f_expect_call, pre_id, id)\ #define EXPECT_MOCK_CALL(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression ,repeat) \ ADD_RESPONSE(returntype,namefunction, args_prototype_with_parenthesis, condition_on_args_expression, repeat, 1, PRE_ID, __LINE__) #define WILL_MOCK_CALL(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression ,repeat) \ ADD_RESPONSE(returntype,namefunction, args_prototype_with_parenthesis, condition_on_args_expression, repeat, 0, PRE_ID, __LINE__) #endif /* __MOCK_C_H__ */ /* implementations */ /* IMPLEMENTATION_TOOLS */ #define POW 17 #define MMOD ((1 << (POW)) - 1) #define SUBA 5 #define SUBB 8 #define GEN_TO_STR_N(type,size,format) \ TYPE_STRING type##_TO_STR(type var){ \ char *ret = malloc(size); \ /*int szret = */sprintf(ret,format,var); \ /*ret[szret]='\0'*//*no need , already by default */; \ return ret; \ }\ #define GENERATE_FUNCTION_ALL(type)\ type MAX_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ type mx =(type)array[0];\ for(size_t i = 0; i < size; ++i)\ if(COMPARE_N_##type(&mx,&array[i]) < 0) mx =(type)array[i];\ return mx;}\ \ size_t ARG_MAX_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ size_t i_mx = 0;\ for(size_t i = 0; i < size; ++i)\ if(COMPARE_N_##type(&array[i_mx],&array[i]) < 0) i_mx = i;\ return i_mx;}\ \ type MIN_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ type mn =(type)array[0];\ for(size_t i = 0; i < size; ++i)\ if(COMPARE_N_##type(&mn,&array[i]) > 0) mn =(type)array[i];\ return mn;}\ \ size_t ARG_MIN_ARRAY_##type(const type *array, size_t size){\ if(array == NULL) return 0;\ size_t i_mn = 0;\ for(size_t i = 0; i < size; ++i)\ if(COMPARE_N_##type(&array[i_mn],&array[i]) > 0) i_mn = i;\ return i_mn;}\ \ #define GENERATE_FUNCTION_NUMERIC(type)\ int COMPARE_N_##type(const void *a, const void *b){ \ type diff = 0;\ if((*(type*)a > *(type*)b)){ \ diff =(*(type*)a - *(type*)b) * PRECISION_##type; \ /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\ PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\ free(str_diff); free(str_a); free(str_b);\ */ \ if(diff >= 1) return 1;\ return 0;\ }else{\ diff =(*(type*)b - *(type*)a) * PRECISION_##type; \ /*char *str_diff = type##_TO_STR(diff), *str_a = type##_TO_STR(*(type*)a), *str_b = type##_TO_STR(*(type*)b);\ PRINT_DEBUG_(" diff = %s a=%s b=%s PRECISION : %ld\n",str_diff, str_a, str_b, PRECISION_##type);\ free(str_diff); free(str_a); free(str_b);\ */\ if(diff >= 1) return -1;\ return 0;\ }\ \ /*if (diff <= -1) return -1; \ if (diff >= 1) return 1; \ return 0; \ */\ } \ \ void COPY_ARRAY_##type(type *dst, const type *src, size_t size){ \ for(size_t i = 0; i < size; ++i) dst[i]=src[i]; \ } \ \ #ifndef IMPLEMENTATION_TOOLS #define IMPLEMENTATION_TOOLS()\ \ GEN_TO_STR_N(TYPE_CHAR,2,"%c")\ GEN_TO_STR_N(TYPE_U_CHAR,2,"%c")\ GEN_TO_STR_N(TYPE_INT,22,"%d")\ GEN_TO_STR_N(TYPE_U_INT,22,"%u")\ GEN_TO_STR_N(TYPE_L_INT,22,"%ld")\ GEN_TO_STR_N(TYPE_U_L_INT,22,"%lu")\ GEN_TO_STR_N(TYPE_SIZE_T,22,"%lu")\ GEN_TO_STR_N(TYPE_FLOAT,128,"%.10f")\ GEN_TO_STR_N(TYPE_DOUBLE,256,"%.30lf")\ GEN_TO_STR_N(TYPE_L_DOUBLE,256,"%.30Lf")\ \ TYPE_STRING TYPE_STRING_TO_STR(TYPE_STRING var){\ return var;\ }\ \ \ long int PRECISION_TYPE_CHAR = 1;\ long int PRECISION_TYPE_U_CHAR = 1;\ long int PRECISION_TYPE_INT = 1;\ long int PRECISION_TYPE_U_INT = 1;\ long int PRECISION_TYPE_L_INT = 1;\ long int PRECISION_TYPE_U_L_INT = 1;\ long int PRECISION_TYPE_SIZE_T = 1;\ \ long int PRECISION_TYPE_FLOAT = 100000000;\ long int PRECISION_TYPE_DOUBLE = 100000000000;\ long int PRECISION_TYPE_L_DOUBLE = 100000000000000;\ \ \ \ \ int \ COMPARE_N_TYPE_STRING(const void *a,const void* b)\ {\ char **aa=(char**)a;\ char **bb=(char**)b;\ PRINT_DEBUG_("a=%s, b=%s\n",*aa, *bb);\ return strcmp(*aa,*bb);\ }\ \ void COPY_ARRAY_TYPE_STRING(char** dst, const char** src, size_t size)\ {\ for(size_t i = 0; i < size; ++i) strcpy(dst[i],src[i]);\ }\ \ \ GENERATE_FUNCTION_NUMERIC(TYPE_CHAR)\ GENERATE_FUNCTION_NUMERIC(TYPE_U_CHAR)\ GENERATE_FUNCTION_NUMERIC(TYPE_INT)\ GENERATE_FUNCTION_NUMERIC(TYPE_U_INT)\ GENERATE_FUNCTION_NUMERIC(TYPE_L_INT)\ GENERATE_FUNCTION_NUMERIC(TYPE_U_L_INT)\ GENERATE_FUNCTION_NUMERIC(TYPE_SIZE_T)\ GENERATE_FUNCTION_NUMERIC(TYPE_FLOAT)\ GENERATE_FUNCTION_NUMERIC(TYPE_DOUBLE)\ GENERATE_FUNCTION_NUMERIC(TYPE_L_DOUBLE)\ \ GENERATE_FUNCTION_ALL(TYPE_CHAR)\ GENERATE_FUNCTION_ALL(TYPE_U_CHAR)\ GENERATE_FUNCTION_ALL(TYPE_INT)\ GENERATE_FUNCTION_ALL(TYPE_U_INT)\ GENERATE_FUNCTION_ALL(TYPE_L_INT)\ GENERATE_FUNCTION_ALL(TYPE_U_L_INT)\ GENERATE_FUNCTION_ALL(TYPE_SIZE_T)\ GENERATE_FUNCTION_ALL(TYPE_FLOAT)\ GENERATE_FUNCTION_ALL(TYPE_DOUBLE)\ GENERATE_FUNCTION_ALL(TYPE_L_DOUBLE)\ GENERATE_FUNCTION_ALL(TYPE_STRING)\ \ /* strto_type */\ \ int strto_TYPE_INT(char *str, char **endptr){ \ return (int)strtol(str,endptr,10);\ }\ unsigned int strto_TYPE_U_INT(char *str, char **endptr){ \ return (unsigned int)strtoul(str,endptr,10);\ }\ long int strto_TYPE_L_INT(char *str, char **endptr){\ return strtol(str,endptr,10);\ }\ unsigned long int strto_TYPE_U_L_INT(char *str, char **endptr){\ return strtoul(str,endptr,10);\ }\ size_t strto_TYPE_SIZE_T(char *str, char **endptr){\ return strtoul(str,endptr,10);\ }\ float strto_TYPE_FLOAT(char *str, char **endptr){\ return strtof(str,endptr);\ }\ double strto_TYPE_DOUBLE(char *str, char **endptr){\ return strtod(str,endptr);\ }\ long double strto_TYPE_L_DOUBLE(char *str, char **endptr){\ return strtold(str,endptr);\ }\ \ \ /*\ * time section\ */\ \ double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start){\ /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n", time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\ return (time_stop.tv_sec - time_start.tv_sec) + 1.0e-9 * (time_stop.tv_nsec - time_start.tv_nsec);\ }\ \ double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start){\ /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n", time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\ return 1.0e3 * (time_stop.tv_sec - time_start.tv_sec) + 1.0e-6 * (time_stop.tv_nsec - time_start.tv_nsec);\ }\ \ long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start){\ /*PRINT_DEBUG_("\n\nstop.sec:%ld, start.sec:%ld, stop.nsec:%ld, start.nsec:%ld\n\n", time_stop.tv_sec , time_start.tv_sec, time_stop.tv_nsec , time_start.tv_nsec);*/\ return 1.0e9 * (time_stop.tv_sec - time_start.tv_sec) + (time_stop.tv_nsec - time_start.tv_nsec);\ }\ \ #endif /* IMPLEMENTATION_TOOLS */ #ifndef IMPLEMENTATION_PROGRESS_BAR #define IMPLEMENTATION_PROGRESS_BAR()\ \ static struct winsize w;\ static int initialized = 0;\ \ \ static void set_window_height_for_bar_progress(int height)\ {\ fprintf(stdout, "\n\0337" /* save cursor*/\ "\033[0;%dr" /* set scroll region (this will place the cursor in the top left)*/\ "\0338\033[1A\033[J" /* restore cursor but ensure its inside the scrolling area*/\ , height);\ fflush(stdout);\ }\ \ \ static void init_progress_bar()\ {\ /*ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);*/\ ioctl(1, TIOCGWINSZ, &w);\ set_window_height_for_bar_progress(w.ws_row - 1);\ }\ \ \ static void abort_progress_bar()\ {\ bar_progress_stop();\ exit(0);\ }\ \ \ void bar_progress_start()\ {\ signal(SIGWINCH, init_progress_bar);\ signal(SIGINT, abort_progress_bar);\ /*signal(SIGSEGV, abort_progress_bar);*/\ init_progress_bar();\ initialized = 1;\ bar_progress_step(0);\ }\ \ \ void bar_progress_step_msg(int step_progress, int all_progress, char *msg, char fill_bar, char fill_dot, int colored /*bool */)\ {\ static int cur_round=0;\ char prgss[]="\\|/-";\ int len = strlen(prgss);\ \ if (initialized == 0) {\ fprintf(stderr, "error: bar_progress_step() called before bar_progress_start().\n");\ exit(1);\ }\ \ if (step_progress < 0) {\ step_progress = 0;\ } \ else if (step_progress >= all_progress) {\ step_progress = all_progress -1;\ }\ int size_char_log= strlen(msg) + strlen("(-) Progress: [100a] [aaaa/bbbb] a");\ int width = (w.ws_col - size_char_log);\ /*int j;*/\ /*\ for(int j=0; j< width ; ++j)\ if (j<(int)(width * (step_progress / 100))) bar[j]='=';\ else bar[j]='.';\ bar[width] = 0;\ */\ int status_percent = (step_progress+1) * 100 / all_progress;\ int status_progress = (step_progress+1) * width / all_progress;\ \ char *bar = malloc(status_progress + 1); /*w.ws_col);*/\ char *dot = malloc(width - status_progress +1 ); /*w.ws_col);*/\ \ memset(bar,fill_bar,status_progress); \ \ bar[status_progress]='\0';\ \ memset(dot,fill_dot, width-status_progress);\ dot[width - status_progress]='\0'; \ \ \ if(colored)printf("\e[s\e[%d;0H(%c) "bg_white"Progress: [%3d%%]\e[0m ["bg_green"%s"bg_red"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1, prgss[cur_round], status_percent, bar, dot, msg, step_progress + 1, all_progress);\ else printf("\e[s\e[%d;0H(%c) "bg_gray"Progress: [%3d%%]\e[0m ["bg_white"%s"bg_gray"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1, prgss[cur_round], status_percent, bar, dot, msg, step_progress + 1, all_progress);\ /*fprintf(stdout, "\e[s\e[%d;0H(%c) "bg_green"Progress: [%3d%%]\e[0m ["bg_green"%s"bg_red"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1,prgss[cur_round], status_percent, bar,dot,msg,step_progress,all_progress);*/\ /*fprintf(stdout, "\e[s\e[%d;0H(%c) "bg_green"Progress: [%3d%%]\e[0m ["BG_GREEN"%s"BG_RED"%s\e[0m] %s [%3d/%3d]\e[u", w.ws_row + 1,prgss[cur_round], status_percent, bar,dot,msg,step_progress,all_progress);*/\ /*fprintf(stdout, "\e[s\e[%d;0H(%c) \e[42;30mProgress: [%3d%%]\e[0m [%s%s%s%s\033[0m] %s [%3d/%3d]\e[u", w.ws_row + 1,prgss[cur_round], status_percent,BG_GREEN, bar, BG_RED,dot,msg,step_progress,all_progress);*/\ /*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [\033[42;30m%s\033[41m%s\033[0m]\e[u", w.ws_row + 1, (int) step_progress, bar,dot);*/\ /*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [%s]\e[u", w.ws_row + 1, (int) step_progress, bar);*/\ /*fprintf(stdout, "\e[s\e[%d;0H\e[42;30mProgress: [%3d%%]\e[0m [%s%s]\e[u", w.ws_row + 1, (int) step_progress, bar,dot);*/\ \ fflush(stdout);\ \ if(cur_round 100) {\ step_progress = 100;\ }\ int width = (w.ws_col - 20);\ int j;\ /*\ for(int j=0; j< width ; ++j)\ if (j<(int)(width * (step_progress / 100))) bar[j]='=';\ else bar[j]='.';\ bar[width] = 0;\ */\ int status = (int)(width * (step_progress / 100));\ for(j=0; j< status ; ++j)\ bar[j]='=';\ \ bar[j]='\0';\ for(j=0;j /* * by default display in millisecond */ /* */ #define NANOSECOND (timeunit[0]=='n') #define SECOND (timeunit[0]=='s') #define LOCK(mutex_var) pthread_mutex_lock(&mutex_var); #define UNLOCK(mutex_var) pthread_mutex_unlock(&mutex_var); #define INCREMENT(variable)\ do{\ if(is_parallel_nb){\ LOCK(mut_##variable); \ ++variable;\ UNLOCK(mut_##variable);\ }\ else ++variable;\ }while(0); #define default_ordered 0 #define default_unicolour 0 #define default_removelog 0 //#define default_parallel_nb 1 #define default_parallel_nb_opt 1 #define default_verb NORMAL #define COMPARE_STR_TO_DEFS(defined,in_str)\ /*LOG(" ===================== ======== %s vs %s =========== \n",in_str,#defined);*/\ if(strcmp(in_str, #defined)==0){\ return defined;\ } #define LOG_WRONG(option,arg,msg)\ some_thing_wrong=1;\ help=1;\ printf("incorrect %s option is interpreted as -%c, %s \n\n",arg,#option[0],msg);\ break; #define IF_OPTION_WITH_ARG_NUM(option)\ if(argv[i][0]=='-'){\ j=1;\ while(argv[i][j]=='-') ++j;\ if(argv[i][j] == #option[0]){\ arg=argv[i];\ long ret_num=extract_num_after_equal_symbole_in_string(argv[i]);\ PRINT_DEBUG("option=%s, ret_num = %ld, argv[%d]=%s\n",#option,ret_num,i,argv[i]);\ is_##option = 1;\ if(ret_num > -1)\ option = ret_num;\ else{\ if(i0)\ option = ret_num;\ else{ \ option = default_##option;\ LOG_WRONG(option,arg, "wait for args")\ }\ }\ }\ else{\ option = default_##option;\ LOG_WRONG(option,arg, "wait for args")\ }\ }\ PRINT_DEBUG("option %s activated, its value is %ld\n",#option,option);\ continue;\ }\ }\ #define IF_OPTION_WITH_ARG_STR(option)\ if(argv[i][0]=='-'){\ j=1;\ while(argv[i][j]=='-') ++j;/* to accept multiple -- */\ if(argv[i][j] == #option[0]){\ arg=argv[i];\ char* ret_str=(char*)extract_string_after_equal_symbole_in_string(argv[i]);\ PRINT_DEBUG("option=%s, ret_str = %s, argv[%d]=%s\n",#option,ret_str,i,argv[i]);\ if(ret_str ==NULL || strlen(ret_str)==0){\ if(iname);\ failed_lst = failed_lst->next;\ } #define INCREMENT_EXPECT(expect,name)\ do{\ size_t num_test=extract_num__f(name);\ ++count_## expect ##_test[num_test];\ PRINT_DEBUG("INCREMENT cout_%s_test[%ld] = %ld\n",#expect, num_test,count_## expect ##_test[num_test]); \ }while(0); #define EXPECTED_EXPECT_F(expect/*, not_expect*/) \ \ bool expected_##expect##_f(bool val){ \ if(val == expect) { \ INCREMENT(count_pass_local); /*++count_pass_local*/ \ return true; \ }else { \ INCREMENT(count_fail_local); /*++count_fail_local*/ \ return false; \ } \ } \ bool expected_##expect##_f_name(bool val, const char * name){ \ if(val == expect) { \ INCREMENT_EXPECT(pass,name);\ return true; \ }else { \ INCREMENT_EXPECT(fail,name);\ return false; \ } \ } \ #define EXPECTED_OP_TYPE(OP,type) \ \ bool expected_##OP##_##type(type var1, type var2){ \ if(COMPARE_N_##type(&var1, &var2) OP 0){ \ INCREMENT(count_pass_local); /*++count_pass_local*/ \ return true; \ }else { \ INCREMENT(count_fail_local); /*++count_fail_local*/ \ return false; \ } \ } \ bool expected_##OP##_name_##type(type var1, type var2,const char * name){ \ if(COMPARE_N_##type(&var1, &var2) OP 0){ \ INCREMENT_EXPECT(pass,name);\ return true; \ }else { \ INCREMENT_EXPECT(fail,name);\ return false; \ } \ }\ bool expected_array_##OP##_##type(type *var1, long int sz1, type *var2, long int sz2){ \ if(sz1 OP sz2){\ if(sz1 == sz2){\ size_t count_ = 0;\ for(size_t i=0;inext; \ } \ tmp_failed_l = malloc(sizeof(struct failed_lists)); \ tmp_failed_l->name = malloc(strlen(name_failed)+1); \ strcpy(tmp_failed_l->name, name_failed); \ tmp_failed_l->next = NULL; \ rec_tmp->next = tmp_failed_l; \ \ } \ else{ \ *fn_failed_list = malloc(sizeof(struct failed_lists)); \ (*fn_failed_list)->name = malloc(strlen(name_failed)+1); \ strcpy((*fn_failed_list)->name, name_failed); \ (*fn_failed_list)->next = NULL; \ } \ \ } \ \ /* \ * match the id global (gives by OS) of the thread with the local (the program) id of thread \ */ \ long int id_of_thread_executed(const char * func_call_name){ \ size_t id_from_self = pthread_self(); \ for(long int i=0; i<= parallel_nb; ++i){ \ if(id_thread_self[i] == id_from_self) \ return i; \ } \ /*if(id_thread_self){ \ for(long int i=0; i<= parallel_nb; ++i) \ PRINT_DEBUG(" id_thread_self[%ld] = %ld \n", i, id_thread_self[i]); \ }*/ \ /* no error, when pthread is call in a test, we will not have a match! */ \ PRINT_DEBUG("\n debug [%s]: called by <%s>, id_from_self: %ld\n",__func__, func_call_name,id_from_self); \ return -1; \ } \ \ \ /* \ * format name of TEST(name_f) is: 'TEST_name_f____NUM|', \ * and name attribute is 'TEST(name_f): test N° NUM!' (! at the end is random): \ * we extract NUM here \ * to have hash_table of the count when parallel test! \ */ \ size_t extract_num__f(const char *name_f){ \ size_t len = strlen(name_f); \ size_t val = 0, p = 1; \ for(long i= len-1; i>=0; --i){ \ PRINT_DEBUG(" name_f(%s)[%ld] = %c\n",name_f,i,name_f[i]); \ if(name_f[i]=='|') val = 0; \ if(name_f[i] >= '0' && name_f[i] <= '9'){ \ val += p * (name_f[i]-'0'); \ p *= 10; \ } \ else if( name_f[i] == ' ' || name_f[i] == '_' || name_f[i] == '=' ) break; \ } \ return val; \ } \ /* TEST_funcname___NUM -> TEST(funcname) */ \ char* extract_func_edited_TEST_from_exec_func_name(char* func_name){ \ size_t len=strlen(func_name); \ char *ret_name=malloc(len+1); \ strcpy(ret_name, func_name); \ char *pad="____"; \ size_t len_pad=strlen(pad); \ ret_name[4]='('; \ for(size_t i=5;i= len_db ){ \ char *tmp_bp=malloc(len_bp+1); \ strcpy(tmp_bp,bar_progress); \ tmp_bp[2]='u'; \ bar_progress=tmp_bp; \ bar_progress_has_to_be_freed = 1; \ } \ else{ \ char *tmp_bp=malloc(len_db+1); \ strcpy(tmp_bp,default_bar_progress); \ tmp_bp[2]='u'; \ default_bar_progress=tmp_bp; \ default_bar_progress_has_to_be_freed = 1; \ } \ } \ \ if(gtestlike){ \ for(int i=0; i<=hk_SK; ++i) \ tab_hk_f[i]=g_tab_hk_f[i]; \ } \ \ parallel_nb = parallel_nb_opt; \ is_parallel_nb = is_parallel_nb_opt; \ \ /*if(savelog){ \ f_savelog=fopen(savelog, "w+"); \ }*/ \ } \ \ \ /* ===================================== begin options handle ======================================================= */\ \ void usage(int argc, char **argv){ \ printf("usage: %s [OPTIONS] [] \n\n" \ " or : %s [OPTIONS]=[]\n\n",argv[0],argv[0]); \ printf("OPTIONS\n"); \ printf( "\t -h, --help \n" \ "\t\tprint help, options variables\n\n"); \ printf( "\t -g, --gtestlike \n" \ "\t\tto have gtest hook like!\n\n"); \ printf( "\t -p , --parallel , -p=, --parallel=\n" \ "\t\tby default the program ran in sequantial all test, \n" \ "\t\tif this option is set, the program run tests on NB threads.\n" \ "\t\tEach thread pull up one test out the list of all test not yet executed,\n" \ "\t\tand execute it, until the list is empty \n\n"); \ printf( "\t -t , --time , -t=, --time= \n" \ "\t\tby default unit is millisecons ms, the other of unit are choices are second (or s), and nanosecond (or ns)\n" \ "\t\tex: -t ns or -t=nanosecond or --time=n to set nanosecond unit\n\n"); \ printf( "\t -u , --unicolour\n" \ "\t\tby default, the result is colored, if you choice this option, it prints with default color\n\n"); \ printf( "\t -r , --remove\n" \ "\t\tif the option parallel is choosen the result on each thread is record in separate files,\n" \ "\t\tthis option remove the file logs of each thread after all tests.\n\n"); \ printf( "\t -s , --savelog , -s=file, --savelog=file\n" \ "\t\tthis option save the global ordered result in 'file',\n" \ "\t\t \n\n"); \ \ printf( "\t -n=, ... ,--numtests=,...\n" \ "\t\tthis option allow to execute only the selected numbers of tests (in the order in file test)\n" \ "\t\tex: -n=0,6,3 8 to execute the tests 0,3,6,8 (if the number is less than the count of all tests)\n\n"); \ printf( "\t -l=, ... ,--listests=,...\n" \ "\t\tthis option allow to execute only the selected name of tests. It allows empty name by using '-l=,'\n" \ "\t\tex: -l=name0,,name2 : execute only (if they exist): TEST(name0),TEST(),TEST(name2)\n\n"); \ printf( "\t -b , --bar_progress , -b=BPRGSS, --bar_progress=BPRGSS. Example: -b=\"#_c\"\n" \ "\t\tthis option change progression bar if it is active. The first character (\'#\') fills the bar\n" \ "\t\tthe second char (\'_\') fills the other part of bar. the bar is colored if the 3rd char is \'c\' and not if different.\n" \ "\t\tby default the progress bar is active and the option is -b=\" c\", if need not colored, we can put -b=\" n\" option.\n\n"); \ printf( "\t -z=