From f356445dec9b59680cb5b1f712cb571f2df8fa73 Mon Sep 17 00:00:00 2001 From: fanasina Date: Sun, 1 Oct 2023 00:22:40 +0200 Subject: [PATCH] debug mock, add list current call var if STR_PRINT_CUR_VAR is set for the mock function --- .gitignore | 2 +- src/fmock/fmock.c | 136 ++++++++++++++++++++++++++++++++++++++-------- src/fmock/fmock.h | 84 +++++++++++++++------------- src/ftest/ftest.c | 53 +++++++++++++++++- src/ftest/ftest.h | 16 +++++- test/is_good.c | 8 +++ 6 files changed, 232 insertions(+), 67 deletions(-) diff --git a/.gitignore b/.gitignore index 86b2fd8..2a5808d 100755 --- a/.gitignore +++ b/.gitignore @@ -5,4 +5,4 @@ log* */**.o */**/**.o launch_* - +eEcomp diff --git a/src/fmock/fmock.c b/src/fmock/fmock.c index 111c183..585003a 100644 --- a/src/fmock/fmock.c +++ b/src/fmock/fmock.c @@ -62,6 +62,28 @@ void append_list_base_fmock(struct list_base_fmock **l_fmock, struct func_mock_i struct func_mock_info_struct *f_mock_glist; pthread_mutex_t mut_f_mock_glist; +void append_variable_current(struct list_current_variable **lcurrent_var, char *current_var){ + if(*lcurrent_var){ + PRINT_DEBUG("----- l_current_var not NULL, content: %s have to add %s\n",(*lcurrent_var)->str_current_variables, current_var); + struct list_current_variable *tmp_lcv = *lcurrent_var; + while(tmp_lcv->next) tmp_lcv = tmp_lcv->next; + tmp_lcv->next = malloc(sizeof(struct list_current_variable)); + //(tmp_lcv->next)->str_current_variables = malloc(strlen(current_var)); + //strcpy((tmp_lcv->next)->str_current_variables,current_var); + (tmp_lcv->next)->str_current_variables = current_var; + (tmp_lcv->next)->next= NULL; + + } + else{ + PRINTF("-- lcurrent_var NULL\n"); + *lcurrent_var = malloc(sizeof(struct list_current_variable)); + //(*lcurrent_var)->str_current_variables = malloc(strlen(current_var)); + //strcpy((*lcurrent_var)->str_current_variables,current_var); + (*lcurrent_var)->str_current_variables = current_var; + (*lcurrent_var)->next = NULL; + } +} + void append_fmock_to_listmock(struct func_mock_info_struct **f_mock_list, struct func_mock_info_struct *f_mock){ INCREMENT_(count_f_mock_wished); if(f_mock->expect_call) { @@ -80,11 +102,17 @@ void append_fmock_to_listmock(struct func_mock_info_struct **f_mock_list, struc } + + +#define SSTRFY(x) STRFY(x) + char* extract_name_func_mock(char *input){ char * ret=malloc(strlen(input)); strcpy(ret,input); - for(size_t i=0; i0) sprintf(ret,"%ld",nb); - else if(nb == 0 ) sprintf(ret,"zero"); - else if(nb==INFINITY) sprintf(ret,"INFINITY"); - else sprintf(ret,"negative"); + if(nb>1) sprintf(ret," to be called %ld times",nb); + else if(nb == 1) sprintf(ret," to be called once"); + else if(nb == 0 ) sprintf(ret," not to be executed"); + else if(nb==INFINITY) sprintf(ret," to be called forever"); + else sprintf(ret," nothing! it's negative:%ld", nb); return ret; } +#define PRINT_VAR_CUR(mockinfo)\ + do{\ + PRINTF("\n\tlist of variables when %s was called:\n\t\t",mockinfo->str_namefunc);\ + size_t cal_cur=0;\ + struct list_current_variable *tmp_cur_v = mockinfo->l_current_var;\ + while(tmp_cur_v){\ + PRINTF(" call : %ld : variables : %s \n\t\t",++cal_cur, tmp_cur_v->str_current_variables);\ + tmp_cur_v = tmp_cur_v->next;\ + }\ + PRINTF("\n");\ + }while(0); + + + __attribute__((destructor)) void check_mock_excpected(){ - //int kdefault=0, kgreen=1, kred=2, kyellow=3, kblue=4, knothing=5; + //int kdefault=0, kgreen=1, kred=2, kyellow=3, kblue=4, knothing; if(unicolour) { - kgreen=5; kred=5; kyellow=5; kblue=5; + kgreen=knothing; kred=knothing; kyellow=knothing; kblue=knothing; + //for(int i=0; i< Dknothing;++i) strcpy(colors_f[i]," "); } struct winsize w; @@ -143,50 +189,93 @@ __attribute__((destructor)) tfree=tmock; PRINT_DEBUG("**** STAT mock function:%s, conditions:%s t_left:%ld, init_left:%ld, failed_call:%ld\n",tmock->str_namefunc, tmock->str_conditions, tmock->times_left,tmock->init_times_left, tmock->failed_call); if((tmock->expect_call) && (tmock->init_times_left == tmock->times_left) || (tmock->failed_call)){ - PRINTF("%s%s %s %s expect to be called with condition %s, %s times, it was called %ld times and failed %ld times \n",colors_f[kred],HK_TR,tmock->str_namefunc,DEFAULT_K, tmock->str_conditions, + if(tmock->l_current_var){ + PRINTF("%s%s %s%s %s: expect %s, it was called %ld times and failed %ld times, with condition %s\n",colors_f[kred],HK_TR,colors_f[kyellow],tmock->str_namefunc,DEFAULT_K, number_call_translate(tmock->init_times_left), tmock->call/*tmock->failed_call + (tmock->init_times_left - tmock->times_left)*/, - tmock->failed_call ); + tmock->failed_call, + tmock->str_conditions + ); + PRINT_VAR_CUR(tmock); + } + else + PRINTF("%s%s %s%s %s: expect %s, it was called %ld times and failed %ld times, with condition %s \n",colors_f[kred],HK_TR,colors_f[kyellow],tmock->str_namefunc,DEFAULT_K, + number_call_translate(tmock->init_times_left), + tmock->call/*tmock->failed_call + (tmock->init_times_left - tmock->times_left)*/, + tmock->failed_call, + tmock->str_conditions + ); } tmock=tmock->next; //free(tfree); } - PRINTF("\n%s%s STAT MOCK : there are %ld mock functions, %ld wished response, %ld expected response, which are:\n\n",colors_f[kgreen],HK_EQ,count_f_mock, count_f_mock_wished, count_expect_mock); + PRINTF("\n%s%s STAT MOCK : there are %ld mock functions, %ld wished responses, %ld expected responses, which are:\n\n",colors_f[kgreen],HK_EQ,count_f_mock, count_f_mock_wished, count_expect_mock); struct list_base_fmock *tmp_list_fm = g_list_base_fmock; struct func_mock_info_struct *tmp_inf_mock; /* list each fmock an each calls */ while(tmp_list_fm){ tmp_inf_mock = tmp_list_fm->info_mock; - memset(reader,'=',w.ws_col-1); + memset(reader,'=',w.ws_col-1); + char *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); - size_t bg_rd=(w.ws_col - len_nameff)/2; + char *by_=" called by "; + size_t len_by_=strlen(by_); + size_t bg_rd=(w.ws_col - len_nameff - len_caller - len_by_)/2; for(size_t i=0; istr_namefunc,nameff, len_nameff)){ if(tmp_inf_mock->expect_call){ - if(tmp_inf_mock->init_times_left == tmp_inf_mock->times_left || tmp_inf_mock->failed_call){ - PRINTF("%s%s%s %s\t expect be call %s times,\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); + 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" , + colors_f[!unicolour*(kred - success)],tab_hk_f[hk_EQ+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); + PRINT_VAR_CUR(tmp_inf_mock); }else{ - PRINTF("%s%s %s\t expect be call %s times,\t called %ld times and failed %ld times,\t with condition: %s,\t call by: %s %s\n" , + 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" , + colors_f[!unicolour*(kred - success)],tab_hk_f[hk_EQ+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, tmp_inf_mock->str_conditions , tmp_inf_mock->str_caller, DEFAULT_K);*/ } - }else{ + }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" , + colors_f[!unicolour*(kred + success)],tab_hk_f[hk_EQ+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); + 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" , + colors_f[!unicolour*(kred + success)],tab_hk_f[hk_EQ+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 be call %s times,\t called %ld times and failed %ld times,\t with condition: %s,\t call by: %s \n" , + 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 be call %s times,\t called %ld times and failed %ld times,\t with condition: %s,\t call by: %s %s\n" , + 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); + }*/ } } } @@ -194,7 +283,7 @@ __attribute__((destructor)) } tmp_list_fm = tmp_list_fm->next; } - + PRINT_DEBUG("%s\n","check mock done!"); pthread_mutex_destroy(&mut_f_mock_glist); @@ -202,4 +291,3 @@ __attribute__((destructor)) pthread_mutex_destroy(&mut_count_f_mock); pthread_mutex_destroy(&mut_count_expect_mock); } - diff --git a/src/fmock/fmock.h b/src/fmock/fmock.h index 43cfe22..147f72c 100644 --- a/src/fmock/fmock.h +++ b/src/fmock/fmock.h @@ -8,11 +8,18 @@ #define INITSTATE -1 #define DONOTHING 0 +struct list_current_variable{ + char *str_current_variables; + struct list_current_variable *next; +}; + 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 */ @@ -27,9 +34,11 @@ struct list_base_fmock{ }; + 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); extern struct func_mock_info_struct *f_mock_glist; extern struct list_base_fmock *g_list_base_fmock; @@ -48,6 +57,7 @@ extern struct list_base_fmock *g_list_base_fmock; 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 * */\ /*int arg_count;*/\ struct func_mock_info_struct *info_mock;\ struct list_mock_return_ ## namefunction *next;\ @@ -58,6 +68,7 @@ extern struct list_base_fmock *g_list_base_fmock; (list_mo_ ## namefunction.info_mock)->init_times_left = INITSTATE;\ /*list_mo_ ## namefunction.arg_count = parse_count_args_(#args_prototype_with_parenthesis);\ list_mo_ ## namefunction.call_mock_condition = malloc(list_mo_ ## namefunction.arg_count * sizeof( int (*)(void*))) ;*/\ + list_mo_ ## namefunction.str_print_current_variables = NULL;\ list_mo_ ## namefunction.next = NULL;\ }\ returntype namefunction args_prototype_with_parenthesis {\ @@ -71,6 +82,8 @@ extern struct list_base_fmock *g_list_base_fmock; }\ 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);\ /*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 */ \ @@ -107,33 +120,10 @@ extern struct list_base_fmock *g_list_base_fmock; char* extract_name_func_mock(char *input); + #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) -#if 0 - (tmp_mock->info_mock)->expect_call = f_expect_call;\ - (tmp_mock->info_mock)->init_times_left = repeat;\ - (tmp_mock->info_mock)->times_left = repeat;\ - (tmp_mock->info_mock)->next = NULL;\ - tmp_mock->call_mock_condition = CONCAT(namefunction ## _cond_, id);\ - tmp_mock->run = CONCAT(run_ ## namefunction ## _line_, id);\ - - - - (tmp_mock->next)->run = CONCAT(run_ ## namefunction ## _line_, id);\ - (tmp_mock->next)->call_mock_condition = CONCAT(namefunction ## _cond_, id);\ - (tmp_mock->next)->info_mock = malloc(sizeof(struct func_mock_info_struct));\ - ((tmp_mock->next)->info_mock)->expect_call = f_expect_call;\ - ((tmp_mock->next)->info_mock)->init_times_left = repeat;\ - ((tmp_mock->next)->info_mock)->times_left = repeat;\ - ((tmp_mock->next)->info_mock)->str_namefunc = malloc(strlen(#namefunction));\ - strcpy(((tmp_mock->next)->info_mock)->str_namefunc, #namefunction);\ - ((tmp_mock->next)->info_mock)->str_conditions = malloc(strlen(#condition_on_args_expression));\ - strcpy(((tmp_mock->next)->info_mock)->str_conditions, #condition_on_args_expression;\ - ((tmp_mock->next)->info_mock)->next = NULL;\ - (tmp_mock->next)->next = NULL;\ - -#endif /* * to inject the name TEST in the mock attribute info @@ -148,54 +138,74 @@ char* extract_name_func_mock(char *input); }\ }while(0); -#define FILL_MOCK_INFO(tmp_new_mock, namefunction, condition_on_args_expression , repeat, f_expect_call, id) \ - (tmp_new_mock)->run = CONCAT(run_ ## namefunction ## _line_, id);\ + +#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 PRE_ID ___line_ + + +#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("_line_"));\ - sprintf(((tmp_new_mock)->info_mock)->str_namefunc,"%s_line_%d",#namefunction,id);\ + ((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, id)\ - /*FUNC_type_ ## namefunction CONCAT(run_ ## namefunction ## _line_ , id);*/\ - returntype CONCAT(run_ ## namefunction ## _line_ , id) args_prototype_with_parenthesis; \ +#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, id);\ + 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, id);\ + 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 ## _line_, id) args_prototype_with_parenthesis - + 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, __LINE__) + 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, __LINE__) + ADD_RESPONSE(returntype,namefunction, args_prototype_with_parenthesis, condition_on_args_expression, repeat, 0, PRE_ID, __LINE__) diff --git a/src/ftest/ftest.c b/src/ftest/ftest.c index 9ed194a..eb82711 100644 --- a/src/ftest/ftest.c +++ b/src/ftest/ftest.c @@ -111,7 +111,10 @@ char *default_bar_progress=" c"; //size_t width = 80; char *colors_f[]={DEFAULT_K, GREEN_K, RED_K, YELLOW_K, BLUE_K, ""}; -int kdefaukt=0, kgreen=1, kred=2, kyellow=3, kblue=4, knothing=5; +int kdefault=0, kgreen=1, kred=2, kyellow=3, kblue=4 , knothing= Dknothing; + +char *tab_hk_f[]={ HK_EQ, HK_TR, HK_RN, HK_DN, HK_OK, HK_FL, HK_PS, HK_SK }; +int hk_EQ=0, hk_TR=1, hk_RN=2, hk_DN=3, hk_OK=4, hk_FL=5, hk_PS=6, hk_SK=7 ; bool some_tests_selected=0; @@ -267,6 +270,43 @@ size_t extract_num__f(const char *name_f){ } return val; } + /* TEST_funcname___NUM -> TEST(funcname) */ +char* extract_func_edited_TEST_from_exec_func_name(char* func_name){ + size_t len=strlen(func_name); + char *ret_name=malloc(len); + strcpy(ret_name, func_name); + char *pad="____"; + size_t len_pad=strlen(pad); + ret_name[4]='('; + for(size_t i=5;i= len_db ){ + char *tmp_bp=malloc(len_bp); + strcpy(tmp_bp,bar_progress); + tmp_bp[2]='u'; + bar_progress=tmp_bp; + } + else{ + char *tmp_bp=malloc(len_bp); + strcpy(tmp_bp,default_bar_progress); + tmp_bp[2]='u'; + default_bar_progress=tmp_bp; + } + } +} + // ===================================== begin options handle ======================================================= @@ -305,6 +345,7 @@ void usage(int argc, char **argv){ exit(0); } if(only_usage) exit(0); + } @@ -562,6 +603,7 @@ void parse_options(int argc, char **argv){ IF_NO_MATCH_DO_WRONG } + setup_variables_before_exec(); } // ==================================================== end handle option ================================ @@ -744,6 +786,8 @@ unsigned nnsleep(long long x) { return 0; } +#if 0 + void progress_test_(){ struct func *tmp; size_t num_test=0; @@ -799,6 +843,8 @@ void progress_test_(){ printf("\n"); } +#endif + void bar_progress_test_(){ bar_progress_start(); @@ -951,7 +997,7 @@ GEN_IS_IN_ARRAY_PTR(TYPE_STRING) GEN_IS_IN_ARRAY_NUM(TYPE_SIZE_T) /* - * extract name test between () beacuse the syntax is TEST(name_test) + * extract name test between () because the syntax is TEST(name_test) */ void extract_name_test_from_name(char *name_org, char **name_f){ size_t len=strlen(name_org); @@ -1351,10 +1397,11 @@ if(progress) pthread_join(thrd_progress, NULL); final_parallel_test_(); } - void run_all_tests_args(int argc, char **argv){ parse_options(argc,argv); + + if(help) usage(argc,argv); if(is_parallel_nb) run_all_tests_parallel(parallel_nb); else run_all_tests(); diff --git a/src/ftest/ftest.h b/src/ftest/ftest.h index ba90586..de4ec09 100644 --- a/src/ftest/ftest.h +++ b/src/ftest/ftest.h @@ -19,8 +19,13 @@ #define YELLOW_K "\033[0;33m" #define BLUE_K "\033[0;34m" + #define COLOR_SZ 6 -extern char *colors_f[]; + +#define Dknothing COLOR_SZ - 1 + +#define SZ_TAB_HK 8 + #ifdef HK #define HK_EQ "[==========]" @@ -58,7 +63,11 @@ extern bool unicolour; extern bool ordered; extern bool log_parallel; -extern int kdefaukt, kgreen, kred, kyellow, kblue, knothing; +extern char *colors_f[]; +extern char *tab_hk_f[]; + +extern int kdefault, kgreen, kred, kyellow, kblue, knothing; +extern int hk_EQ, hk_TR, hk_RN, hk_DN, hk_OK, hk_FL, hk_PS, hk_SK; #ifndef SAVE_LOG #define SAVE_LOG 0 @@ -324,6 +333,9 @@ 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, ... ); diff --git a/test/is_good.c b/test/is_good.c index 47d218b..81801b8 100644 --- a/test/is_good.c +++ b/test/is_good.c @@ -196,6 +196,14 @@ TEST(mockf1){ MOCK_FUNC(int, f2_mock,(int a,int b),(a,b)) +STR_PRINT_CUR_VAR(f2_mock, (int a,int b),(a,b)){ + char *ret=malloc(150); + //char ret[150]; + sprintf(ret,"(int)a: %d, (int)b: %d",a,b); + return ret; +} + + EXPECT_MOCK_CALL(int, f2_mock, (int a,int b), (a