restruct repository to ytest, create shared library for ytest

Makefile

@@ -1,63 +1,49 @@
-
+# lib: -lytest
-NAME_TEST=is_good
+PROJECT_LIB=libytest.so
 CC=gcc
-LDFLAGS=-lpthread #-D DEBUG=1
+#LDFLAGS=
-ROOT_DIR=$(shell pwd)
+INCLUDE_DIRS=$(PWD) 
-INCLUDE_DIR=$(ROOT_DIR)/src
+#$(wildcard $(PWD)/**/include)
-CFLAGS=-I$(INCLUDE_DIR)
+INCLUDE=-I$(PWD)/yftest/include  -I$(PWD)/yfmock/include -I$(PWD)/ytools_t/include -I$(PWD)/ybar_progress/include
-SRC_DIR=$(ROOT_DIR)/src
+CFLAGS=-lpthread -Wall -Werror -fpic $(INCLUDE) 
-#SRC=$(wildcard */*/*.c) 
+
-SRC=$(wildcard **/**/*.c) 
+TOPTARGETS := all clean #update_headers
+
+#SRC=$(wildcard y*/src/**/**/*.c) 
+SRC=$(wildcard y*/*/*/*.c) 
 OBJ=$(SRC:.c=.o)
-#HEADS=$(OBJS:.o=.h)
-TEST_DIR=$(ROOT_DIR)/test
-EXECSRC=$(TEST_DIR)/$(NAME_TEST).c
-EXEC=$(ROOT_DIR)/launch_$(NAME_TEST)_m
-PERMSRC=src/permutation_t/permutation_t.c
-PERMSRC_O=$(PERMSRC:.c=.o)
-SETTSRC=src/set_theoric_t/set_theoric_t.c
-SETTSRC_O=$(SETTSRC:.c=.o)
-TOOLSRC=src/tools_t/tools_t.c
-TOOLSRC_O=$(TOOLSRC:.c=.o)
-FTESTSRC=src/ftest/ftest.c
-FTESTSRC_O=$(FTESTSRC:.c=.o)
-FMOCKSRC=src/fmock/fmock.c
-FMOCKSRC_O=$(FMOCKSRC:.c=.o)
-BPROGRESSRC=src/bar_progress/bar_progress.c
-BPROGRESSRC_0=$(BPROGRESSRC:.c=.o)
 
-all: $(EXEC)
+SUBDIRS :=$(wildcard y*)
 
-$(EXEC):	$(EXECSRC) $(OBJ)
+export
-	$(CC) -o $@ $^ -I$(INCLUDE_DIR) $(LDFLAGS)
 
-$(FMOCKSRC_O): $(FMOCKSRC) $(FTESTSRC_O) 
-	$(CC) -o $@ -c $< $(CFLAGS)
 
-$(FTESTSRC_O): $(FTESTSRC) $(TOOLSRC_O) 
+$(TOPTARGETS): $(SUBDIRS)
-	$(CC) -o $@ -c $< $(CFLAGS)
 
-$(PERMSRC_O): $(PERMSRC) $(SETTSRC_O)
+all: $(PROJECT_LIB) 
-	$(CC) -o $@ -c $< $(CFLAGS)
 
-$(SETTSRC_O) : $(SETTSRC) $(TOOLSRC_O)
-	$(CC) -o $@ -c $< $(CFLAGS)
 
-$(TOOLSRC_O): $(TOOLSRC) 
+$(PROJECT_LIB): $(OBJ)
-	$(CC) -o $@ -c $< $(CFLAGS)
+	echo $(OBJ)
+	#$(CC) -shared -o $@ $^ $(INCLUDE) $(LDFLAGS)
+	$(CC) -shared -o $@ $^ $(LDFLAGS)
 
-$(BPROGRESSRC_0): $(BPROGRESSRC) 
-	$(CC) -o $@ -c $< $(CFLAGS)
 
-.PHONY: clean mrproper
+$(SUBDIRS):
+		$(MAKE) -C $@ $(MAKECMDGOALS)
+
+update_headers: $(PROJECT_LIB)
+	for file_h in $(SUBDIRS); do cp -r "$$file_h/include" include_ytest/;	done	
+
+.PHONY: $(TOPTARGETS) $(SUBDIRS)
 
 clean:
-	echo "all src : $(SRC)"
+	rm -f $(PROJECT_LIB)
-	echo "all obj : $(OBJ)"
-	rm -f $(OBJ)
 
-mrproper: clean
+remove_headers:
-	rm -f $(EXEC)
+	rm -r include_ytest/*
 
-run: $(EXEC)
+#SRC_test=test/is_good.c
-	$(EXEC) -h
+
+#compile: $(SRC_test) $(PROJECT_LIB) 
+#	$(CC) -o launch_is_good_m $< -L. test/src/permutation_t/permutation_t.o test/src/set_theoric_t/set_theoric_t.o -lytest -I./test/src -I./include_ytest

README.md

@@ -4,29 +4,79 @@ C library like `gtest / gmock`  like, but works mainly with functions
 ## env
 linux
 
+## install
+```
+make
+```
+or 
+```
+./kreate_library_ytest.sh
+```
+
+### make options
+```
+make update_headers
+```
+it copy all headers of `ytest` in `include_ytest/include/`
+
+## compile
+if the code is in `test/is_good.c` we compile in the main directory by:
+```
+gcc -o launch_ex test/is_good.c -I./include_ytest -L. -lytest \
+  src/permutation/permutation.c src/set_theoric/set_theoric.c -I./src # this line is the library we need to test!
+```
+if we change the directory, we need to notice the /Path_to_dir_ytest, then change the option compile by
+```
+gcc -o launch_ex path_to_file/is_good.c -I/Path_to_dir_ytest/include_ytest -L/Path_to_dir_ytest -lytest \
+  /Path_tolib/src/permutation/permutation.c /Path_tolib/src/set_theoric/set_theoric.c -I./Path_tolib # this line is the library we need to test!
+```
+
+## install lib ytest
+
+copy the headers in `include_ytest` to include directory, for example
+```
+cp include_ytest/include/* /usr/include/
+```
+or
+```
+cp include_ytest/include/* ~/.local/include/
+```
+if `/usr/include` or `~/.local/include` is in `CPATH`
+or
+add ```export CPATH=/Path_to_dir_ytest/include_ytest/include:$CPATH```  in `~/.bashrc`.
+ 
+So, we do not need to add `-I/Path_to_dir_ytest/include_ytest/include` when compiling,
+
+To avoid `-L/Path_to_dir_ytest` when compiling, we can copy `libytest.so` in a directory in `/usr/lib/` or copy `libytest.so` in `/path_to/lib_ytest/` and then 
+add ```export LD_LIBRARY_PATH=/path_to/lib_ytest:$LD_LIBRARY_PATH```  in `~/.bashrc`.
+
+
+
+
 ## test examples
 `test/is_good.c`
 
-## compile and run
+## compile and run the example
 ```
-make
+cd test
+make 
 ./launch_is_good_m
 ```
 or
 ```
 chmod +x compile.sh
-./compile.sh 
+./compile.sh "is_good.c" 
 ./launch_is_good_c
 ```
 ## some compile options
 ### if need debug print
-`./compile "-D DEBUG=1"`
+`./compile "s_good.c"  "-D DEBUG=1"`
 ### if need gdb
-`./compile "-g"`
+`./compile "test/is_good.c"  "-g"`
 ### if need prompt googletest like
-`./compile "-D HK"`
+`./compile "test/is_good.c"  "-D HK"`
 
-We can combine these options, for example: `./compile "-D DEBUG=1 -D HK -g"`
+We can combine these options, for example: `./compile "test/is_good.c"  "-D DEBUG=1 -D HK -g"`
 
 ## launch options if using run_all_tests_args(argc, argv);
 By default `./launch_is_good_{c,m}` is on 1 thread but we can add some options to run tests in parallel, or change colors, to disable progress bar, ..., to print help
@@ -89,6 +139,12 @@ For example, to launch tests (`test/is_good.c`) on 4 threads, using unicolor(bla
 
 
 # How to create test
+
+This need to add `path_to/include_ytest/include` in `CPATH` by `export CPATH=/path_to/include_ytest/include:$CPATH` in terminal or in `~/.bashrc` file for example, or add `-I/path_to/include_ytest/include` when compiling, 
+the others option when compiling are `-L/path_to/directorytest` this path must contain `libytest.so` generated by `make` or `./kreate_library_ytest` or we can put this path in `LD_LIBRARY_PATH`.
+And we must add `lytest` to add the shared library in compilation.
+
+## include
 ```
 #include "ftest/ftest.h"
 
@@ -102,6 +158,7 @@ TEST(){
 	EXPECT_TRUE(true);
 }
 ```
+
 ## in main func
 ### if using options:
 ```

compile.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-gcc test/is_good.c src/ftest/ftest.c src/fmock/fmock.c \
-  src/tools_t/tools_t.c src/bar_progress/bar_progress.c \
-  src/permutation_t/permutation_t.c src/set_theoric_t/set_theoric_t.c \
-  -Isrc $1 -o launch_is_good_c -lpthread 

include_ytest/include/ftest/ftest.h

@@ -782,8 +782,9 @@ do{
   void CONCAT(TEST_##name_f##____,count)(void)
 
 
-//#define TEST(name_f)\
+/*#define TEST(name_f)\
   FTEST_(__COUNTER__,name_f)
+*/
 
 #define TEST(name_f)                                            \
   FTEST__(__COUNTER__,name_f)

kreate_library_ytest.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+for yfile in y*
+do
+  cp -r "$yfile/include" include_ytest/
+done
+
+
+gcc -c -Wall -Werror -fpic  yftest/src/ftest/ftest.c yfmock/src/fmock/fmock.c \
+  ytools_t/src/tools_t/tools_t.c ybar_progress/src/bar_progress/bar_progress.c \
+  -I./include_ytest/include $1 -lpthread 
+
+gcc -shared -o libytest.so *.o 
+
+rm *.o

src/fmock/cp0fmock.h

