diff --git a/src/fmock/fmock.c b/src/fmock/fmock.c index e00ab30..c1cbaa4 100644 --- a/src/fmock/fmock.c +++ b/src/fmock/fmock.c @@ -145,10 +145,17 @@ char * number_call_translate(long nb){ return ret; } +char * strprint_caller_(char *input){ + if(input==NULL) { return "";} + char *called_in=",\t called in "; + char *ret = malloc(strlen(called_in)+strlen(input)+1); + sprintf(ret,"%s%s",called_in,input); + return ret; +} #define PRINT_VAR_CUR(mockinfo)\ do{\ - PRINTF("\n%s list of variables when %s was called, whith condition %s:\n\t\t",HK_EQ,mockinfo->str_namefunc,mockinfo->str_conditions);\ + PRINTF("\n%s list of variables when %s was called, with condition %s:\n\t\t",HK_EQ,mockinfo->str_namefunc,mockinfo->str_conditions);\ size_t cal_cur=0;\ struct list_current_variable *tmp_cur_v = mockinfo->l_current_var;\ while(tmp_cur_v){\ @@ -217,8 +224,10 @@ __attribute__((destructor)) while(tmp_list_fm){ tmp_inf_mock = tmp_list_fm->info_mock; memset(reader,'=',w.ws_col-1); - char *caller = extract_func_edited_TEST_from_exec_func_name(tmp_inf_mock->str_caller); + char *caller=""; + if(tmp_inf_mock->str_caller) caller = extract_func_edited_TEST_from_exec_func_name(tmp_inf_mock->str_caller); size_t len_caller = strlen(caller); + char *nameff=extract_name_func_mock(tmp_inf_mock->str_namefunc); size_t len_nameff=strlen(nameff); char *by_=" called by "; @@ -237,45 +246,28 @@ __attribute__((destructor)) if(0==strncmp(tmp_inf_mock->str_namefunc,nameff, len_nameff)){ if(tmp_inf_mock->expect_call){ int success = !((tmp_inf_mock->init_times_left == tmp_inf_mock->times_left) || (tmp_inf_mock->failed_call)); - // if(tmp_inf_mock->init_times_left == tmp_inf_mock->times_left || tmp_inf_mock->failed_call){} if(tmp_inf_mock->l_current_var){ - PRINTF("%s%s%s %s\t expect %s,\t called %ld times and failed %ld times,\t called by: %s ,\t with condition: %s%s\n" , + PRINTF("%s%s%s %s\t expect %s,\t called %ld times and failed %ld times %s,\t with condition: %s%s\n" , colors_f[!unicolour*(kred - success)],tab_hk_f[hk_FL-success],colors_f[knothing * success],tmp_inf_mock->str_namefunc, number_call_translate(tmp_inf_mock->init_times_left), tmp_inf_mock->call, - tmp_inf_mock->failed_call, tmp_inf_mock->str_caller, tmp_inf_mock->str_conditions, DEFAULT_K); + tmp_inf_mock->failed_call, strprint_caller_(tmp_inf_mock->str_caller), tmp_inf_mock->str_conditions, DEFAULT_K); PRINT_VAR_CUR(tmp_inf_mock); }else{ - PRINTF("%s%s%s %s\t expect %s,\t called %ld times and failed %ld times,\t call by: %s ,\t with condition: %s%s\n" , + PRINTF("%s%s%s %s\t expect %s,\t called %ld times and failed %ld times %s,\t with condition: %s%s\n" , colors_f[!unicolour*(kred - success)],tab_hk_f[hk_FL-success],colors_f[knothing*success],tmp_inf_mock->str_namefunc, number_call_translate(tmp_inf_mock->init_times_left), tmp_inf_mock->call, - tmp_inf_mock->failed_call, tmp_inf_mock->str_caller, tmp_inf_mock->str_conditions , DEFAULT_K); - - /*PRINTF("%s%s %s\t expect %s,\t called %ld times and failed %ld times,\t with condition: %s,\t call by: %s %s\n" , - colors_f[kgreen],HK_TR,tmp_inf_mock->str_namefunc, number_call_translate(tmp_inf_mock->init_times_left), tmp_inf_mock->call, - tmp_inf_mock->failed_call, tmp_inf_mock->str_conditions , tmp_inf_mock->str_caller, DEFAULT_K);*/ + tmp_inf_mock->failed_call, strprint_caller_(tmp_inf_mock->str_caller), tmp_inf_mock->str_conditions , DEFAULT_K); } }else{/* will expect */ int success = !(tmp_inf_mock->failed_call); if(tmp_inf_mock->l_current_var){ - PRINTF("%s%s%s %s\t will %s,\t called %ld times and failed %ld times,\t called by: %s ,\t with condition: %s,%s\n" , + PRINTF("%s%s%s %s\t will %s,\t called %ld times and failed %ld times %s,\t with condition: %s,%s\n" , colors_f[!unicolour*(kred + success)],tab_hk_f[hk_FL-success],colors_f[knothing*success],tmp_inf_mock->str_namefunc, number_call_translate(tmp_inf_mock->init_times_left), tmp_inf_mock->call, - tmp_inf_mock->failed_call, tmp_inf_mock->str_caller, tmp_inf_mock->str_conditions , DEFAULT_K); + tmp_inf_mock->failed_call, strprint_caller_(tmp_inf_mock->str_caller), tmp_inf_mock->str_conditions , DEFAULT_K); PRINT_VAR_CUR(tmp_inf_mock); }else{ - PRINTF("%s%s%s %s\t will %s,\t called %ld times and failed %ld times,\t called by: %s ,\t with condition: %s %s\n" , + PRINTF("%s%s%s %s\t will %s,\t called %ld times and failed %ld times %s,\t with condition: %s %s\n" , colors_f[!unicolour*(kred + success)],tab_hk_f[hk_FL-success],colors_f[knothing*success],tmp_inf_mock->str_namefunc, number_call_translate(tmp_inf_mock->init_times_left), tmp_inf_mock->call, - tmp_inf_mock->failed_call, tmp_inf_mock->str_caller, tmp_inf_mock->str_conditions , DEFAULT_K); - - - /* - if(tmp_inf_mock->failed_call){ - PRINTF("%s%s%s %s\t will %s,\t called %ld times and failed %ld times,\t with condition: %s,\t call by: %s \n" , - colors_f[kred],HK_EQ,DEFAULT_K,tmp_inf_mock->str_namefunc, number_call_translate(tmp_inf_mock->init_times_left), tmp_inf_mock->call, - tmp_inf_mock->failed_call, tmp_inf_mock->str_conditions , tmp_inf_mock->str_caller); - }else{ - PRINTF("%s%s %s\t will %s,\t called %ld times and failed %ld times,\t with condition: %s,\t call by: %s %s\n" , - colors_f[kyellow],HK_TR,tmp_inf_mock->str_namefunc, number_call_translate(tmp_inf_mock->init_times_left), tmp_inf_mock->call, - tmp_inf_mock->failed_call, tmp_inf_mock->str_conditions , tmp_inf_mock->str_caller, DEFAULT_K); - }*/ + tmp_inf_mock->failed_call, strprint_caller_(tmp_inf_mock->str_caller), tmp_inf_mock->str_conditions , DEFAULT_K); } } } diff --git a/src/fmock/fmock.h b/src/fmock/fmock.h index a11d12a..3b7dc0c 100644 --- a/src/fmock/fmock.h +++ b/src/fmock/fmock.h @@ -51,6 +51,9 @@ void append_fmock_to_listmock(struct func_mock_info_struct **f_mock_list, struc 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; @@ -87,7 +90,7 @@ extern struct list_base_fmock *g_list_base_fmock; PRINT_DEBUG(">>>>>>count call of %s: %ld\n",STRFY(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(YELLOW_K,HK_TR," WARNING, no EXPECT or WILL CALL defined for the mock function %s.\n",#namefunction);\ + PRINT_HK_C(YELLOW_K,HK_TR," WARNING, no EXPECT_MOCK_CALL or WILL_MOCK_CALL defined for the mock function %s.\n",#namefunction);\ PRINT_HK_C(YELLOW_K,HK_TR," Can be defined by EXPECT_MOCK_CALL(%s,%s,%s,true,1) if call once and accept all args, the same args with WILL_MOCK_CALL \n",STRFY (returntype), STRFY(namefunction),STRFY (args_prototype_with_parenthesis) ); \ return (returntype)0; \ }\ @@ -100,7 +103,7 @@ extern struct list_base_fmock *g_list_base_fmock; 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){ \ - PRINT_HK_C(YELLOW_K,HK_TR," WARNING, MOCK need to be initialized in TEST env call by INIT_CALLER_MOCK(%s) if need to have stats\n",(tmp_mock->info_mock)->str_namefunc); \ + /*PRINT_HK_C(YELLOW_K,HK_TR," WARNING, the caller (TEST function which call (execute) the mock function %s may be defined in TEST function by INIT_CALLER_MOCK(%s) if need to have stats\n", #namefunction,#namefunction); \ /*return (returntype)0;*/ \ }\ else{\ @@ -134,7 +137,13 @@ 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{ HANDLE_OP_EXPECT_NAME(EQ,TYPE_INT,var1,var2,(list_mo_ ## name_f_mocked.info_mock)->str_caller,"mock test")}while(0) + 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) /* diff --git a/src/ftest/ftest.h b/src/ftest/ftest.h index de4ec09..49b96f1 100644 --- a/src/ftest/ftest.h +++ b/src/ftest/ftest.h @@ -508,6 +508,7 @@ do{ \ //#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) \ @@ -539,40 +540,106 @@ do{ \ }\ }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(GREEN_K,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(RED_K,HK_TR," 1 test failed from %s \n",__func__); \ + } \ + }else { \ + if(expected_##OP##_name_##type(var1, var2, __func__)){ \ + PRINT_HK_C(GREEN_K,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(RED_K,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(GREEN_K,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(RED_K,HK_TR," 1 test failed from %s \n",__func__); \ + return; \ + } \ + }else { \ + if(expected_##OP##_name_##type(var1, var2, __func__)){ \ + PRINT_HK_C(GREEN_K,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(RED_K,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_ASSERT(EQ, TYPE_CHAR,var1, var2, 0) -#define EXPECT_EQ_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_U_CHAR,var1, var2, 0) -#define EXPECT_EQ_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_U_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_L_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_U_L_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_SIZE_T,var1, var2, 0) -#define EXPECT_EQ_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_FLOAT,var1, var2, 0) -#define EXPECT_EQ_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_DOUBLE,var1, var2, 0) -#define EXPECT_EQ_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_L_DOUBLE,var1, var2, 0) -#define EXPECT_EQ_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_STRING,var1, var2, 0) +#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_ASSERT(EQ, TYPE_L_INT,var1, var2, 0) +#define EXPECT_EQ(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_L_INT,var1, var2) // ============== ASERT ===================== -#define ASSERT_EQ_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_CHAR,var1, var2, 1) -#define ASSERT_EQ_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_U_CHAR,var1, var2, 1) -#define ASSERT_EQ_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_U_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_L_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_U_L_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_SIZE_T,var1, var2, 1) -#define ASSERT_EQ_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_FLOAT,var1, var2, 1) -#define ASSERT_EQ_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_DOUBLE,var1, var2, 1) -#define ASSERT_EQ_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_L_DOUBLE,var1, var2, 1) -#define ASSERT_EQ_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_STRING,var1, var2, 1) +#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_EXPECT_ASSERT(EQ, TYPE_L_INT,var1, var2, 1) +#define ASSERT_EQ(var1, var2) HANDLE_OP_ASSERT_(EQ, TYPE_L_INT,var1, var2) // ************************ end EQ ********************** @@ -580,36 +647,36 @@ do{ \ // *********************** begin LT ************************ // ============== EXPECT ============================== -#define EXPECT_LT_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_CHAR,var1, var2, 0) -#define EXPECT_LT_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_U_CHAR,var1, var2, 0) -#define EXPECT_LT_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_INT,var1, var2, 0) -#define EXPECT_LT_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_U_INT,var1, var2, 0) -#define EXPECT_LT_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_L_INT,var1, var2, 0) -#define EXPECT_LT_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_U_L_INT,var1, var2, 0) -#define EXPECT_LT_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_SIZE_T,var1, var2, 0) -#define EXPECT_LT_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_FLOAT,var1, var2, 0) -#define EXPECT_LT_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_DOUBLE,var1, var2, 0) -#define EXPECT_LT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_L_DOUBLE,var1, var2, 0) -#define EXPECT_LT_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_STRING,var1, var2, 0) +#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_ASSERT(LT, TYPE_L_INT,var1, var2, 0) +#define EXPECT_LT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_L_INT,var1, var2) // ============== ASERT ===================== -#define ASSERT_LT_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_CHAR,var1, var2, 1) -#define ASSERT_LT_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_U_CHAR,var1, var2, 1) -#define ASSERT_LT_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_INT,var1, var2, 1) -#define ASSERT_LT_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_U_INT,var1, var2, 1) -#define ASSERT_LT_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_L_INT,var1, var2, 1) -#define ASSERT_LT_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_U_L_INT,var1, var2, 1) -#define ASSERT_LT_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_SIZE_T,var1, var2, 1) -#define ASSERT_LT_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_FLOAT,var1, var2, 1) -#define ASSERT_LT_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_DOUBLE,var1, var2, 1) -#define ASSERT_LT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_L_DOUBLE,var1, var2, 1) -#define ASSERT_LT_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_STRING,var1, var2, 1) +#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_EXPECT_ASSERT(LT, TYPE_L_INT,var1, var2, 1) +#define ASSERT_LT(var1, var2) HANDLE_OP_ASSERT_(LT, TYPE_L_INT,var1, var2) // ************************ end LT ********************** @@ -617,37 +684,37 @@ do{ \ // *********************** begin GT ************************ // ============== EXPECT ============================== -#define EXPECT_GT_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_CHAR,var1, var2, 0) -#define EXPECT_GT_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_U_CHAR,var1, var2, 0) -#define EXPECT_GT_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_INT,var1, var2, 0) -#define EXPECT_GT_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_U_INT,var1, var2, 0) -#define EXPECT_GT_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_L_INT,var1, var2, 0) -#define EXPECT_GT_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_U_L_INT,var1, var2, 0) -#define EXPECT_GT_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_SIZE_T,var1, var2, 0) -#define EXPECT_GT_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_FLOAT,var1, var2, 0) -#define EXPECT_GT_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_DOUBLE,var1, var2, 0) -#define EXPECT_GT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_L_DOUBLE,var1, var2, 0) -#define EXPECT_GT_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_STRING,var1, var2, 0) +#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_ASSERT(GT, TYPE_L_INT,var1, var2, 0) +#define EXPECT_GT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_L_INT,var1, var2) // ============== ASERT ===================== -#define ASSERT_GT_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_CHAR,var1, var2, 1) -#define ASSERT_GT_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_U_CHAR,var1, var2, 1) -#define ASSERT_GT_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_INT,var1, var2, 1) -#define ASSERT_GT_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_U_INT,var1, var2, 1) -#define ASSERT_GT_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_L_INT,var1, var2, 1) -#define ASSERT_GT_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_U_L_INT,var1, var2, 1) -#define ASSERT_GT_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_SIZE_T,var1, var2, 1) -#define ASSERT_GT_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_FLOAT,var1, var2, 1) -#define ASSERT_GT_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_DOUBLE,var1, var2, 1) -#define ASSERT_GT_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_L_DOUBLE,var1, var2, 1) -#define ASSERT_GT_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_STRING,var1, var2, 1) +#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_EXPECT_ASSERT(GT, TYPE_L_INT,var1, var2, 1) +#define ASSERT_GT(var1, var2) HANDLE_OP_ASSERT_(GT, TYPE_L_INT,var1, var2) // ************************ end GT ********************** @@ -655,37 +722,37 @@ do{ \ // *********************** begin LE ************************ // ============== EXPECT ============================== -#define EXPECT_LE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_CHAR,var1, var2, 0) -#define EXPECT_LE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_U_CHAR,var1, var2, 0) -#define EXPECT_LE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_INT,var1, var2, 0) -#define EXPECT_LE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_U_INT,var1, var2, 0) -#define EXPECT_LE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_L_INT,var1, var2, 0) -#define EXPECT_LE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_U_L_INT,var1, var2, 0) -#define EXPECT_LE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_SIZE_T,var1, var2, 0) -#define EXPECT_LE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_FLOAT,var1, var2, 0) -#define EXPECT_LE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_DOUBLE,var1, var2, 0) -#define EXPECT_LE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_L_DOUBLE,var1, var2, 0) -#define EXPECT_LE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_STRING,var1, var2, 0) +#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_ASSERT(LE, TYPE_L_INT,var1, var2, 0) +#define EXPECT_LE(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_L_INT,var1, var2) // ============== ASERT ===================== -#define ASSERT_LE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_CHAR,var1, var2, 1) -#define ASSERT_LE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_U_CHAR,var1, var2, 1) -#define ASSERT_LE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_INT,var1, var2, 1) -#define ASSERT_LE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_U_INT,var1, var2, 1) -#define ASSERT_LE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_L_INT,var1, var2, 1) -#define ASSERT_LE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_U_L_INT,var1, var2, 1) -#define ASSERT_LE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_SIZE_T,var1, var2, 1) -#define ASSERT_LE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_FLOAT,var1, var2, 1) -#define ASSERT_LE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_DOUBLE,var1, var2, 1) -#define ASSERT_LE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_L_DOUBLE,var1, var2, 1) -#define ASSERT_LE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_STRING,var1, var2, 1) +#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_EXPECT_ASSERT(LE, TYPE_L_INT,var1, var2, 1) +#define ASSERT_LE(var1, var2) HANDLE_OP_ASSERT_(LE, TYPE_L_INT,var1, var2) // ************************ end LE ********************** @@ -693,37 +760,37 @@ do{ \ // *********************** begin GE ************************ // ============== EXPECT ============================== -#define EXPECT_GE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_CHAR,var1, var2, 0) -#define EXPECT_GE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_U_CHAR,var1, var2, 0) -#define EXPECT_GE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_INT,var1, var2, 0) -#define EXPECT_GE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_U_INT,var1, var2, 0) -#define EXPECT_GE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_L_INT,var1, var2, 0) -#define EXPECT_GE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_U_L_INT,var1, var2, 0) -#define EXPECT_GE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_SIZE_T,var1, var2, 0) -#define EXPECT_GE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_FLOAT,var1, var2, 0) -#define EXPECT_GE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_DOUBLE,var1, var2, 0) -#define EXPECT_GE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_L_DOUBLE,var1, var2, 0) -#define EXPECT_GE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_STRING,var1, var2, 0) +#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_ASSERT(GE, TYPE_L_INT,var1, var2, 0) +#define EXPECT_GE(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_L_INT,var1, var2) // ============== ASERT ===================== -#define ASSERT_GE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_CHAR,var1, var2, 1) -#define ASSERT_GE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_U_CHAR,var1, var2, 1) -#define ASSERT_GE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_INT,var1, var2, 1) -#define ASSERT_GE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_U_INT,var1, var2, 1) -#define ASSERT_GE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_L_INT,var1, var2, 1) -#define ASSERT_GE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_U_L_INT,var1, var2, 1) -#define ASSERT_GE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_SIZE_T,var1, var2, 1) -#define ASSERT_GE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_FLOAT,var1, var2, 1) -#define ASSERT_GE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_DOUBLE,var1, var2, 1) -#define ASSERT_GE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_L_DOUBLE,var1, var2, 1) -#define ASSERT_GE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_STRING,var1, var2, 1) +#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_EXPECT_ASSERT(GE, TYPE_L_INT,var1, var2, 1) +#define ASSERT_GE(var1, var2) HANDLE_OP_ASSERT_(GE, TYPE_L_INT,var1, var2) // ************************ end GE ********************** @@ -731,43 +798,43 @@ do{ \ // *********************** begin NE ************************ // ============== EXPECT ============================== -#define EXPECT_NE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_CHAR,var1, var2, 0) -#define EXPECT_NE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_U_CHAR,var1, var2, 0) -#define EXPECT_NE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_INT,var1, var2, 0) -#define EXPECT_NE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_U_INT,var1, var2, 0) -#define EXPECT_NE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_L_INT,var1, var2, 0) -#define EXPECT_NE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_U_L_INT,var1, var2, 0) -#define EXPECT_NE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_SIZE_T,var1, var2, 0) -#define EXPECT_NE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_FLOAT,var1, var2, 0) -#define EXPECT_NE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_DOUBLE,var1, var2, 0) -#define EXPECT_NE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_L_DOUBLE,var1, var2, 0) -#define EXPECT_NE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_STRING,var1, var2, 0) +#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_ASSERT(NE, TYPE_L_INT,var1, var2, 0) +#define EXPECT_NE(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_L_INT,var1, var2) // ============== ASERT ===================== -#define ASSERT_NE_TYPE_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_CHAR,var1, var2, 1) -#define ASSERT_NE_TYPE_U_CHAR(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_U_CHAR,var1, var2, 1) -#define ASSERT_NE_TYPE_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_INT,var1, var2, 1) -#define ASSERT_NE_TYPE_U_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_U_INT,var1, var2, 1) -#define ASSERT_NE_TYPE_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_L_INT,var1, var2, 1) -#define ASSERT_NE_TYPE_U_L_INT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_U_L_INT,var1, var2, 1) -#define ASSERT_NE_TYPE_SIZE_T(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_SIZE_T,var1, var2, 1) -#define ASSERT_NE_TYPE_FLOAT(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_FLOAT,var1, var2, 1) -#define ASSERT_NE_TYPE_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_DOUBLE,var1, var2, 1) -#define ASSERT_NE_TYPE_L_DOUBLE(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_L_DOUBLE,var1, var2, 1) -#define ASSERT_NE_TYPE_STRING(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_STRING,var1, var2, 1) +#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_EXPECT_ASSERT(NE, TYPE_L_INT,var1, var2, 1) +#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) \ @@ -794,12 +861,77 @@ do{ }\ }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(GREEN_K,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(RED_K,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(GREEN_K,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(RED_K,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(GREEN_K,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(RED_K,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(GREEN_K,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(RED_K,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 diff --git a/test/is_good.c b/test/is_good.c index 81801b8..6a0adac 100644 --- a/test/is_good.c +++ b/test/is_good.c @@ -175,7 +175,10 @@ TEST(sleep){sleep(1);} MOCK_FUNC(int, f_mock, (), ()) -EXPECT_MOCK_CALL(int,f_mock, (),1, 2) {/*EXPECT_EQ(1,3);*/ EXPECT_EQ_IN_MOCKF(21,21,f_mock); +EXPECT_MOCK_CALL(int,f_mock, (),1, 2) { + EXPECT_EQ_IN_MOCKF(21,21,f_mock); + EXPECT_EQ(1,3); + EXPECT_EQ(4,4); EXPECT_EQ_IN_MOCKF(23,24,f_mock); return 12;} EXPECT_MOCK_CALL(int,f_mock, (),1, 1) { EXPECT_EQ_IN_MOCKF(23,21,f_mock);return 10;} @@ -183,7 +186,7 @@ EXPECT_MOCK_CALL(int,f_mock, (),1==2||2<1, 1) {return 18;} EXPECT_MOCK_CALL(int,f_mock, (),1, INFINITY) {return -18;} TEST(mockf1){ - INIT_CALLER_MOCK(f_mock); + //INIT_CALLER_MOCK(f_mock); for(int i = 0; i<8; ++i){