diff --git a/Makefile b/Makefile index 1ea95f6..07473cc 100644 --- a/Makefile +++ b/Makefile @@ -1,63 +1,49 @@ - -NAME_TEST=is_good +# lib: -lytest +PROJECT_LIB=libytest.so CC=gcc -LDFLAGS=-lpthread #-D DEBUG=1 -ROOT_DIR=$(shell pwd) -INCLUDE_DIR=$(ROOT_DIR)/src -CFLAGS=-I$(INCLUDE_DIR) -SRC_DIR=$(ROOT_DIR)/src -#SRC=$(wildcard */*/*.c) -SRC=$(wildcard **/**/*.c) +#LDFLAGS= +INCLUDE_DIRS=$(PWD) +#$(wildcard $(PWD)/**/include) +INCLUDE=-I$(PWD)/yftest/include -I$(PWD)/yfmock/include -I$(PWD)/ytools_t/include -I$(PWD)/ybar_progress/include +CFLAGS=-lpthread -Wall -Werror -fpic $(INCLUDE) + +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) - $(CC) -o $@ $^ -I$(INCLUDE_DIR) $(LDFLAGS) +export -$(FMOCKSRC_O): $(FMOCKSRC) $(FTESTSRC_O) - $(CC) -o $@ -c $< $(CFLAGS) -$(FTESTSRC_O): $(FTESTSRC) $(TOOLSRC_O) - $(CC) -o $@ -c $< $(CFLAGS) +$(TOPTARGETS): $(SUBDIRS) -$(PERMSRC_O): $(PERMSRC) $(SETTSRC_O) - $(CC) -o $@ -c $< $(CFLAGS) +all: $(PROJECT_LIB) -$(SETTSRC_O) : $(SETTSRC) $(TOOLSRC_O) - $(CC) -o $@ -c $< $(CFLAGS) -$(TOOLSRC_O): $(TOOLSRC) - $(CC) -o $@ -c $< $(CFLAGS) +$(PROJECT_LIB): $(OBJ) + 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)" - echo "all obj : $(OBJ)" - rm -f $(OBJ) + rm -f $(PROJECT_LIB) -mrproper: clean - rm -f $(EXEC) +remove_headers: + rm -r include_ytest/* -run: $(EXEC) - $(EXEC) -h +#SRC_test=test/is_good.c + +#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 diff --git a/README.md b/README.md index 881ad61..be9ec67 100644 --- a/README.md +++ b/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: ``` diff --git a/compile.sh b/compile.sh deleted file mode 100755 index 21909b8..0000000 --- a/compile.sh +++ /dev/null @@ -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 diff --git a/src/bar_progress/bar_progress.h b/include_ytest/include/bar_progress/bar_progress.h similarity index 100% rename from src/bar_progress/bar_progress.h rename to include_ytest/include/bar_progress/bar_progress.h diff --git a/src/fmock/fmock.h b/include_ytest/include/fmock/fmock.h similarity index 100% rename from src/fmock/fmock.h rename to include_ytest/include/fmock/fmock.h diff --git a/src/ftest/ftest.h b/include_ytest/include/ftest/ftest.h similarity index 99% rename from src/ftest/ftest.h rename to include_ytest/include/ftest/ftest.h index 0eebbbd..9797e9c 100644 --- a/src/ftest/ftest.h +++ b/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) diff --git a/src/tools_t/tools_t.h b/include_ytest/include/tools_t/tools_t.h old mode 100755 new mode 100644 similarity index 100% rename from src/tools_t/tools_t.h rename to include_ytest/include/tools_t/tools_t.h diff --git a/kreate_library_ytest.sh b/kreate_library_ytest.sh new file mode 100644 index 0000000..bbe50e9 --- /dev/null +++ b/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 diff --git a/libytest.so b/libytest.so new file mode 100644 index 0000000..6248557 Binary files /dev/null and b/libytest.so differ diff --git a/src/fmock/cp0fmock.h b/src/fmock/cp0fmock.h deleted file mode 100644 index 191db7f..0000000 --- a/src/fmock/cp0fmock.h +++ /dev/null @@ -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__ */ diff --git a/src/launch_is_good b/src/launch_is_good deleted file mode 100755 index 4255fe2..0000000 Binary files a/src/launch_is_good and /dev/null differ diff --git a/test/Makefile b/test/Makefile new file mode 100644 index 0000000..c8f9214 --- /dev/null +++ b/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 diff --git a/test/compile.sh b/test/compile.sh new file mode 100644 index 0000000..1949482 --- /dev/null +++ b/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 diff --git a/test/is_good.c b/test/is_good.c index 082dabf..1c37377 100644 --- a/test/is_good.c +++ b/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);} diff --git a/src/Makefile b/test/src/Makefile similarity index 97% rename from src/Makefile rename to test/src/Makefile index 640288a..897eb11 100644 --- a/src/Makefile +++ b/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) diff --git a/src/coordinate/coordinate.h b/test/src/coordinate/coordinate.h similarity index 100% rename from src/coordinate/coordinate.h rename to test/src/coordinate/coordinate.h diff --git a/src/dimension/dimension.cpp b/test/src/dimension/dimension.cpp similarity index 100% rename from src/dimension/dimension.cpp rename to test/src/dimension/dimension.cpp diff --git a/src/dimension/dimension.h b/test/src/dimension/dimension.h old mode 100755 new mode 100644 similarity index 100% rename from src/dimension/dimension.h rename to test/src/dimension/dimension.h diff --git a/src/dimension/dimension.hpp b/test/src/dimension/dimension.hpp old mode 100755 new mode 100644 similarity index 100% rename from src/dimension/dimension.hpp rename to test/src/dimension/dimension.hpp diff --git a/src/is_good.c b/test/src/is_good.c similarity index 100% rename from src/is_good.c rename to test/src/is_good.c diff --git a/src/permutation_t/permutation_t.c b/test/src/permutation_t/permutation_t.c similarity index 100% rename from src/permutation_t/permutation_t.c rename to test/src/permutation_t/permutation_t.c diff --git a/src/permutation_t/permutation_t.h b/test/src/permutation_t/permutation_t.h similarity index 100% rename from src/permutation_t/permutation_t.h rename to test/src/permutation_t/permutation_t.h diff --git a/src/set_theoric_t/set_theoric_t.c b/test/src/set_theoric_t/set_theoric_t.c similarity index 100% rename from src/set_theoric_t/set_theoric_t.c rename to test/src/set_theoric_t/set_theoric_t.c diff --git a/src/set_theoric_t/set_theoric_t.h b/test/src/set_theoric_t/set_theoric_t.h similarity index 100% rename from src/set_theoric_t/set_theoric_t.h rename to test/src/set_theoric_t/set_theoric_t.h diff --git a/src/tensor/tens0neD/tens0neD.cpp b/test/src/tensor/tens0neD/tens0neD.cpp similarity index 100% rename from src/tensor/tens0neD/tens0neD.cpp rename to test/src/tensor/tens0neD/tens0neD.cpp diff --git a/src/tensor/tens0neD/tens0neD.h b/test/src/tensor/tens0neD/tens0neD.h similarity index 100% rename from src/tensor/tens0neD/tens0neD.h rename to test/src/tensor/tens0neD/tens0neD.h diff --git a/src/tensor/tensCuda/d_tensCuda.cu b/test/src/tensor/tensCuda/d_tensCuda.cu old mode 100755 new mode 100644 similarity index 100% rename from src/tensor/tensCuda/d_tensCuda.cu rename to test/src/tensor/tensCuda/d_tensCuda.cu diff --git a/src/tensor/tensCuda/d_tensCuda.h b/test/src/tensor/tensCuda/d_tensCuda.h similarity index 100% rename from src/tensor/tensCuda/d_tensCuda.h rename to test/src/tensor/tensCuda/d_tensCuda.h diff --git a/src/tensor/tensCuda/tensCuda.cu b/test/src/tensor/tensCuda/tensCuda.cu similarity index 100% rename from src/tensor/tensCuda/tensCuda.cu rename to test/src/tensor/tensCuda/tensCuda.cu diff --git a/src/tensor/tensCuda/tensCuda.h b/test/src/tensor/tensCuda/tensCuda.h similarity index 100% rename from src/tensor/tensCuda/tensCuda.h rename to test/src/tensor/tensCuda/tensCuda.h diff --git a/ybar_progress/Makefile b/ybar_progress/Makefile new file mode 100644 index 0000000..c06b690 --- /dev/null +++ b/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) + diff --git a/ybar_progress/include/bar_progress/bar_progress.h b/ybar_progress/include/bar_progress/bar_progress.h new file mode 100644 index 0000000..48a8928 --- /dev/null +++ b/ybar_progress/include/bar_progress/bar_progress.h @@ -0,0 +1,30 @@ +#ifndef __BAR_PROGRESS_H__ +#define __BAR_PROGRESS_H__ + +#include +#include +#include +//#include +#include +#include + + + +/* + * 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 */ diff --git a/src/bar_progress/bar_progress.c b/ybar_progress/src/bar_progress/bar_progress.c similarity index 99% rename from src/bar_progress/bar_progress.c rename to ybar_progress/src/bar_progress/bar_progress.c index 9731d2d..1b3c248 100644 --- a/src/bar_progress/bar_progress.c +++ b/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]='='; diff --git a/ybar_progress/src/bar_progress/bar_progress.h b/ybar_progress/src/bar_progress/bar_progress.h new file mode 100644 index 0000000..48a8928 --- /dev/null +++ b/ybar_progress/src/bar_progress/bar_progress.h @@ -0,0 +1,30 @@ +#ifndef __BAR_PROGRESS_H__ +#define __BAR_PROGRESS_H__ + +#include +#include +#include +//#include +#include +#include + + + +/* + * 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 */ diff --git a/yfmock/Makefile b/yfmock/Makefile new file mode 100644 index 0000000..f213508 --- /dev/null +++ b/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) + diff --git a/yfmock/include/fmock/fmock.h b/yfmock/include/fmock/fmock.h new file mode 100644 index 0000000..7ef12c0 --- /dev/null +++ b/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__ */ diff --git a/src/fmock/fmock.c b/yfmock/src/fmock/fmock.c similarity index 98% rename from src/fmock/fmock.c rename to yfmock/src/fmock/fmock.c index a4bfb96..5a0edf4 100644 --- a/src/fmock/fmock.c +++ b/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), diff --git a/yftest/Makefile b/yftest/Makefile new file mode 100644 index 0000000..b6b9a94 --- /dev/null +++ b/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) + diff --git a/yftest/include/ftest/ftest.h b/yftest/include/ftest/ftest.h new file mode 100644 index 0000000..9797e9c --- /dev/null +++ b/yftest/include/ftest/ftest.h @@ -0,0 +1,800 @@ +#ifndef __TEST_C_H__ +#define __TEST_C_H__ + +#include +#include +#include +#include +//#include +#include +//#include +#include /* 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__ */ diff --git a/src/ftest/ftest.c b/yftest/src/ftest/ftest.c similarity index 99% rename from src/ftest/ftest.c rename to yftest/src/ftest/ftest.c index b645017..2ada557 100644 --- a/src/ftest/ftest.c +++ b/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; } /* diff --git a/ytools_t/Makefile b/ytools_t/Makefile new file mode 100644 index 0000000..9259c90 --- /dev/null +++ b/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) + diff --git a/ytools_t/include/tools_t/tools_t.h b/ytools_t/include/tools_t/tools_t.h new file mode 100644 index 0000000..10607a4 --- /dev/null +++ b/ytools_t/include/tools_t/tools_t.h @@ -0,0 +1,119 @@ +#ifndef __TOOLS_T_C_H__ +#define __TOOLS_T_C_H__ + +#include +#include +#include +#include +#include + +// 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__*/ + diff --git a/src/tools_t/tools_t.c b/ytools_t/src/tools_t/tools_t.c similarity index 100% rename from src/tools_t/tools_t.c rename to ytools_t/src/tools_t/tools_t.c diff --git a/ytools_t/src/tools_t/tools_t.h b/ytools_t/src/tools_t/tools_t.h new file mode 100644 index 0000000..10607a4 --- /dev/null +++ b/ytools_t/src/tools_t/tools_t.h @@ -0,0 +1,119 @@ +#ifndef __TOOLS_T_C_H__ +#define __TOOLS_T_C_H__ + +#include +#include +#include +#include +#include + +// 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__*/ +