@@ -1,93 +0,0 @@
-#ifndef __MOCK_C_H__
-#define __MOCK_C_H__
-
-#include "ftest/ftest.h"
-#include "tools_t/tools_t.h"
-
-#define INFINITY -8
-#define INITSTATE -1
-#define DONOTHING 0
-
-int parse_count_args_(char *input);
-
-struct func_mock_info_struct{
-  long id;
-  void *struct_mock;/* contain returntype, namefunction, args... */
-  int expect_call;/* 1 if EXPECT_MOCK_CALL and 0 if WILL_MOCK_CALL */
-  long init_times_left;/* DONOTHING do nothing (pass to -> next), INFINITY every time; INITSTATE init; > 0 execute and decrement  */
-  long times_left;
-  struct func_mock_struct *next;
-};
-
-#define MOCK_FUNC(returntype, namefunction, args_prototype_with_parenthesis, args_call_with_parenthesis)\
-  /*typedef returntype FUNC_type_ ## namefunction args_prototype_with_parenthesis ;*/\
-  /*typedef args_prototype_with_parenthesis args_ ## namefunction;*/\
-  struct list_mock_return_ ## namefunction{\
-    returntype (*run) args_prototype_with_parenthesis;\
-    int expect_call;/* 1 if EXPECT_MOCK_CALL and 0 if WILL_MOCK_CALL */\
-    int (*call_mock_condition) args_prototype_with_parenthesis ;/* to store condition */\
-    /*int arg_count;*/\
-    long init_times_left;/* DONOTHING do nothing (pass to -> next), INFINITY every time; INITSTATE init; > 0 execute and decrement  */\
-    long times_left;/* DONOTHING do nothing (pass to -> next), INFINITY every time; INITSTATE init; > 0 execute and decrement  */\
-    struct list_mock_return_ ## namefunction *next;\
-  } list_mo_ ## namefunction;\
-  __attribute__((constructor)) void init_list_m_ ## namefunction(void){\
-    list_mo_ ## namefunction.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.next = NULL;\
-  }\
-  returntype namefunction args_prototype_with_parenthesis {\
-    struct list_mock_return_ ## namefunction *tmp_mock = &list_mo_ ## namefunction;\
-    while(tmp_mock->next && tmp_mock->times_left == 0) tmp_mock = tmp_mock->next ;\
-      /*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->times_left <= INFINITY) || (tmp_mock->times_left > 0)){\
-        --(tmp_mock->times_left);\
-        if(1 == tmp_mock->call_mock_condition args_call_with_parenthesis){\
-          return tmp_mock->run args_call_with_parenthesis;\
-        }\
-        else return (returntype)0;/* default return */\
-      }\
-  }
-
-
-#define ADD_RESPONSE(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression , repeat, f_expect_call, id)\
-  /*FUNC_type_ ## namefunction CONCAT(run_ ## namefunction ## _ID_ , id);*/\
-  returntype CONCAT(run_ ## namefunction ## _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->times_left == INITSTATE){/* init state */\
-      tmp_mock->expect_call = f_expect_call;\
-      tmp_mock->init_times_left = repeat;\
-      tmp_mock->times_left = repeat;\
-      tmp_mock->call_mock_condition = CONCAT(namefunction ## _cond_, id);\
-      tmp_mock->run = CONCAT(run_ ## namefunction ## _ID_, id);\
-    }\
-    else{\
-      while(tmp_mock->next) tmp_mock = tmp_mock->next;\
-      tmp_mock->next = malloc(sizeof(list_mo_ ## namefunction));\
-      (tmp_mock->next)->run = CONCAT(run_ ## namefunction ## _ID_, id);\
-      (tmp_mock->next)->call_mock_condition = CONCAT(namefunction ## _cond_, id);\
-      (tmp_mock->next)->expect_call = f_expect_call;\
-      (tmp_mock->next)->init_times_left = repeat;\
-      (tmp_mock->next)->times_left = repeat;\
-      (tmp_mock->next)->next = NULL;\
-    }\
-  }\
-  returntype CONCAT(run_ ## namefunction ## _ID_, id) args_prototype_with_parenthesis
-
-
-
-
-#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__)
-
-
-#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__)
-  
-
-
-#endif /* __MOCK_C_H__ */

test/Makefile

@@ -0,0 +1,61 @@
+
+
+
+
+NAME_TEST=is_good
+CC=gcc
+ROOT_DIR=$(PWD)
+INCLUDE_DIR=$(ROOT_DIR)/src
+CFLAGS=-I$(INCLUDE_DIR) -I../include_ytest/include
+LDFLAGS=-L$(PWD)/.. -lytest
+
+#SRC_DIR=$(ROOT_DIR)/src
+#SRC=$(wildcard */*/*.c) 
+SRC=$(wildcard **/**/*.c) 
+OBJ=$(SRC:.c=.o)
+#HEADS=$(OBJS:.o=.h)
+TEST_DIR=$(PWD)
+EXECSRC=$(NAME_TEST).c
+EXEC=launch_$(NAME_TEST)_m
+PERMSRC=src/permutation_t/permutation_t.c
+PERMSRC_O=$(PERMSRC:.c=.o)
+SETTSRC=src/set_theoric_t/set_theoric_t.c
+SETTSRC_O=$(SETTSRC:.c=.o)
+TOOLSRC=../ytools_t/src/tools_t/tools_t.c
+TOOLSRC_O=$(TOOLSRC:.c=.o)
+
+FTESTSRC=src/ftest/ftest.c
+FTESTSRC_O=$(FTESTSRC:.c=.o)
+FMOCKSRC=src/fmock/fmock.c
+FMOCKSRC_O=$(FMOCKSRC:.c=.o)
+BPROGRESSRC=src/bar_progress/bar_progress.c
+BPROGRESSRC_0=$(BPROGRESSRC:.c=.o)
+
+LIB_YTEST=../libytest.so
+
+all: $(EXEC) $(LIB_YTEST)
+
+$(EXEC):	$(EXECSRC) $(OBJ)
+	$(CC) -o $@ $^ $(CFLAGS) $(LDFLAGS)
+
+$(PERMSRC_O): $(PERMSRC) $(SETTSRC_O)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+$(SETTSRC_O) : $(SETTSRC) $(TOOLSRC_O)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+$(TOOLSRC_O): $(TOOLSRC) 
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+.PHONY: clean mrproper
+
+clean:
+	#echo "all src : $(SRC)"
+	#echo "all obj : $(OBJ)"
+	rm -f $(OBJ)
+
+mrproper: clean
+	rm -f $(EXEC)
+
+run: $(EXEC)
+	$(EXEC) -h

test/compile.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+if [ "$#" -le 0 ] ; then
+  echo "Usage: $0 is_good.c" >&2
+  echo "for example to compile: is_good.c" >&2
+  exit 1
+fi
+if [ "$#" -le 1 ] ; then
+  echo "Usage: $0 $1" >&2
+  echo " we can add more option for example '-D DEBUG=1' to have debug print, '-D HK' to have gtest like prompt, od '-g' to gbd" >&2
+  echo "for example: $0 $1 \"-D DEBUG=1 -D HK -g\""
+fi
+
+
+export LD_LIBRARY_PATH=$PWD/../:LD_LIBRARY_PATH
+
+gcc -o launch_is_good_c $1 -L$PWD/../ $2 -lytest -I../include_ytest/include src/permutation_t/permutation_t.o src/set_theoric_t/set_theoric_t.o -I./src 
+#gcc -o launch_is_good_c $1 $2 -lytest -I../include_ytest src/permutation_t/permutation_t.o src/set_theoric_t/set_theoric_t.o -I./src 
+
+
+
+#gcc $1 src/ftest/ftest.c src/fmock/fmock.c src/tools_t/tools_t.c src/bar_progress/bar_progress.c src/permutation_t/permutation_t.c src/set_theoric_t/set_theoric_t.c -I./include $2 -o launch_is_good_c -lpthread 

test/is_good.c

@@ -12,9 +12,10 @@
 #include "ftest/ftest.h"
 #include "fmock/fmock.h"
 
+#if 1
+
 #include "permutation_t/permutation_t.h"
 
-#if 1
 
 TEST(size_permutation2){
   PRINTF("another size_permutation2 again\n");
@@ -30,6 +31,8 @@ TEST(size_permutation)
   PRINTF("test size_permutation2\n");
 }
 
+#endif
+
 TEST(size_permutation2){
   PRINTF("another size_permutation2 again false\n");
   bool val_bool = false;
@@ -78,6 +81,7 @@ TEST(){
   ASSERT_TRUE(true);
 }
 
+
 TEST(){
   sleep(3);
   int a = 5;
@@ -176,7 +180,6 @@ TEST(sleep){sleep(1);}
 TEST(sleep){sleep(1);}
 TEST(sleep){sleep(1);}
 
-#endif
 TEST(sleep){sleep(1);}
 TEST(sleep){sleep(1);}
 TEST(sleep){sleep(1);}

test/src/Makefile

@@ -6,7 +6,7 @@ ROOT_DIR=$(shell pwd)
 INCLUDE_DIR=$(ROOT_DIR)
 CFLAGS=-I$(INCLUDE_DIR)
 SRC_DIR=$(ROOT_DIR)
-SRC=$(wildcard */*.c) 
+SRC=$(wildcard src/*/*.c) 
 OBJ=$(SRC:.c=.o)
 #HEADS=$(OBJS:.o=.h)
 TEST_DIR=$(ROOT_DIR)

ybar_progress/Makefile

@@ -0,0 +1,17 @@
+
+
+
+BARPROGES_SRC=src/bar_progress/bar_progress.c
+BARPROGES_O=$(BARPROGES_SRC:.c=.o)
+
+all: $(BARPROGES_O)
+
+$(BARPROGES_O): $(BARPROGES_SRC)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+
+.PHONY: clean 
+
+clean:
+	rm -f $(BARPROGES_O)
+

ybar_progress/include/bar_progress/bar_progress.h

@@ -0,0 +1,30 @@
+#ifndef __BAR_PROGRESS_H__
+#define __BAR_PROGRESS_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//#include <unistd.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+
+
+
+/*
+ * Prepares screen for progress bar.
+ */
+void bar_progress_start(void);
+
+void bar_progress_step_msg(int step_progress, int all_progress, char *msg, char fill_bar, char fill_dot, int colored);
+
+/*
+ * progress  value 0 to 100
+ */
+void bar_progress_step(float step_percent);
+
+/*
+ * Removes progress bar and restores original screen size.
+ */
+void bar_progress_stop(void);
+
+#endif /* __BAR_PROGRESS_H */

ybar_progress/src/bar_progress/bar_progress.c

@@ -72,7 +72,7 @@ void bar_progress_step_msg(int step_progress, int all_progress, char *msg, char
 	}
   int size_char_log= strlen(msg) + strlen("(-) Progress: [100a] [aaaa/bbbb] a");
 	int width = (w.ws_col - size_char_log);
-  int j;
+  //int j;
   /*
   for(int j=0; j< width ; ++j)
     if (j<(int)(width * (step_progress / 100))) bar[j]='=';

ybar_progress/src/bar_progress/bar_progress.h

@@ -0,0 +1,30 @@
+#ifndef __BAR_PROGRESS_H__
+#define __BAR_PROGRESS_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//#include <unistd.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+
+
+
+/*
+ * Prepares screen for progress bar.
+ */
+void bar_progress_start(void);
+
+void bar_progress_step_msg(int step_progress, int all_progress, char *msg, char fill_bar, char fill_dot, int colored);
+
+/*
+ * progress  value 0 to 100
+ */
+void bar_progress_step(float step_percent);
+
+/*
+ * Removes progress bar and restores original screen size.
+ */
+void bar_progress_stop(void);
+
+#endif /* __BAR_PROGRESS_H */

yfmock/Makefile

@@ -0,0 +1,20 @@
+
+
+FMOCK_SRC=src/fmock/fmock.c
+FMOCK_O=$(FMOCK_SRC:.c=.o)
+
+FTEST_SRC=../yftest/src/ftest/ftest.c
+FTEST_O=$(FTEST_SRC:.c=.o)
+
+
+all: $(FMOCK_O)
+
+$(FMOCK_O): $(FMOCK_SRC) $(FTEST_O)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+
+.PHONY: clean 
+
+clean:
+	rm -f $(FMOCK_O)
+

yfmock/include/fmock/fmock.h

@@ -0,0 +1,286 @@
+#ifndef __MOCK_C_H__
+#define __MOCK_C_H__
+
+#include "ftest/ftest.h"
+#include "tools_t/tools_t.h"
+
+#define INFINITY -8
+#define INITSTATE -1
+#define DONOTHING 0
+
+#define PRE_ID ___line_
+/*
+ * list of each variable called 
+ * use str_print_current_variables attibute function pointer to record variable
+ * so if STR_PRINT_CUR_VAR is not defined, this list is empty!
+ */
+struct list_current_variable{
+  char *str_current_variables;
+  struct list_current_variable *next;
+};
+
+/*
+ * list to store info abou mock function 
+ */
+struct func_mock_info_struct{
+  long id;
+  char *str_namefunc;
+  char *str_conditions;
+  char *str_caller;
+  //char *str_current_variables;
+  struct list_current_variable *l_current_var;
+  int expect_call;/* 1 if EXPECT_MOCK_CALL and 0 if WILL_MOCK_CALL */
+  long call;/* increment when call (try to executed) and 0 if not : init value */
+  long failed_call;/* increment when condition not fill and 0 if not : init value */
+  long init_times_left;/* DONOTHING do nothing (pass to -> next), INFINITY every time; INITSTATE init; > 0 execute and decrement  */
+  long times_left;/* DONOTHING do nothing (pass to -> next), INFINITY every time; INITSTATE init; > 0 execute and decrement  */
+  struct func_mock_info_struct *next;
+};
+
+/*
+ * to list all mock responses of all mock functions in one list
+ */
+struct list_base_fmock{
+  struct func_mock_info_struct *info_mock;
+  struct list_base_fmock *next;
+};
+
+
+
+int parse_count_args_(char *input);
+void append_fmock_to_listmock(struct func_mock_info_struct **f_mock_list,  struct func_mock_info_struct *f_mock);
+void append_list_base_fmock(struct list_base_fmock **l_fmock, struct func_mock_info_struct *f_mock);
+void append_variable_current(struct list_current_variable **lcurrent_var, char *current_var);
+
+// if input == functioname___line_NBLINE return functioname, else it return the input
+//char* extract_name_func_mock(char *input);
+
+extern struct func_mock_info_struct *f_mock_glist;
+extern struct list_base_fmock *g_list_base_fmock;
+
+#if 0
+    int expect_call; /* 1 if EXPECT_MOCK_CALL and 0 if WILL_MOCK_CALL */\
+    long init_times_left; /* DONOTHING do nothing (pass to -> next), INFINITY every time; INITSTATE init; > 0 execute and decrement  */\
+    long times_left; /* DONOTHING do nothing (pass to -> next), INFINITY every time; INITSTATE init; > 0 execute and decrement  */\
+
+#endif
+
+#define INIT_MOCK_INFO_IF_NO__(tmp__mock, namefunction, pre_id, id) \
+      (tmp__mock)->run = NULL;\
+      (tmp__mock)->call_mock_condition = NULL;\
+      /*(tmp__mock)->str_print_current_variables = list_mo_ ## namefunction .str_print_current_variables;*/\
+      ((tmp__mock)->info_mock)->expect_call = -1;\
+      ((tmp__mock)->info_mock)->call = 0;\
+      ((tmp__mock)->info_mock)->failed_call = 0;\
+      ((tmp__mock)->info_mock)->str_namefunc = malloc(strlen(#namefunction) + 32 + strlen(#pre_id));\
+      sprintf(((tmp__mock)->info_mock)->str_namefunc,"%s%s%d",#namefunction,#pre_id,id);\
+      ((tmp__mock)->info_mock)->str_conditions = NULL;\
+      ((tmp__mock)->info_mock)->str_caller = NULL;\
+      ((tmp__mock)->info_mock)->l_current_var= NULL;\
+      ((tmp__mock)->info_mock)->next = NULL;\
+      /*(tmp__mock)->next = NULL;*/\
+      append_fmock_to_listmock(&f_mock_glist, (tmp__mock)->info_mock);\
+      append_list_base_fmock( &g_list_base_fmock ,(tmp__mock)->info_mock);
+
+#define INIT_MOCK_INFO_IF_NO_(tmp_new_mock, namefunction, pre_id) \
+    INIT_MOCK_INFO_IF_NO__(tmp_new_mock, namefunction, pre_id, __LINE__) \
+
+#define MOCK_FUNC(returntype, namefunction, args_prototype_with_parenthesis, args_call_with_parenthesis)\
+  /*typedef returntype FUNC_type_ ## namefunction args_prototype_with_parenthesis ;*/\
+  /*typedef args_prototype_with_parenthesis args_ ## namefunction;*/\
+  struct list_mock_return_ ## namefunction{\
+    returntype (*run) args_prototype_with_parenthesis;\
+    int (*call_mock_condition) args_prototype_with_parenthesis ;/* to store condition */\
+    char* (*str_print_current_variables) args_prototype_with_parenthesis ;/* to store current variables CREATE by macro STR_PRINT_CUR_VAR same arguments as MOCK_FUNC without returntype whoch is always char * */\
+    struct func_mock_info_struct *info_mock;\
+    struct list_mock_return_ ## namefunction *next;\
+  } list_mo_ ## namefunction;\
+  __attribute__((constructor)) void init_list_m_ ## namefunction(void){\
+    list_mo_ ## namefunction.info_mock = malloc(sizeof(struct func_mock_info_struct));\
+    (list_mo_ ## namefunction.info_mock)->times_left = INITSTATE;\
+    (list_mo_ ## namefunction.info_mock)->init_times_left = INITSTATE;\
+    list_mo_ ## namefunction.str_print_current_variables = NULL;\
+    list_mo_ ## namefunction.next = NULL;\
+  }\
+  returntype namefunction args_prototype_with_parenthesis {\
+    static size_t count_call_f=0;\
+    ++count_call_f;\
+    PRINT_DEBUG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>count call of %s: %ld\n",#namefunction,count_call_f);\
+    struct list_mock_return_ ## namefunction *tmp_mock = &list_mo_ ## namefunction;\
+    if( (tmp_mock->info_mock)->times_left == INITSTATE ){\
+         PRINT_HK_C(colors_f[k_YELLOW],HK_TR," WARNING, %s, no EXPECT_MOCK_CALL or WILL_MOCK_CALL, but called %ld times.\n",#namefunction, count_call_f);\
+       if(count_call_f==1){\
+         PRINT_HK_C(colors_f[k_YELLOW],HK_TR," For instance:\n"\
+             "%s EXPECT_MOCK_CALL(%s,%s,%s,true,1){\n"\
+             "%s\t %s ret;\n%s \t ...do something with %s;\n"\
+             "%s\t return ret;\n"\
+             "%s }\n"\
+             "%s if call once and accept all args, the same args with WILL_MOCK_CALL \n\n",\
+            HK_TR, #returntype, #namefunction,#args_prototype_with_parenthesis, HK_TR,#returntype, \
+            HK_TR, #args_call_with_parenthesis, HK_TR, HK_TR, HK_TR ); \
+        /*return (returntype)0;*/ \
+        INIT_MOCK_INFO_IF_NO_(tmp_mock,namefunction, PRE_ID);\
+      }/* to have log */\
+      /*if(list_mo_ ## namefunction.next ) PRINT_ERROR(" %s .next SHOULD BE NULL\n",STRFY(list_mo_ ## namefunction));*/\
+    }\
+    while(tmp_mock->next && (tmp_mock->info_mock)->times_left == 0) {tmp_mock = tmp_mock->next ;}\
+    ++((tmp_mock->info_mock)->call);\
+    if(tmp_mock->str_print_current_variables){\
+      append_variable_current(&((tmp_mock->info_mock)->l_current_var), tmp_mock->str_print_current_variables args_call_with_parenthesis);\
+    }\
+    else if(count_call_f == 1){\
+      PRINT_HK_C(colors_f[k_YELLOW],HK_TR," no printer variable function defined, to define it:\n"\
+          "%s STR_PRINT_CUR_VAR(%s,%s,%s){\n"\
+          "%s\t char* ret=malloc(256);/*for instance*/;\n"\
+          "%s\t ...  sprintf(ret,...., %s);/*for instance*/ \n"\
+          "%s\t return ret;\n"\
+          "%s }\n"\
+          "%s same prototype as MOCK_FUNC whithout returntype which always char* i\n\n",\
+            HK_TR, #namefunction,#args_prototype_with_parenthesis, #args_call_with_parenthesis, \
+            HK_TR, HK_TR, #args_call_with_parenthesis, HK_TR, HK_TR, HK_TR ); \
+    }\
+      /*LOG("condition_func:%d\n", tmp_mock->call_mock_condition args_call_with_parenthesis);*/ /*LOG("%s\n","failure condition");*/\
+    /*EXPECT_EQ_TYPE_INT(1, tmp_mock->call_mock_condition args_call_with_parenthesis);*/ /*LOG("%s\n","failure condition");*/\
+    /*if ((tmp_mock->info_mock)->times_left == 0)*/ /*no longer response, default return */ \
+      /*return (returntype)0;*//* default return */\
+    if( (tmp_mock->info_mock)->str_caller == NULL){ \
+      if(count_call_f == 1){\
+        PRINT_HK_C(colors_f[k_YELLOW],HK_TR," WARNING, no  INIT_CALLER_MOCK; you can put it like this: \n"\
+            "%s TEST(nametest){\n"\
+            "%s\t INIT_CALLER_MOCK(%s); \n"\
+            "%s\t %s%s; \n"\
+            "%s }\n"\
+            "%s i.e before calling %s in this TEST, to have explicit logs\n",\
+          HK_TR, HK_TR, #namefunction, HK_TR,#namefunction,#args_call_with_parenthesis,  HK_TR, HK_TR, #namefunction);} \
+      /*return (returntype)0;*/ \
+    }\
+    else if (((tmp_mock->info_mock)->times_left != 0) && ((tmp_mock->info_mock)->times_left != INITSTATE )) {\
+      size_t len0 = strlen((tmp_mock->info_mock)->str_conditions);\
+      size_t len1 = strlen("when checking condition call: aa");\
+      char *msg_call=malloc(len0 + len1 + strlen(__func__));\
+      sprintf(msg_call,"when checking %s condition call: %s",__func__,(tmp_mock->info_mock)->str_conditions);\
+      HANDLE_OP_EXPECT_NAME(EQ,TYPE_INT,1, tmp_mock->call_mock_condition args_call_with_parenthesis, (tmp_mock->info_mock)->str_caller, msg_call); /*LOG("%s\n","failure condition");*/\
+      free(msg_call);\
+    }\
+    /*if(0 == tmp_mock->call_mock_condition args_call_with_parenthesis){\
+      PRINT_LOC("Failure, arguments not expected\ncondition ( %s ) not verified\n\n", (tmp_mock->info_mock)->str_conditions);\
+      PRINT_HK_C(RED_K,HK_TR," 1 argument check failed from %s \n",__func__);                                 \
+    }*/\
+    PRINT_DEBUG(" %*c VALUES: mock function:%s, conditions:%s t_left:%ld, init_left:%ld| args:%s\n",8,'^',(tmp_mock->info_mock)->str_namefunc, (tmp_mock->info_mock)->str_conditions, (tmp_mock->info_mock)->times_left,(tmp_mock->info_mock)->init_times_left, #args_call_with_parenthesis);\
+    if (((tmp_mock->info_mock)->times_left <= INFINITY) || ((tmp_mock->info_mock)->times_left > 0)){\
+      --((tmp_mock->info_mock)->times_left);\
+    PRINT_DEBUG(" %*c VALUES: mock function:%s, conditions:%s t_left:%ld, init_left:%ld| args:%s\n",8,'v',(tmp_mock->info_mock)->str_namefunc, (tmp_mock->info_mock)->str_conditions, (tmp_mock->info_mock)->times_left,(tmp_mock->info_mock)->init_times_left, #args_call_with_parenthesis);\
+      if(1 == tmp_mock->call_mock_condition args_call_with_parenthesis){\
+        return tmp_mock->run args_call_with_parenthesis;\
+      }\
+      else ++((tmp_mock->info_mock)->failed_call);\
+    }\
+    return (returntype)0;/* default return */\
+  }
+
+
+char* extract_name_func_mock(char *input);
+
+/*
+ * used in mock functions to check the conditions
+ */
+#define EXPECT_EQ_IN_MOCKF(var1,var2, name_f_mocked)\
+  do{ \
+   if((list_mo_ ## name_f_mocked.info_mock)->str_caller) {\
+     HANDLE_OP_EXPECT_NAME(EQ,TYPE_INT,var1,var2,(list_mo_ ## name_f_mocked.info_mock)->str_caller,"mock test");\
+   }\
+   else\
+     HANDLE_OP_EXPECT_NAME(EQ,TYPE_INT,var1,var2,__func__,"mock test");\
+}while(0)
+    
+
+/*
+ *  to inject the name TEST caller in the mock attribute info, usefull in logs and stats
+ */
+#define INIT_CALLER_MOCK(namefunction)/* */\
+  do{\
+      struct list_mock_return_ ## namefunction *tmp_mock = &list_mo_ ## namefunction;\
+      while(tmp_mock){\
+        (tmp_mock->info_mock)->str_caller=malloc(strlen(__func__));\
+        strcpy((tmp_mock->info_mock)->str_caller,__func__);\
+        tmp_mock = tmp_mock->next;\
+      }\
+ }while(0);
+
+/*
+ * to create/ define str_print_current_variables functions
+ * prototype:  char* str_print_current_variables (prototype of mock function)
+ * the args of the macro are the same of MOCK_FUNC without the returntype which is always (char*).
+ * It need to be defined after MOCK_FUNC but need to be before EXPECT_MOCK_CALL or WILL_MOCK_CALL
+ */
+
+#define STR_PRINT_CUR_VAR(namefunction, args_prototype_with_parenthesis, args_call_with_parenthesis)\
+  char* str_print_variables ## namefunction args_prototype_with_parenthesis;\
+__attribute__((constructor)) void create_str_print_variables ## namefunction(){\
+  list_mo_ ## namefunction .str_print_current_variables = str_print_variables ## namefunction;\
+  }\
+  char* str_print_variables ## namefunction args_prototype_with_parenthesis
+
+
+
+
+#define FILL_MOCK_INFO(tmp_new_mock, namefunction, condition_on_args_expression , repeat, f_expect_call, pre_id, id, is_init) \
+      (tmp_new_mock)->run = CONCAT(run_ ## namefunction ## pre_id, id);\
+      (tmp_new_mock)->call_mock_condition = CONCAT(namefunction ## _cond_, id);\
+      if(!is_init)\
+        (tmp_new_mock)->str_print_current_variables = list_mo_ ## namefunction .str_print_current_variables;\
+      /*(tmp_new_mock)->info_mock  = malloc(sizeof(struct func_mock_info_struct));*/\
+      ((tmp_new_mock)->info_mock)->expect_call = f_expect_call;\
+      ((tmp_new_mock)->info_mock)->call = 0;\
+      ((tmp_new_mock)->info_mock)->failed_call = 0;\
+      ((tmp_new_mock)->info_mock)->init_times_left = repeat;\
+      ((tmp_new_mock)->info_mock)->times_left = repeat;\
+      ((tmp_new_mock)->info_mock)->str_namefunc = malloc(strlen(#namefunction) + 32 + strlen(#pre_id));\
+      sprintf(((tmp_new_mock)->info_mock)->str_namefunc,"%s%s%d",#namefunction,#pre_id,id);\
+      ((tmp_new_mock)->info_mock)->str_conditions = malloc(strlen(#condition_on_args_expression));\
+      strcpy(((tmp_new_mock)->info_mock)->str_conditions, #condition_on_args_expression);\
+      ((tmp_new_mock)->info_mock)->str_caller = NULL;\
+      ((tmp_new_mock)->info_mock)->l_current_var= NULL;\
+      ((tmp_new_mock)->info_mock)->next = NULL;\
+      (tmp_new_mock)->next = NULL;\
+      append_fmock_to_listmock(&f_mock_glist, (tmp_new_mock)->info_mock);
+
+
+#define ADD_RESPONSE_(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression , repeat, f_expect_call, pre_id, id)\
+  /*FUNC_type_ ## namefunction CONCAT(run_ ## namefunction ## pre_id , id);*/\
+  returntype CONCAT(run_ ## namefunction ## pre_id , id) args_prototype_with_parenthesis; \
+  int CONCAT(namefunction ## _cond_ , id) args_prototype_with_parenthesis {/*LOG("cond:%d\n",condition_on_args_expression);*/ return condition_on_args_expression;}\
+  __attribute__((constructor)) void CONCAT(append_list_ ## namefunction , id)(void){\
+    struct list_mock_return_ ## namefunction *tmp_mock = &list_mo_ ## namefunction;\
+    if((tmp_mock->info_mock)->times_left == INITSTATE){/* init state */\
+      FILL_MOCK_INFO(tmp_mock, namefunction, condition_on_args_expression , repeat, f_expect_call, pre_id, id, true);\
+      append_list_base_fmock( &g_list_base_fmock ,(tmp_mock->info_mock));\
+    }\
+    else{\
+      while(tmp_mock->next) tmp_mock = tmp_mock->next;\
+      tmp_mock->next = malloc(sizeof(list_mo_ ## namefunction));\
+      (tmp_mock->next)->info_mock  = malloc(sizeof(struct func_mock_info_struct));\
+      FILL_MOCK_INFO(tmp_mock->next, namefunction, condition_on_args_expression , repeat, f_expect_call, pre_id, id, false);\
+      /*(tmp_mock->info_mock)->next  = (tmp_mock->next)->info_mock ;*/\
+    }\
+  }\
+  returntype CONCAT(run_ ## namefunction ## pre_id, id) args_prototype_with_parenthesis
+
+/*
+ * have to define this below macro to rewrite the right macro identifier (PRE_ID) 
+ */ 
+      
+#define ADD_RESPONSE(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression , repeat, f_expect_call, pre_id, id)\
+   ADD_RESPONSE_(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression , repeat, f_expect_call, pre_id, id)\
+
+
+#define EXPECT_MOCK_CALL(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression ,repeat) \
+  ADD_RESPONSE(returntype,namefunction, args_prototype_with_parenthesis, condition_on_args_expression, repeat, 1, PRE_ID, __LINE__)
+
+
+#define WILL_MOCK_CALL(returntype, namefunction, args_prototype_with_parenthesis, condition_on_args_expression ,repeat) \
+  ADD_RESPONSE(returntype,namefunction, args_prototype_with_parenthesis, condition_on_args_expression, repeat, 0, PRE_ID, __LINE__)
+  
+
+
+#endif /* __MOCK_C_H__ */

yfmock/src/fmock/fmock.c

@@ -198,14 +198,14 @@ __attribute__((destructor))
 
 
     is_parallel_nb = 0; /* no longer parallel here */
-    struct func_mock_info_struct *tmock = f_mock_glist, *tfree;
+    struct func_mock_info_struct *tmock = f_mock_glist; //, *tfree;
 
     /* global order of fmock , order of expect and will */
     while(tmock){
       PRINT_DEBUG("check mock function: %s\n",tmock->str_namefunc);
-      tfree=tmock;
+      //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)){
+      if(((tmock->expect_call) && (tmock->init_times_left == tmock->times_left)) || (tmock->failed_call)){
         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[k_RED],HK_FL,colors_f[k_YELLOW],tmock->str_namefunc,DEFAULT_K, 
             number_call_translate(tmock->init_times_left),

yftest/Makefile

@@ -0,0 +1,24 @@
+
+
+FTEST_SRC=src/ftest/ftest.c
+FTEST_O=$(FTEST_SRC:.c=.o)
+
+TOOLS_SRC=../ytools_t/src/tools_t/tools_t.c
+TOOLS_O=$(TOOLS_SRC:.c=.o)
+
+BARPROGES_SRC=../ybar_progress/src/bar_progress/bar_progress.c
+BARPROGES_O=$(BARPROGES_SRC:.c=.o)
+
+
+all: $(FTEST_O)
+
+
+$(FTEST_O): $(FTEST_SRC) $(TOOLS_O) $(BARPROGES_O)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+
+.PHONY: clean 
+
+clean:
+	rm -f $(FTEST_O)
+

yftest/include/ftest/ftest.h

@@ -0,0 +1,800 @@
+#ifndef __TEST_C_H__
+#define __TEST_C_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+//#include <time.h>
+#include <pthread.h>
+//#include <unistd.h>
+#include <sys/ioctl.h> /* to have size of screen, for progress bar */
+
+#include "tools_t/tools_t.h"
+#include "bar_progress/bar_progress.h"
+
+#define DEFAULT_K "\033[0m" /*Resets the text to default color*/
+#define GREEN_K "\033[0;32m" 
+#define RED_K "\033[0;31m"
+#define YELLOW_K "\033[0;33m"
+#define BLUE_K "\033[0;34m"
+#define NOTHING_K ""
+
+#define COLOR_SZ 6
+
+#define Dknothing COLOR_SZ - 1
+
+#define SZ_TAB_HK 8
+
+
+#ifdef HK
+  #define HK_EQ "[==========]"
+  #define HK_TR "[----------]"
+  #define HK_RN "[RUN       ]"
+  #define HK_DN "[      DONE]"
+  #define HK_OK "[       OK ]"
+  #define HK_FL "[  FAILED  ]"
+  #define HK_PS "[  PASSED  ]"
+  #define HK_SK "[  SKIP    ]"
+#else
+  #define HK_EQ "=========="
+  #define HK_TR "----------"
+  #define HK_RN "====== RUN"
+  #define HK_DN "===== DONE"
+  #define HK_OK "======= OK"
+  #define HK_FL "===== FAIL"
+  #define HK_PS "===== PASS"
+  #define HK_SK "===== SKIP"
+#endif /* HK */
+
+/*
+ * compare symbol
+ */
+#define EQ ==
+#define LT <
+#define GT >
+#define LE <=
+#define GE >=
+#define NE !=
+
+
+extern FILE **f_ou_th;
+extern bool unicolour;
+extern bool ordered;
+extern bool log_parallel;
+extern char *savelog;
+
+extern char *colors_f[];
+extern char *tab_hk_f[];
+
+extern int k_DEFAULT, k_GREEN, k_RED, k_YELLOW, k_BLUE, k_NOTHING;
+extern int hk_EQ, hk_TR, hk_RN, hk_DN, hk_OK, hk_FL, hk_PS, hk_SK;
+extern char *varHK_EQ, *varHK_TR, *varHK_RN, *varHK_DN, *varHK_OK, *varHK_FL, *varHK_PS, *varHK_SK;
+
+/* 
+ * */
+
+/*
+ *  to execute once in print functions in the case of log_parallel (printing on screen and recording in file), we have to copy to stream -> string before copy it, 
+ *  so I have tried using fopen a file in memory location '/dev/shm' and remove it after use!
+ *   /dev/shm/tmp_PTHREAD_SELF() but it prints twice sometimes, 
+ *  here a solution with open_memstream which is better 
+ */
+
+#define PRINTF( ...) \
+  do{ \
+      FILE *stream ;\
+      size_t len;\
+      char *buf ;\
+      stream = open_memstream (&buf, &len);\
+        if (stream == NULL) { fprintf(stderr," error open_memstream %s:%d:%s \n",__FILE__,__LINE__,__func__); exit(0); }\
+      fprintf(stream,  __VA_ARGS__); \
+      fflush(stream);\
+      if(is_parallel_nb){\
+        long int id_thread=id_of_thread_executed();\
+        if(log_parallel){\
+            fprintf(F_OUT, "%s",buf);\
+            if(id_thread >= 0){\
+              fprintf(f_ou_th[id_thread], "%s",buf);\
+              fflush(f_ou_th[id_thread]);\
+            }\
+        }\
+        else{\
+            if(id_thread >= 0){\
+              fprintf(f_ou_th[id_thread], "%s",buf);\
+              fflush(f_ou_th[id_thread]);\
+            }\
+            else {\
+              fprintf(F_OUT, "%s",buf);\
+            }\
+        }\
+      } \
+      else{\
+         if(savelog){\
+            FILE *f_savelog = fopen(savelog,"a");\
+            fprintf(f_savelog, "%s",buf);\
+            fclose(f_savelog);\
+         }\
+         fprintf(F_OUT, "%s",buf);\
+      }\
+      fclose(stream);\
+      free(buf);\
+  }while(0)
+
+
+#define LOG(...) PRINTF(__VA_ARGS__)
+
+#define PRINT_LOC(fmt, ...) \
+  PRINTF( "%s:%d:%s(): " fmt, __FILE__, __LINE__, __func__, __VA_ARGS__)
+
+
+#define PRINT_HK_C(color,hk,fmt,...)\
+ PRINTF("%s%s%s" fmt, color,hk,colors_f[k_DEFAULT],__VA_ARGS__)
+
+ 
+
+     
+/*
+ * to skip the bloc test function
+ */
+#define SKIP(fmt,...)\
+  PRINT_HK_C(colors_f[k_GREEN], HK_SK, fmt, ## __VA_ARGS__);\
+  PRINT_LOC("%s\n\n" DEFAULT_K," Skiped "); return;
+
+
+
+struct func {
+  char *name;
+  void (*run)(void);
+  struct func *next;
+};
+
+
+extern bool is_parallel_nb;
+
+long int id_of_thread_executed(void);
+
+void parse_options(int argc, char **argv);
+
+void run_all_tests();
+void execute_all(struct func *fun);
+void append_func(void (*run)(void), char *name);
+
+char* extract_func_edited_TEST_from_exec_func_name(char* func_name); /* TEST_funcname___NUM -> TEST(funcname) */
+
+/*
+void run_some_tests(size_t cnt, ... );
+void run_all_tests_exept(size_t cnt, ... );
+void run_some_tests_ordered(size_t cnt, ... );
+*/
+
+void run_all_tests_parallel(size_t parallel /*, int max_col*/);
+
+/* 
+ * to launch test with different parameters without re-compile it  
+ * it can print help if need!
+ * */
+void run_all_tests_args(int argc, char **argv);
+
+bool expected_true_f(bool val);
+bool expected_false_f(bool val);
+
+bool expected_true_f_name(bool val, const char *name);
+bool expected_false_f_name(bool val, const char *name);
+
+#define GEN_EXPECTED_OP_TYPE_FUNC(OP,type)\
+  bool expected_##OP##_##type(type var1, type var2);\
+  bool expected_##OP##_name_##type(type var1, type var2, const char *name); 
+
+
+/*
+ * ***** generate signature of expected functions EQ ***********
+ */ 
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_U_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_U_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_U_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_SIZE_T)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_FLOAT)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_L_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(EQ, TYPE_STRING)
+/* 
+ * ********************  end EQ generation ************************
+ */ 
+
+
+/*
+ * ***** generate signature of expected functions LT ***********
+ */ 
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_U_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_U_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_U_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_SIZE_T)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_FLOAT)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_L_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(LT, TYPE_STRING)
+/* 
+ * ********************  end LT generation ************************
+ */ 
+
+
+/*
+ * ***** generate signature of expected functions GT ***********
+ */ 
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_U_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_U_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_U_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_SIZE_T)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_FLOAT)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_L_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(GT, TYPE_STRING)
+/* 
+ * ********************  end GT generation ************************
+ */ 
+
+
+/*
+ * ***** generate signature of expected functions LE ***********
+ */ 
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_U_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_U_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_U_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_SIZE_T)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_FLOAT)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_L_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(LE, TYPE_STRING)
+/* 
+ * ********************  end LE generation ************************
+ */ 
+
+
+/*
+ * ***** generate signature of expected functions GE ***********
+ */ 
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_U_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_U_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_U_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_SIZE_T)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_FLOAT)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_L_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(GE, TYPE_STRING)
+/* 
+ * ********************  end GE generation ************************
+ */ 
+
+
+/*
+ * ***** generate signature of expected functions NE ***********
+ */ 
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_U_CHAR)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_U_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_U_L_INT)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_SIZE_T)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_FLOAT)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_L_DOUBLE)
+GEN_EXPECTED_OP_TYPE_FUNC(NE, TYPE_STRING)
+/* 
+ * ********************  end NE generation ************************
+ */
+
+/*
+ * only expect
+ */
+#define HANDLE_OP_EXPECT_NAME(OP,type,var1,var2,name_f,msg_call)                                                          \
+do{      \
+   if(is_parallel_nb == 0){\
+      if(expected_##OP##_##type(var1, var2)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 %s passed %s \n\n",name_f,msg_call);                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+          ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));  */                                          \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 %s failed %s \n",name_f,msg_call);                                           \
+      }                                                                                                         \
+   }else {                                                                                                         \
+      if(expected_##OP##_name_##type(var1, var2, name_f)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 %s passed %s \n\n",name_f,msg_call);                                       \
+        /*PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed %s \n\n",name_f);*/                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+         ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));*/                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 %s failed %s \n",name_f,msg_call);                                           \
+      }                                                                                                         \
+    }\
+}while(0);
+
+//#define EXPECT_OP_(OP,type,var1,var2)  HANDLE_OP_EXPECT_(OP,type,var1,var2)
+  
+  /**
+   * old combined macros HANDLE_OP_EXPECT_ASSERT for ASSERT and EXPECT
+   * is_assert : 0 for EXPECT and 1 for ASSERT 
+   */
+#define HANDLE_OP_EXPECT_ASSERT(OP,type,var1,var2,is_assert)                                                          \
+do{      \
+   if(is_parallel_nb == 0){\
+      if(expected_##OP##_##type(var1, var2)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+          ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));  */                                          \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                           \
+        if(is_assert) return;                                                                                   \
+      }                                                                                                         \
+   }else {                                                                                                         \
+      if(expected_##OP##_name_##type(var1, var2, __func__)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+         ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));*/                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                           \
+        if(is_assert) return;                                                                                   \
+      }                                                                                                         \
+    }\
+}while(0);
+
+// *******************************************************************************************************************
+  
+  /**
+   * new HANDLE_OP_ EXPECT and ASSERT separated
+   */
+#define HANDLE_OP_EXPECT_(OP,type,var1,var2)                                                          \
+do{      \
+   if(is_parallel_nb == 0){\
+      if(expected_##OP##_##type(var1, var2)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+          ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));  */                                          \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                           \
+      }                                                                                                         \
+   }else {                                                                                                         \
+      if(expected_##OP##_name_##type(var1, var2, __func__)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+         ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));*/                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                           \
+      }                                                                                                         \
+    }\
+}while(0);
+
+#define HANDLE_OP_ASSERT_(OP,type,var1,var2)                                                          \
+do{      \
+   if(is_parallel_nb == 0){\
+      if(expected_##OP##_##type(var1, var2)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+          ,DESCRIPTION_##OP,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));  */                                          \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                           \
+        return;                                                                                   \
+      }                                                                                                         \
+   }else {                                                                                                         \
+      if(expected_##OP##_name_##type(var1, var2, __func__)){                                                                       \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                                       \
+      }                                                                                                         \
+      else{                                                                                                     \
+        /*PRINT_LOC("Failure\nExpected %s of these values:\n   %s\n\tWhich is:  %s\n %s\n\tWhich is: %s\n\n"\
+         ,DESCRIPTION_##OP ,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));*/                                            \
+        PRINT_LOC("Failure\nExpected: (%s) %s (%s) :\n Value of %s: %s \n Value of %s: %s\n\n"\
+          ,#var1,STRFY(OP),#var2,#var1, type##_TO_STR(var1),  #var2, type##_TO_STR(var2));                                            \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                           \
+        return;                                                                                   \
+      }                                                                                                         \
+    }\
+}while(0);
+
+
+
+// ********************************************************************************************************************
+
+  
+// *********************** begin EQ  ************************ 
+// ============== EXPECT ==============================
+
+#define EXPECT_EQ_TYPE_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_CHAR,var1, var2)
+#define EXPECT_EQ_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_U_CHAR,var1, var2)
+#define EXPECT_EQ_TYPE_INT(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_INT,var1, var2)
+#define EXPECT_EQ_TYPE_U_INT(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_U_INT,var1, var2)
+#define EXPECT_EQ_TYPE_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_L_INT,var1, var2)
+#define EXPECT_EQ_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_U_L_INT,var1, var2)
+#define EXPECT_EQ_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_SIZE_T,var1, var2)
+#define EXPECT_EQ_TYPE_FLOAT(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_FLOAT,var1, var2)
+#define EXPECT_EQ_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_DOUBLE,var1, var2)
+#define EXPECT_EQ_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_L_DOUBLE,var1, var2)
+#define EXPECT_EQ_TYPE_STRING(var1, var2) 	HANDLE_OP_EXPECT_(EQ, TYPE_STRING,var1, var2)
+
+#define EXPECT_EQ(var1, var2) HANDLE_OP_EXPECT_(EQ, TYPE_L_INT,var1, var2)
+
+
+
+// ============== ASERT =====================
+
+#define ASSERT_EQ_TYPE_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_CHAR,var1, var2)
+#define ASSERT_EQ_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_U_CHAR,var1, var2)
+#define ASSERT_EQ_TYPE_INT(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_INT,var1, var2)
+#define ASSERT_EQ_TYPE_U_INT(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_U_INT,var1, var2)
+#define ASSERT_EQ_TYPE_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_L_INT,var1, var2)
+#define ASSERT_EQ_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_U_L_INT,var1, var2)
+#define ASSERT_EQ_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_SIZE_T,var1, var2)
+#define ASSERT_EQ_TYPE_FLOAT(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_FLOAT,var1, var2)
+#define ASSERT_EQ_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_DOUBLE,var1, var2)
+#define ASSERT_EQ_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_L_DOUBLE,var1, var2)
+#define ASSERT_EQ_TYPE_STRING(var1, var2) 	HANDLE_OP_ASSERT_(EQ, TYPE_STRING,var1, var2)
+
+#define ASSERT_EQ(var1, var2)  HANDLE_OP_ASSERT_(EQ, TYPE_L_INT,var1, var2)
+
+// ************************ end EQ  **********************
+
+
+// *********************** begin LT  ************************ 
+// ============== EXPECT ==============================
+
+#define EXPECT_LT_TYPE_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_CHAR,var1, var2)
+#define EXPECT_LT_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_U_CHAR,var1, var2)
+#define EXPECT_LT_TYPE_INT(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_INT,var1, var2)
+#define EXPECT_LT_TYPE_U_INT(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_U_INT,var1, var2)
+#define EXPECT_LT_TYPE_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_L_INT,var1, var2)
+#define EXPECT_LT_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_U_L_INT,var1, var2)
+#define EXPECT_LT_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_SIZE_T,var1, var2)
+#define EXPECT_LT_TYPE_FLOAT(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_FLOAT,var1, var2)
+#define EXPECT_LT_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_DOUBLE,var1, var2)
+#define EXPECT_LT_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_L_DOUBLE,var1, var2)
+#define EXPECT_LT_TYPE_STRING(var1, var2) 	HANDLE_OP_EXPECT_(LT, TYPE_STRING,var1, var2)
+
+#define EXPECT_LT(var1, var2) HANDLE_OP_EXPECT_(LT, TYPE_L_INT,var1, var2)
+
+
+// ============== ASERT =====================
+
+#define ASSERT_LT_TYPE_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_CHAR,var1, var2)
+#define ASSERT_LT_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_U_CHAR,var1, var2)
+#define ASSERT_LT_TYPE_INT(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_INT,var1, var2)
+#define ASSERT_LT_TYPE_U_INT(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_U_INT,var1, var2)
+#define ASSERT_LT_TYPE_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_L_INT,var1, var2)
+#define ASSERT_LT_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_U_L_INT,var1, var2)
+#define ASSERT_LT_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_SIZE_T,var1, var2)
+#define ASSERT_LT_TYPE_FLOAT(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_FLOAT,var1, var2)
+#define ASSERT_LT_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_DOUBLE,var1, var2)
+#define ASSERT_LT_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_L_DOUBLE,var1, var2)
+#define ASSERT_LT_TYPE_STRING(var1, var2) 	HANDLE_OP_ASSERT_(LT, TYPE_STRING,var1, var2)
+
+#define ASSERT_LT(var1, var2)  HANDLE_OP_ASSERT_(LT, TYPE_L_INT,var1, var2)
+
+// ************************ end LT  **********************
+
+
+// *********************** begin GT  ************************ 
+// ============== EXPECT ==============================
+
+#define EXPECT_GT_TYPE_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_CHAR,var1, var2)
+#define EXPECT_GT_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_U_CHAR,var1, var2)
+#define EXPECT_GT_TYPE_INT(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_INT,var1, var2)
+#define EXPECT_GT_TYPE_U_INT(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_U_INT,var1, var2)
+#define EXPECT_GT_TYPE_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_L_INT,var1, var2)
+#define EXPECT_GT_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_U_L_INT,var1, var2)
+#define EXPECT_GT_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_SIZE_T,var1, var2)
+#define EXPECT_GT_TYPE_FLOAT(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_FLOAT,var1, var2)
+#define EXPECT_GT_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_DOUBLE,var1, var2)
+#define EXPECT_GT_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_L_DOUBLE,var1, var2)
+#define EXPECT_GT_TYPE_STRING(var1, var2) 	HANDLE_OP_EXPECT_(GT, TYPE_STRING,var1, var2)
+
+#define EXPECT_GT(var1, var2) HANDLE_OP_EXPECT_(GT, TYPE_L_INT,var1, var2)
+
+
+
+// ============== ASERT =====================
+
+#define ASSERT_GT_TYPE_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_CHAR,var1, var2)
+#define ASSERT_GT_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_U_CHAR,var1, var2)
+#define ASSERT_GT_TYPE_INT(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_INT,var1, var2)
+#define ASSERT_GT_TYPE_U_INT(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_U_INT,var1, var2)
+#define ASSERT_GT_TYPE_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_L_INT,var1, var2)
+#define ASSERT_GT_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_U_L_INT,var1, var2)
+#define ASSERT_GT_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_SIZE_T,var1, var2)
+#define ASSERT_GT_TYPE_FLOAT(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_FLOAT,var1, var2)
+#define ASSERT_GT_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_DOUBLE,var1, var2)
+#define ASSERT_GT_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_L_DOUBLE,var1, var2)
+#define ASSERT_GT_TYPE_STRING(var1, var2) 	HANDLE_OP_ASSERT_(GT, TYPE_STRING,var1, var2)
+
+#define ASSERT_GT(var1, var2)  HANDLE_OP_ASSERT_(GT, TYPE_L_INT,var1, var2)
+
+// ************************ end GT  **********************
+
+
+// *********************** begin LE  ************************ 
+// ============== EXPECT ==============================
+
+#define EXPECT_LE_TYPE_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_CHAR,var1, var2)
+#define EXPECT_LE_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_U_CHAR,var1, var2)
+#define EXPECT_LE_TYPE_INT(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_INT,var1, var2)
+#define EXPECT_LE_TYPE_U_INT(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_U_INT,var1, var2)
+#define EXPECT_LE_TYPE_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_L_INT,var1, var2)
+#define EXPECT_LE_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_U_L_INT,var1, var2)
+#define EXPECT_LE_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_SIZE_T,var1, var2)
+#define EXPECT_LE_TYPE_FLOAT(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_FLOAT,var1, var2)
+#define EXPECT_LE_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_DOUBLE,var1, var2)
+#define EXPECT_LE_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_L_DOUBLE,var1, var2)
+#define EXPECT_LE_TYPE_STRING(var1, var2) 	HANDLE_OP_EXPECT_(LE, TYPE_STRING,var1, var2)
+
+#define EXPECT_LE(var1, var2) HANDLE_OP_EXPECT_(LE, TYPE_L_INT,var1, var2)
+
+
+
+// ============== ASERT =====================
+
+#define ASSERT_LE_TYPE_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_CHAR,var1, var2)
+#define ASSERT_LE_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_U_CHAR,var1, var2)
+#define ASSERT_LE_TYPE_INT(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_INT,var1, var2)
+#define ASSERT_LE_TYPE_U_INT(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_U_INT,var1, var2)
+#define ASSERT_LE_TYPE_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_L_INT,var1, var2)
+#define ASSERT_LE_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_U_L_INT,var1, var2)
+#define ASSERT_LE_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_SIZE_T,var1, var2)
+#define ASSERT_LE_TYPE_FLOAT(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_FLOAT,var1, var2)
+#define ASSERT_LE_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_DOUBLE,var1, var2)
+#define ASSERT_LE_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_L_DOUBLE,var1, var2)
+#define ASSERT_LE_TYPE_STRING(var1, var2) 	HANDLE_OP_ASSERT_(LE, TYPE_STRING,var1, var2)
+
+#define ASSERT_LE(var1, var2)  HANDLE_OP_ASSERT_(LE, TYPE_L_INT,var1, var2)
+
+// ************************ end LE  **********************
+
+
+// *********************** begin GE  ************************ 
+// ============== EXPECT ==============================
+
+#define EXPECT_GE_TYPE_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_CHAR,var1, var2)
+#define EXPECT_GE_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_U_CHAR,var1, var2)
+#define EXPECT_GE_TYPE_INT(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_INT,var1, var2)
+#define EXPECT_GE_TYPE_U_INT(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_U_INT,var1, var2)
+#define EXPECT_GE_TYPE_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_L_INT,var1, var2)
+#define EXPECT_GE_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_U_L_INT,var1, var2)
+#define EXPECT_GE_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_SIZE_T,var1, var2)
+#define EXPECT_GE_TYPE_FLOAT(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_FLOAT,var1, var2)
+#define EXPECT_GE_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_DOUBLE,var1, var2)
+#define EXPECT_GE_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_L_DOUBLE,var1, var2)
+#define EXPECT_GE_TYPE_STRING(var1, var2) 	HANDLE_OP_EXPECT_(GE, TYPE_STRING,var1, var2)
+
+#define EXPECT_GE(var1, var2) HANDLE_OP_EXPECT_(GE, TYPE_L_INT,var1, var2)
+
+
+
+// ============== ASERT =====================
+
+#define ASSERT_GE_TYPE_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_CHAR,var1, var2)
+#define ASSERT_GE_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_U_CHAR,var1, var2)
+#define ASSERT_GE_TYPE_INT(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_INT,var1, var2)
+#define ASSERT_GE_TYPE_U_INT(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_U_INT,var1, var2)
+#define ASSERT_GE_TYPE_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_L_INT,var1, var2)
+#define ASSERT_GE_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_U_L_INT,var1, var2)
+#define ASSERT_GE_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_SIZE_T,var1, var2)
+#define ASSERT_GE_TYPE_FLOAT(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_FLOAT,var1, var2)
+#define ASSERT_GE_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_DOUBLE,var1, var2)
+#define ASSERT_GE_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_L_DOUBLE,var1, var2)
+#define ASSERT_GE_TYPE_STRING(var1, var2) 	HANDLE_OP_ASSERT_(GE, TYPE_STRING,var1, var2)
+
+#define ASSERT_GE(var1, var2)  HANDLE_OP_ASSERT_(GE, TYPE_L_INT,var1, var2)
+
+// ************************ end GE  **********************
+
+
+// *********************** begin NE  ************************ 
+// ============== EXPECT ==============================
+
+#define EXPECT_NE_TYPE_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_CHAR,var1, var2)
+#define EXPECT_NE_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_U_CHAR,var1, var2)
+#define EXPECT_NE_TYPE_INT(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_INT,var1, var2)
+#define EXPECT_NE_TYPE_U_INT(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_U_INT,var1, var2)
+#define EXPECT_NE_TYPE_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_L_INT,var1, var2)
+#define EXPECT_NE_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_U_L_INT,var1, var2)
+#define EXPECT_NE_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_SIZE_T,var1, var2)
+#define EXPECT_NE_TYPE_FLOAT(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_FLOAT,var1, var2)
+#define EXPECT_NE_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_DOUBLE,var1, var2)
+#define EXPECT_NE_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_L_DOUBLE,var1, var2)
+#define EXPECT_NE_TYPE_STRING(var1, var2) 	HANDLE_OP_EXPECT_(NE, TYPE_STRING,var1, var2)
+
+#define EXPECT_NE(var1, var2) HANDLE_OP_EXPECT_(NE, TYPE_L_INT,var1, var2)
+
+
+
+// ============== ASERT =====================
+
+#define ASSERT_NE_TYPE_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_CHAR,var1, var2)
+#define ASSERT_NE_TYPE_U_CHAR(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_U_CHAR,var1, var2)
+#define ASSERT_NE_TYPE_INT(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_INT,var1, var2)
+#define ASSERT_NE_TYPE_U_INT(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_U_INT,var1, var2)
+#define ASSERT_NE_TYPE_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_L_INT,var1, var2)
+#define ASSERT_NE_TYPE_U_L_INT(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_U_L_INT,var1, var2)
+#define ASSERT_NE_TYPE_SIZE_T(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_SIZE_T,var1, var2)
+#define ASSERT_NE_TYPE_FLOAT(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_FLOAT,var1, var2)
+#define ASSERT_NE_TYPE_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_DOUBLE,var1, var2)
+#define ASSERT_NE_TYPE_L_DOUBLE(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_L_DOUBLE,var1, var2)
+#define ASSERT_NE_TYPE_STRING(var1, var2) 	HANDLE_OP_ASSERT_(NE, TYPE_STRING,var1, var2)
+
+#define ASSERT_NE(var1, var2)  HANDLE_OP_ASSERT_(NE, TYPE_L_INT,var1, var2)
+
+// ************************ end NE  **********************
+
+/*
+ * ==============  bool ===================
+ * bellow old combined EXPECT and ASSERT macros
+ */
+
+#define HANDLE_EXPECT_NOT_EXPECT_ASSERT(expect,not_expect,var1,is_assert)                             \
+do{                                                                                               \
+   if(is_parallel_nb==0){\
+      if(expected_##expect##_f(var1)){                                                                \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                             \
+      }                                                                                               \
+      else{                                                                                           \
+        PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                 \
+        if(is_assert) return;                                                                         \
+      }                                                                                               \
+  }\
+  else{\
+      if(expected_##expect##_f_name(var1, __func__)){                                                                \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                             \
+      }                                                                                               \
+      else{                                                                                           \
+        PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n",__func__);                                 \
+        if(is_assert) return;                                                                         \
+      }                                                                                               \
+  }\
+}while(0);
+
+// *******************************************************************************************************
+/*
+ * new macro HANDEL ASSERT and EXPECT separated
+ */
+#define HANDLE_EXPECT_NOT_EXPECT_(expect,not_expect,var1)                                             \
+do{                                                                                                   \
+   if(is_parallel_nb==0){                                                                             \
+      if(expected_##expect##_f(var1)){                                                                \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                             \
+      }                                                                                               \
+      else{                                                                                           \
+        PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect);  \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n\n",__func__);                               \
+      }                                                                                               \
+  }                                                                                                   \
+  else{                                                                                               \
+    size_t id_thread=id_of_thread_executed();                                                         \
+      if(expected_##expect##_f_name(var1, __func__)){                                                 \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s, on thread[%ld]\n\n",__func__,id_thread);    \
+      }                                                                                               \
+      else{                                                                                           \
+        PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect);  \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s, on thread[%ld]\n\n",__func__,id_thread);      \
+      }                                                                                               \
+  }                                                                                                   \
+}while(0);
+
+
+#define HANDLE_ASSERT_EXPECT_NOT_EXPECT_(expect,not_expect,var1)                                      \
+do{                                                                                                   \
+   if(is_parallel_nb==0){                                                                             \
+      if(expected_##expect##_f(var1)){                                                                \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s \n\n",__func__);                             \
+      }                                                                                               \
+      else{                                                                                           \
+        PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n", #var1, #not_expect, #expect);  \
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s \n\n",__func__);                               \
+        return;                                                                                       \
+      }                                                                                               \
+  }\
+  else{\
+    size_t id_thread=id_of_thread_executed();                                                         \
+      if(expected_##expect##_f_name(var1, __func__)){                                                 \
+        PRINT_HK_C(colors_f[k_GREEN],HK_TR," 1 test passed from %s, on thread[%ld]\n\n",__func__,id_thread);    \
+      }                                                                                               \
+      else{                                                                                           \
+        PRINT_LOC("Failure\nValue of: %s\nActual: %s\nExpected: %s\n\n", #var1, #not_expect, #expect);\
+        PRINT_HK_C(colors_f[k_RED],HK_TR," 1 test failed from %s, on thread[%ld]\n\n",__func__, id_thread);     \
+        return;                                                                                       \
+      }                                                                                               \
+  }\
+}while(0);
+
+
+// *******************************************************************************************************  
+#define EXPECT_TRUE(var1) HANDLE_EXPECT_NOT_EXPECT_(true, false, var1)
+#define EXPECT_FALSE(var1) HANDLE_EXPECT_NOT_EXPECT_(false, true, var1)
+
+#define ASSERT_TRUE(var1) HANDLE_ASSERT_EXPECT_NOT_EXPECT_(true, false, var1)
+#define ASSERT_FALSE(var1) HANDLE_ASSERT_EXPECT_NOT_EXPECT_(false, true, var1)
+
+
+//********************************************************************************
+
+/*  
+#define EXPECT_TRUE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(true, false, var1, 0)
+#define EXPECT_FALSE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(false, true, var1, 0)
+
+#define ASSERT_TRUE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(true, false, var1, 1)
+#define ASSERT_FALSE(var1) HANDLE_EXPECT_NOT_EXPECT_ASSERT(false, true, var1, 1)
+*/
+
+
+#define CONCAT(x,y) x ## y
+#define STRFY(x) # x 
+
+//#define test_label test
+
+#define FTEST_(count, name_f)                                                 \
+  void CONCAT(test_##name_f##____,count)(void);                               \
+  __attribute__((constructor))                                                \
+  void CONCAT(append_test_##name_f,count)(void){                              \
+    append_func(CONCAT(test_##name_f##____,count),STRFY(name_f test count));  \
+  }                                                                           \
+  void CONCAT(test_##name_f##____,count)(void)
+ 
+#define FTEST__(count, name_f)                                                \
+  void CONCAT(TEST_##name_f##____,count)(void);                                       \
+  __attribute__((constructor))                                                \
+  void CONCAT(append_test_##name_f,count)(void){                              \
+    append_func(CONCAT(TEST_##name_f##____,count),STRFY (TEST(name_f): test N° count| ) );          \
+  }                                                                           \
+  void CONCAT(TEST_##name_f##____,count)(void)
+
+
+/*#define TEST(name_f)\
+  FTEST_(__COUNTER__,name_f)
+*/
+
+#define TEST(name_f)                                            \
+  FTEST__(__COUNTER__,name_f)
+
+/*  
+#define ASSERT_TRUE(val)\
+  if(expected_true_f(val,#val,__func__) == false) {error_print("%s\n\n","Failure"); return;}
+  
+#define ASSERT_FALSE(val)\
+  if(expected_false_f(val,#val,__func__) == false) {error_print("%s\n\n","Failure"); return;}
+*/
+
+#endif /* __TEST_C_H__ */

yftest/src/ftest/ftest.c

@@ -783,9 +783,10 @@ void bar_progress_test_(){
 void*
 run_progress_tests(void *max_d)
 {
-   int max_col = 80; //*(int*)max_d;
+   /*int max_col = 80;*/ //*(int*)max_d;
    //progress_test_(max_col);
    bar_progress_test_();
+   return (void*)0;
 }
 
 
@@ -1123,6 +1124,7 @@ run_parallel_tests(void *id)
    head_parallel_run(&start_t, id_th);
    execute_test_parallel(id_th);
    stat_end_parallel_run(count_fail_thread[id_th]+count_pass_thread[id_th], start_t, id_th);
+   return (void*)0;
 }
 
 /*

ytools_t/Makefile

@@ -0,0 +1,17 @@
+
+
+TOOLS_SRC=src/tools_t/tools_t.c
+TOOLS_O=$(TOOLS_SRC:.c=.o)
+
+
+all: $(TOOLS_O)
+
+$(TOOLS_O): $(TOOLS_SRC)
+	$(CC) -o $@ -c $< $(CFLAGS)
+
+
+.PHONY: clean 
+
+clean:
+	rm -f $(TOOLS_O)
+

ytools_t/include/tools_t/tools_t.h

@@ -0,0 +1,119 @@
+#ifndef __TOOLS_T_C_H__
+#define __TOOLS_T_C_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <time.h>
+
+// to define DEBUG in gcc cli do: gcc -D DEBUG=1 or 0 if need!
+#ifndef DEBUG
+  #define DEBUG 0
+#endif
+
+
+// F_OUT file (stream) to log
+#ifndef F_OUT
+  #define F_OUT stdout
+#endif
+// F_ERR file (stream) to log
+#ifndef F_ERR
+  #define F_ERR stderr
+#endif
+
+
+
+/*
+#ifndef SECOND
+  #define SECOND 0
+#endif
+#ifndef NANOSECOND
+  #define NANOSECOND 0
+#endif
+
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
+*/
+
+void gotoxy(int x, int y);
+//void get_cursor_position(int *col, int *rows);
+
+
+#define debug_print(fmt, ...) \
+  do { if (DEBUG) fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); } while (0)
+
+#define PRINT_DEBUG(fmt, ...) \
+  do { if (DEBUG) fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); } while (0)
+
+
+#define error_print(fmt, ...) \
+   fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+#define PRINT_ERROR(fmt, ...) \
+   fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+#define PRINT_LOC_T(fmt, ...) \
+   fprintf(F_OUT, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+
+
+#define TYPE_CHAR char
+#define TYPE_U_CHAR unsigned char
+#define TYPE_INT int
+#define TYPE_U_INT unsigned int
+#define TYPE_L_INT long int
+#define TYPE_U_L_INT unsigned long int
+#define TYPE_SIZE_T size_t
+#define TYPE_FLOAT float
+#define TYPE_DOUBLE double
+#define TYPE_L_DOUBLE long double
+#define TYPE_STRING char*
+
+#define FREE(x)  { free((x)); (x) = NULL;} 
+
+#define FOREACH(array, size, function)\
+  for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]);
+
+
+#define GENERATE_ALL(type)\
+  int COMPARE_N_##type(const void *,const    void*);\
+  void COPY_ARRAY_##type(type* dst, const type* src, size_t size);\
+  type MAX_ARRAY_##type(const  type *array, size_t size);\
+  size_t ARG_MAX_ARRAY_##type(const type *array, size_t size);\
+  type MIN_ARRAY_##type(const  type *array, size_t size);\
+  size_t ARG_MIN_ARRAY_##type(const  type *array, size_t size);\
+  TYPE_STRING type##_TO_STR(type var);\
+  
+
+GENERATE_ALL(TYPE_CHAR)
+GENERATE_ALL(TYPE_U_CHAR)
+GENERATE_ALL(TYPE_INT)
+GENERATE_ALL(TYPE_U_INT)
+GENERATE_ALL(TYPE_L_INT)
+GENERATE_ALL(TYPE_U_L_INT)
+GENERATE_ALL(TYPE_SIZE_T)
+GENERATE_ALL(TYPE_FLOAT)
+GENERATE_ALL(TYPE_DOUBLE)
+GENERATE_ALL(TYPE_L_DOUBLE)
+GENERATE_ALL(TYPE_STRING)
+
+
+/*
+ * time calucl
+ */
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
+
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
+
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
+
+
+#endif /*__TOOLS_T_C_H__*/
+

ytools_t/src/tools_t/tools_t.h

@@ -0,0 +1,119 @@
+#ifndef __TOOLS_T_C_H__
+#define __TOOLS_T_C_H__
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <time.h>
+
+// to define DEBUG in gcc cli do: gcc -D DEBUG=1 or 0 if need!
+#ifndef DEBUG
+  #define DEBUG 0
+#endif
+
+
+// F_OUT file (stream) to log
+#ifndef F_OUT
+  #define F_OUT stdout
+#endif
+// F_ERR file (stream) to log
+#ifndef F_ERR
+  #define F_ERR stderr
+#endif
+
+
+
+/*
+#ifndef SECOND
+  #define SECOND 0
+#endif
+#ifndef NANOSECOND
+  #define NANOSECOND 0
+#endif
+
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
+*/
+
+void gotoxy(int x, int y);
+//void get_cursor_position(int *col, int *rows);
+
+
+#define debug_print(fmt, ...) \
+  do { if (DEBUG) fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); } while (0)
+
+#define PRINT_DEBUG(fmt, ...) \
+  do { if (DEBUG) fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); } while (0)
+
+
+#define error_print(fmt, ...) \
+   fprintf(stderr, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+#define PRINT_ERROR(fmt, ...) \
+   fprintf(F_ERR, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+#define PRINT_LOC_T(fmt, ...) \
+   fprintf(F_OUT, "%s:%d:%s(): " fmt, __FILE__, \
+      __LINE__, __func__, __VA_ARGS__); 
+
+
+
+#define TYPE_CHAR char
+#define TYPE_U_CHAR unsigned char
+#define TYPE_INT int
+#define TYPE_U_INT unsigned int
+#define TYPE_L_INT long int
+#define TYPE_U_L_INT unsigned long int
+#define TYPE_SIZE_T size_t
+#define TYPE_FLOAT float
+#define TYPE_DOUBLE double
+#define TYPE_L_DOUBLE long double
+#define TYPE_STRING char*
+
+#define FREE(x)  { free((x)); (x) = NULL;} 
+
+#define FOREACH(array, size, function)\
+  for(size_t _ind = 0; _ind < size; ++_ind) function(array[_ind]);
+
+
+#define GENERATE_ALL(type)\
+  int COMPARE_N_##type(const void *,const    void*);\
+  void COPY_ARRAY_##type(type* dst, const type* src, size_t size);\
+  type MAX_ARRAY_##type(const  type *array, size_t size);\
+  size_t ARG_MAX_ARRAY_##type(const type *array, size_t size);\
+  type MIN_ARRAY_##type(const  type *array, size_t size);\
+  size_t ARG_MIN_ARRAY_##type(const  type *array, size_t size);\
+  TYPE_STRING type##_TO_STR(type var);\
+  
+
+GENERATE_ALL(TYPE_CHAR)
+GENERATE_ALL(TYPE_U_CHAR)
+GENERATE_ALL(TYPE_INT)
+GENERATE_ALL(TYPE_U_INT)
+GENERATE_ALL(TYPE_L_INT)
+GENERATE_ALL(TYPE_U_L_INT)
+GENERATE_ALL(TYPE_SIZE_T)
+GENERATE_ALL(TYPE_FLOAT)
+GENERATE_ALL(TYPE_DOUBLE)
+GENERATE_ALL(TYPE_L_DOUBLE)
+GENERATE_ALL(TYPE_STRING)
+
+
+/*
+ * time calucl
+ */
+double diff_timespec_seconds(struct timespec time_stop, struct timespec time_start);
+
+double diff_timespec_milliseconds(struct timespec time_stop, struct timespec time_start);
+
+long diff_timespec_nanoseconds(struct timespec time_stop, struct timespec time_start);
+
+
+#endif /*__TOOLS_T_C_H__*/
+