reorganizing the repository
This commit is contained in:
@@ -0,0 +1,30 @@
|
||||
#ifndef __BAR_PROGRESS_H__
|
||||
#define __BAR_PROGRESS_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
//#include <unistd.h>
|
||||
#include <signal.h>
|
||||
#include <sys/ioctl.h>
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* 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);
|
||||
|
||||
#endif /* __BAR_PROGRESS_H */
|
||||
@@ -0,0 +1,286 @@
|
||||
#ifndef __MOCK_C_H__
|
||||
#define __MOCK_C_H__
|
||||
|
||||
#include "ftest/ftest.h"
|
||||
#include "tools_t/tools_t.h"
|
||||
|
||||
#define INFINITY -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;
|
||||
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), INFINITY every time; INITSTATE init; > 0 execute and decrement */
|
||||
long times_left;/* DONOTHING do nothing (pass to -> next), INFINITY 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);
|
||||
|
||||
// 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), INFINITY every time; INITSTATE init; > 0 execute and decrement */\
|
||||
long times_left; /* DONOTHING do nothing (pass to -> next), INFINITY 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)->call = 0;\
|
||||
((tmp__mock)->info_mock)->failed_call = 0;\
|
||||
((tmp__mock)->info_mock)->str_namefunc = malloc(strlen(#namefunction) + 32 + 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)->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;\
|
||||
}\
|
||||
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__));\
|
||||
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 <= INFINITY) || ((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__));\
|
||||
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)->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) + 32 + 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));\
|
||||
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){\
|
||||
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__ */
|
||||
@@ -0,0 +1,803 @@
|
||||
#ifndef __TEST_C_H__
|
||||
#define __TEST_C_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdarg.h>
|
||||
//#include <time.h>
|
||||
#include <pthread.h>
|
||||
//#include <unistd.h>
|
||||
#include <sys/ioctl.h> /* to have size of screen, for progress bar */
|
||||
|
||||
#include "tools_t/tools_t.h"
|
||||
#include "bar_progress/bar_progress.h"
|
||||
|
||||
#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 !=
|
||||
|
||||
|
||||
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();\
|
||||
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{\
|
||||
if(id_thread >= 0){\
|
||||
fprintf(f_ou_th[id_thread], "%s",buf);\
|
||||
fflush(f_ou_th[id_thread]);\
|
||||
}\
|
||||
else {\
|
||||
fprintf(F_OUT, "%s",buf);\
|
||||
}\
|
||||
}\
|
||||
} \
|
||||
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;
|
||||
|
||||
long int id_of_thread_executed(void);
|
||||
|
||||
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);
|
||||
|
||||
|
||||
/*
|
||||
* ***** 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 HANDLE_OP_EXPECT_NAME(OP,type,var1,var2,name_f,msg_call) \
|
||||
do{ \
|
||||
if(is_parallel_nb == 0){\
|
||||
if(expected_##OP##_##type(var1, var2)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call); \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 %s passed %s \n\n",name_f,msg_call); \
|
||||
/*PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed %s \n\n",name_f);*/ \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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 HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert) \
|
||||
do{ \
|
||||
if(is_parallel_nb == 0){\
|
||||
if(expected_##OP##_##type(var1, var2)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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__)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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__)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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__)){ \
|
||||
PRINT_HK_C(colors_f[k_GREEN],tab_hk_f[hk_TR]," 1 test passed from %s \n\n",__func__); \
|
||||
} \
|
||||
else{ \
|
||||
/*PRINT_LOC("Failure\nExpected %s of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\
|
||||
,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1), #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, type##_TO_STR(var1), #var2, type##_TO_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(); \
|
||||
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(); \
|
||||
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)
|
||||
|
||||
/*
|
||||
#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__ */
|
||||
@@ -0,0 +1,127 @@
|
||||
#ifndef __TOOLS_T_C_H__
|
||||
#define __TOOLS_T_C_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdbool.h>
|
||||
#include <time.h>
|
||||
|
||||
|
||||
// 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);
|
||||
*/
|
||||
|
||||
void gotoxy(int x, int y);
|
||||
//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 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)
|
||||
|
||||
|
||||
/*
|
||||
* 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__*/
|
||||
|
||||
Reference in New Issue
Block a user