diff --git a/isgood b/isgood index 318a0fc..9007a8d 100644 Binary files a/isgood and b/isgood differ diff --git a/src/test_t/is_good.c b/src/test_t/is_good.c index 27e7c64..445bad1 100644 --- a/src/test_t/is_good.c +++ b/src/test_t/is_good.c @@ -116,10 +116,17 @@ TEST(){ printf("no test, only print\n"); } +TEST(lessThan){ + long int a=1,b=2; + EXPECT_LT(a,b); + EXPECT_LT(b,a); + +} + int main(){ //run_all_tests(); - run_all_tests_parallel(5); + run_all_tests_parallel(4); //purge_tests(); //run_some_tests(8, 1, 2, 2, 3, 3, 0, 4, 1); diff --git a/src/test_t/test_t.c b/src/test_t/test_t.c index a1fb10e..7180008 100644 --- a/src/test_t/test_t.c +++ b/src/test_t/test_t.c @@ -63,48 +63,6 @@ struct failed_lists{ }; -void append_failed_list(struct failed_lists **fn_failed_list ,const char *name_failed){ - - if(*fn_failed_list){ - - struct failed_lists *tmp_failed_l = *fn_failed_list, *rec_tmp; - - while(tmp_failed_l){ - rec_tmp = tmp_failed_l; - tmp_failed_l = tmp_failed_l->next; - } - tmp_failed_l = malloc(sizeof(struct failed_lists)); - tmp_failed_l->name = malloc(strlen(name_failed)); - strcpy(tmp_failed_l->name, name_failed); - tmp_failed_l->next = NULL; - rec_tmp->next = tmp_failed_l; - - } - else{ - *fn_failed_list = malloc(sizeof(struct failed_lists)); - (*fn_failed_list)->name = malloc(strlen(name_failed)); - strcpy((*fn_failed_list)->name, name_failed); - (*fn_failed_list)->next = NULL; - } - -} - -/* - * print all TESTs failed - */ - -void list_failed_test(struct failed_lists *test_failed){ - struct failed_lists *failed_lst = test_failed; - while(failed_lst){ - PRINT_HK_C(RED_K, HK_FL," %s\n",failed_lst->name); - failed_lst = failed_lst->next; - //if(failed_lst->next) list_failed_test(failed_lst->next); - } - PRINT_HK_C(DEFAULT_K, HK_EQ,"%s\n",""); -} - - - /* * global variables not exported @@ -181,8 +139,41 @@ pthread_mutex_t mut_count_fail_local; * end of the global variables of test_t.c */ +/* + * + */ -size_t id_of_thread_executed(size_t id_from_self){ +void append_failed_list(struct failed_lists **fn_failed_list ,const char *name_failed){ + + if(*fn_failed_list){ + + struct failed_lists *tmp_failed_l = *fn_failed_list, *rec_tmp; + + while(tmp_failed_l){ + rec_tmp = tmp_failed_l; + tmp_failed_l = tmp_failed_l->next; + } + tmp_failed_l = malloc(sizeof(struct failed_lists)); + tmp_failed_l->name = malloc(strlen(name_failed)); + strcpy(tmp_failed_l->name, name_failed); + tmp_failed_l->next = NULL; + rec_tmp->next = tmp_failed_l; + + } + else{ + *fn_failed_list = malloc(sizeof(struct failed_lists)); + (*fn_failed_list)->name = malloc(strlen(name_failed)); + strcpy((*fn_failed_list)->name, name_failed); + (*fn_failed_list)->next = NULL; + } + +} + +/* + * match the id global (gives by OS) of the thread with the local (the program) id of thread + */ +long int id_of_thread_executed(void){ + size_t id_from_self = pthread_self(); for(size_t i=0; iname); + failed_lst = failed_lst->next; + //if(failed_lst->next) list_failed_test(failed_lst->next); + } + }else{ + while(failed_lst){ + PRINT_HK_C(RED_K, HK_FL," %s, on thread[%ld]\n",failed_lst->name,id_thrd); + failed_lst = failed_lst->next; + //if(failed_lst->next) list_failed_test(failed_lst->next); + } + + } + + PRINT_HK_C(DEFAULT_K, HK_EQ,"%s\n",""); +} + + + + + #define INCREMENT_EXPECT(expect,name)\ do{\ size_t num_test=extract_num_test__f(name);\ @@ -252,10 +273,11 @@ EXPECTED_EXPECT_F(true,false) EXPECTED_EXPECT_F(false,true) */ -#define EXPECTED_EQ_TYPE(type) \ + +#define EXPECTED_OP_TYPE(OP,type) \ \ -bool expected_eq_##type(type var1, type var2){ \ - if(COMPARE_N_##type(&var1, &var2) == 0){ \ +bool expected_##OP##_##type(type var1, type var2){ \ + if(COMPARE_N_##type(&var1, &var2) OP 0){ \ INCREMENT(count_pass_local); /*++count_pass_local*/ \ return true; \ }else { \ @@ -263,8 +285,8 @@ bool expected_eq_##type(type var1, type var2){ return false; \ } \ } \ -bool expected_eq_name_##type(type var1, type var2,const char * name){ \ - if(COMPARE_N_##type(&var1, &var2) == 0){ \ +bool expected_##OP##_name_##type(type var1, type var2,const char * name){ \ + if(COMPARE_N_##type(&var1, &var2) OP 0){ \ INCREMENT_EXPECT(pass,name);\ return true; \ }else { \ @@ -273,20 +295,77 @@ bool expected_eq_name_##type(type var1, type var2,const char * name){ } \ } +EXPECTED_OP_TYPE(EQ,TYPE_CHAR) +EXPECTED_OP_TYPE(EQ,TYPE_U_CHAR) +EXPECTED_OP_TYPE(EQ,TYPE_INT) +EXPECTED_OP_TYPE(EQ,TYPE_U_INT) +EXPECTED_OP_TYPE(EQ,TYPE_L_INT) +EXPECTED_OP_TYPE(EQ,TYPE_U_L_INT) +EXPECTED_OP_TYPE(EQ,TYPE_SIZE_T) +EXPECTED_OP_TYPE(EQ,TYPE_FLOAT) +EXPECTED_OP_TYPE(EQ,TYPE_DOUBLE) +EXPECTED_OP_TYPE(EQ,TYPE_L_DOUBLE) +EXPECTED_OP_TYPE(EQ,TYPE_STRING) +EXPECTED_OP_TYPE(LT,TYPE_CHAR) +EXPECTED_OP_TYPE(LT,TYPE_U_CHAR) +EXPECTED_OP_TYPE(LT,TYPE_INT) +EXPECTED_OP_TYPE(LT,TYPE_U_INT) +EXPECTED_OP_TYPE(LT,TYPE_L_INT) +EXPECTED_OP_TYPE(LT,TYPE_U_L_INT) +EXPECTED_OP_TYPE(LT,TYPE_SIZE_T) +EXPECTED_OP_TYPE(LT,TYPE_FLOAT) +EXPECTED_OP_TYPE(LT,TYPE_DOUBLE) +EXPECTED_OP_TYPE(LT,TYPE_L_DOUBLE) +EXPECTED_OP_TYPE(LT,TYPE_STRING) -EXPECTED_EQ_TYPE(TYPE_CHAR) -EXPECTED_EQ_TYPE(TYPE_U_CHAR) -EXPECTED_EQ_TYPE(TYPE_INT) -EXPECTED_EQ_TYPE(TYPE_U_INT) -EXPECTED_EQ_TYPE(TYPE_L_INT) -EXPECTED_EQ_TYPE(TYPE_U_L_INT) -EXPECTED_EQ_TYPE(TYPE_SIZE_T) -EXPECTED_EQ_TYPE(TYPE_FLOAT) -EXPECTED_EQ_TYPE(TYPE_DOUBLE) -EXPECTED_EQ_TYPE(TYPE_L_DOUBLE) -EXPECTED_EQ_TYPE(TYPE_STRING) +EXPECTED_OP_TYPE(GT,TYPE_CHAR) +EXPECTED_OP_TYPE(GT,TYPE_U_CHAR) +EXPECTED_OP_TYPE(GT,TYPE_INT) +EXPECTED_OP_TYPE(GT,TYPE_U_INT) +EXPECTED_OP_TYPE(GT,TYPE_L_INT) +EXPECTED_OP_TYPE(GT,TYPE_U_L_INT) +EXPECTED_OP_TYPE(GT,TYPE_SIZE_T) +EXPECTED_OP_TYPE(GT,TYPE_FLOAT) +EXPECTED_OP_TYPE(GT,TYPE_DOUBLE) +EXPECTED_OP_TYPE(GT,TYPE_L_DOUBLE) +EXPECTED_OP_TYPE(GT,TYPE_STRING) +EXPECTED_OP_TYPE(LE,TYPE_CHAR) +EXPECTED_OP_TYPE(LE,TYPE_U_CHAR) +EXPECTED_OP_TYPE(LE,TYPE_INT) +EXPECTED_OP_TYPE(LE,TYPE_U_INT) +EXPECTED_OP_TYPE(LE,TYPE_L_INT) +EXPECTED_OP_TYPE(LE,TYPE_U_L_INT) +EXPECTED_OP_TYPE(LE,TYPE_SIZE_T) +EXPECTED_OP_TYPE(LE,TYPE_FLOAT) +EXPECTED_OP_TYPE(LE,TYPE_DOUBLE) +EXPECTED_OP_TYPE(LE,TYPE_L_DOUBLE) +EXPECTED_OP_TYPE(LE,TYPE_STRING) + +EXPECTED_OP_TYPE(GE,TYPE_CHAR) +EXPECTED_OP_TYPE(GE,TYPE_U_CHAR) +EXPECTED_OP_TYPE(GE,TYPE_INT) +EXPECTED_OP_TYPE(GE,TYPE_U_INT) +EXPECTED_OP_TYPE(GE,TYPE_L_INT) +EXPECTED_OP_TYPE(GE,TYPE_U_L_INT) +EXPECTED_OP_TYPE(GE,TYPE_SIZE_T) +EXPECTED_OP_TYPE(GE,TYPE_FLOAT) +EXPECTED_OP_TYPE(GE,TYPE_DOUBLE) +EXPECTED_OP_TYPE(GE,TYPE_L_DOUBLE) +EXPECTED_OP_TYPE(GE,TYPE_STRING) + +EXPECTED_OP_TYPE(NE,TYPE_CHAR) +EXPECTED_OP_TYPE(NE,TYPE_U_CHAR) +EXPECTED_OP_TYPE(NE,TYPE_INT) +EXPECTED_OP_TYPE(NE,TYPE_U_INT) +EXPECTED_OP_TYPE(NE,TYPE_L_INT) +EXPECTED_OP_TYPE(NE,TYPE_U_L_INT) +EXPECTED_OP_TYPE(NE,TYPE_SIZE_T) +EXPECTED_OP_TYPE(NE,TYPE_FLOAT) +EXPECTED_OP_TYPE(NE,TYPE_DOUBLE) +EXPECTED_OP_TYPE(NE,TYPE_L_DOUBLE) +EXPECTED_OP_TYPE(NE,TYPE_STRING) void @@ -361,6 +440,7 @@ stat_end_run(size_t ntst, struct timespec start_t){ if(failed_l != NULL){ PRINT_HK_C(RED_K, HK_FL," %lu tests, listed below:\n",count_fail_global); list_failed_test(failed_l); + PRINT_HK_C("","","\n%ld FAILED TESTS \n",count_fail_global); } } bool is_in_array(size_t *array, size_t sz, size_t num){ @@ -543,8 +623,6 @@ void head_all_parallel_run(struct timespec *start_t){ void head_parallel_run(struct timespec *start_t, size_t id_thrd){ clock_gettime(CLOCK_REALTIME, start_t); PRINT_HK_C(GREEN_K, HK_EQ," Running tests on thread[%ld] ========== ==threadID== %ld \n", id_thrd,pthread_self()); - count_pass_thread[id_thrd] = 0; - count_fail_thread[id_thrd] = 0; } /* @@ -558,9 +636,9 @@ stat_end_parallel_run(size_t ntst, struct timespec start_t, size_t id_thrd){ else if(NANOSECOND) PRINT_HK_C(GREEN_K, HK_EQ," %lu tests ran on thread[%ld]. (%ld ns total)\n",ntst, id_thrd, diff_timespec_nanoseconds(end_t, start_t)); else PRINT_HK_C(GREEN_K, HK_EQ," %lu tests ran on thread[%ld]. (%lf ms total)\n",ntst, id_thrd, diff_timespec_milliseconds(end_t, start_t)); - PRINT_HK_C(GREEN_K, HK_PS," %lu tests\n", count_pass_test[id_thrd]); + PRINT_HK_C(GREEN_K, HK_PS," %lu tests passed on thread[%ld]\n", count_pass_thread[id_thrd], id_thrd); if(thread_test_failed_l[id_thrd] != NULL){ - PRINT_HK_C(RED_K, HK_FL," %lu tests, listed below:\n",count_fail_test[id_thrd]); + PRINT_HK_C(RED_K, HK_FL," %lu tests failed on thread[%ld], listed below:\n",count_fail_thread[id_thrd],id_thrd); list_failed_test(thread_test_failed_l[id_thrd]); } } @@ -582,6 +660,7 @@ stat_end_all_parallel_run(size_t ntst, struct timespec start_t){ if(failed_l != NULL){ PRINT_HK_C(RED_K, HK_FL," %lu tests, listed below:\n",count_fail_global); list_failed_test(failed_l); + PRINT_HK_C("","","\n%ld FAILED TESTS \n",count_fail_global); } } @@ -604,7 +683,7 @@ void end_execute_func_parallel(char *fun_ame, struct timespec start_t, size_t id if(count_fail_test[num_test]){ INCREMENT(count_fail_global); /*++count_fail_global*/ append_failed_list(&thread_test_failed_l[id_thrd], fun_ame); - ++count_fail_thread[id_thrd]; + ++(count_fail_thread[id_thrd]); LOCK(mut_global_list_fail); append_failed_list(&failed_l, fun_ame); UNLOCK(mut_global_list_fail); @@ -613,7 +692,7 @@ void end_execute_func_parallel(char *fun_ame, struct timespec start_t, size_t id } else { - ++count_pass_thread[id_thrd]; + ++(count_pass_thread[id_thrd]); INCREMENT(count_pass_global); /*++count_pass_global*/ PRINT_TIMESTAMP_STAT_PARALLEL(GREEN_K); } @@ -674,6 +753,8 @@ init_parallel_test_() for(size_t i=0; i +#define LE <= +#define GE >= +#define NE != + +#define DESCRIPTION_EQ "equality" +#define DESCRIPTION_LT "less than" +#define DESCRIPTION_GT "greate than" +#define DESCRIPTION_LE "less than or equality" +#define DESCRIPTION_GE "greate than or equality" +#define DESCRIPTION_NE "inequality" + /* // F_OUT file (stream) to log #ifndef F_OUT @@ -59,8 +76,6 @@ #endif #endif -#define LOCK(mutex_var) pthread_mutex_lock(&mutex_var); -#define UNLOCK(mutex_var) pthread_mutex_unlock(&mutex_var); /* @@ -103,84 +118,383 @@ 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_EQ_TYPE_FUNC(type)\ - bool expected_eq_##type(type var1, type var2);\ - bool expected_eq_name_##type(type var1, type var2, 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 ************************ + */ -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_CHAR) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_U_CHAR) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_INT) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_U_INT) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_L_INT) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_U_L_INT) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_SIZE_T) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_FLOAT) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_DOUBLE) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_L_DOUBLE) -GEN_EXPECTED_EQ_TYPE_FUNC(TYPE_STRING) /** * is_assert : 0 for EXPECT and 1 for ASSERT */ -#define HANDLE_EXPECT_ASSERT(type,var1,var2,is_assert) \ +#define HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert) \ do{ \ - if(is_parallel==0){\ - if(expected_eq_##type(var1, var2)){ \ + if(is_parallel == 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 equality of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + /*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__); \ if(is_assert) return; \ } \ }else { \ - if(expected_eq_name_##type(var1, var2, __func__)){ \ + 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 equality of these values:\n %s\n\tWhich is: %s\n %s\n\tWhich is: %s\n\n"\ - ,#var1, type##_TO_STR(var1), #var2, type##_TO_STR(var2)); \ + /*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__); \ if(is_assert) return; \ } \ }\ }while(0); +// *********************** begin EQ ************************ +// ============== EXPECT ============================== -// ============== 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_EXPECT_ASSERT(TYPE_CHAR,var1, var2, 0) -#define EXPECT_EQ_TYPE_U_CHAR(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_U_CHAR,var1, var2, 0) -#define EXPECT_EQ_TYPE_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_U_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_U_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_L_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_L_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_U_L_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_U_L_INT,var1, var2, 0) -#define EXPECT_EQ_TYPE_SIZE_T(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_SIZE_T,var1, var2, 0) -#define EXPECT_EQ_TYPE_FLOAT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_FLOAT,var1, var2, 0) -#define EXPECT_EQ_TYPE_DOUBLE(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_DOUBLE,var1, var2, 0) -#define EXPECT_EQ_TYPE_L_DOUBLE(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_L_DOUBLE,var1, var2, 0) -#define EXPECT_EQ_TYPE_STRING(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_STRING,var1, var2, 0) - -#define EXPECT_EQ(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_L_INT,var1, var2, 0) +#define EXPECT_EQ(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_L_INT,var1, var2, 0) // ============== ASERT ===================== -#define ASSERT_EQ_TYPE_CHAR(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_CHAR,var1, var2, 1) -#define ASSERT_EQ_TYPE_U_CHAR(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_U_CHAR,var1, var2, 1) -#define ASSERT_EQ_TYPE_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_U_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_U_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_L_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_L_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_U_L_INT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_U_L_INT,var1, var2, 1) -#define ASSERT_EQ_TYPE_SIZE_T(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_SIZE_T,var1, var2, 1) -#define ASSERT_EQ_TYPE_FLOAT(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_FLOAT,var1, var2, 1) -#define ASSERT_EQ_TYPE_DOUBLE(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_DOUBLE,var1, var2, 1) -#define ASSERT_EQ_TYPE_L_DOUBLE(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_L_DOUBLE,var1, var2, 1) -#define ASSERT_EQ_TYPE_STRING(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_STRING,var1, var2, 1) +#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(var1, var2) HANDLE_EXPECT_ASSERT(TYPE_L_INT,var1, var2, 1) +#define ASSERT_EQ(var1, var2) HANDLE_OP_EXPECT_ASSERT(EQ, TYPE_L_INT,var1, var2, 1) + +// ************************ end EQ ********************** + + +// *********************** 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_L_INT,var1, var2, 0) + + + +// ============== 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(LT, TYPE_L_INT,var1, var2, 1) + +// ************************ end LT ********************** + + +// *********************** 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_L_INT,var1, var2, 0) + + + +// ============== 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(GT, TYPE_L_INT,var1, var2, 1) + +// ************************ end GT ********************** + + +// *********************** 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_L_INT,var1, var2, 0) + + + +// ============== 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(LE, TYPE_L_INT,var1, var2, 1) + +// ************************ end LE ********************** + + +// *********************** 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_L_INT,var1, var2, 0) + + + +// ============== 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(GE, TYPE_L_INT,var1, var2, 1) + +// ************************ end GE ********************** + + +// *********************** 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_L_INT,var1, var2, 0) + + + +// ============== 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(var1, var2) HANDLE_OP_EXPECT_ASSERT(NE, TYPE_L_INT,var1, var2, 1) + +// ************************ end NE ********************** /* * ============== bool ===================