268 lines
8.0 KiB
Markdown
268 lines
8.0 KiB
Markdown
# FTEST_C
|
|
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 the example
|
|
```
|
|
cd test
|
|
make
|
|
./launch_is_good_m
|
|
```
|
|
or
|
|
```
|
|
chmod +x compile.sh
|
|
./compile.sh "is_good.c"
|
|
./launch_is_good_c
|
|
```
|
|
## some compile options
|
|
### if need debug print
|
|
`./compile "s_good.c" "-D DEBUG=1"`
|
|
### if need gdb
|
|
`./compile "test/is_good.c" "-g"`
|
|
### if need prompt googletest like
|
|
`./compile "test/is_good.c" "-D HK"`
|
|
|
|
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
|
|
|
|
### help
|
|
`./launch_is_good_c -h`
|
|
```
|
|
usage: ./launch_is_good_c [OPTIONS] [<ARGS>]
|
|
|
|
or : ./launch_is_good_c [OPTIONS]=[<ARGS>]
|
|
|
|
OPTIONS
|
|
-h, --help
|
|
print help, options variables
|
|
|
|
-p <NB>, --parallel <NB>, -p=<NB>, --parallel=<NB>
|
|
by default the program ran in sequantial all test,
|
|
if this option is set, the program run tests on NB threads.
|
|
Each thread pull up one test out the list of all test not yet executed,
|
|
and execute it, until the list is empty
|
|
|
|
-t <unit>, --time <unit>, -t=<unit>, --time=<unit>
|
|
by default unit is millisecons ms, the other of unit are choices are second (or s), and nanosecond (or ns)
|
|
ex: -t ns or -t=nanosecond or --time=n to set nanosecond unit
|
|
|
|
-u , --unicolour
|
|
by default, the result is colored, if you choice this option, it prints with default color
|
|
|
|
-r , --remove
|
|
if the option parallel is choosen the result on each thread is record in separate files,
|
|
this option remove the file logs of each thread after all tests.
|
|
|
|
-s <file>, --savelog <file>, -s=file, --savelog=file
|
|
this option save the global ordered result in 'file',
|
|
|
|
|
|
-n=<NUM1>,<NUM2> <NUM3>... ,--numtests=<NUM1>,<NUM2>...
|
|
this option allow to execute only the selected numbers of tests (in the order in file test)
|
|
ex: -n=0,6,3 8 to execute the tests 0,3,6,8 (if the number is less than the count of all tests)
|
|
|
|
-l=<NAME1>,<NAME2> <NAME3>... ,--listests=<NAME1>,<NAME2>...<NAMEn>
|
|
this option allow to execute only the selected name of tests. It allows empty name by using '-l=,'
|
|
ex: -l=name0,,name2 : execute only (if they exist): TEST(name0),TEST(),TEST(name2)
|
|
|
|
-b <BPRGSS>, --bar_progress <BPRGSS>, -b=BPRGSS, --bar_progress=BPRGSS. Example: -b="#_c"
|
|
this option change progression bar if it is active. The first character ('#') fills the bar
|
|
the second char ('_') fills the other part of bar. the bar is colored if the 3rd char is 'c' and not if different.
|
|
by default the progress bar is active and the option is -b=" c", if need not colored, we can put -b=" n" option.
|
|
|
|
-z=<option>
|
|
this option is to set option=0,
|
|
for example, -z=progress is to not load progress bar, it is need if we want to redirect (pipe) the result to file.
|
|
other option: -z=log_parallel (to avoid logs not ordered when parallel tests which is loged by default)
|
|
```
|
|
|
|
For example, to launch tests (`test/is_good.c`) on 4 threads, using unicolor(black&white), and remove logs when all tests are done:
|
|
```
|
|
./launch_is_good_c -p 4 -r -u
|
|
```
|
|
|
|
|
|
# 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"
|
|
|
|
TEST(nametest){
|
|
EXPECT_EQ(1,1);
|
|
}
|
|
/* allow empty nametest, e.g*/
|
|
TEST(){}
|
|
/* allow duplicate name test, to have suit test */
|
|
TEST(){
|
|
EXPECT_TRUE(true);
|
|
}
|
|
```
|
|
|
|
## in main func
|
|
### if using options:
|
|
```
|
|
int main(int arc, char** argv){
|
|
run_all_tests_args(argc, argv);
|
|
return 0;
|
|
}
|
|
```
|
|
### if only use sequential tests
|
|
```
|
|
int main(){
|
|
run_all_tests();
|
|
return 0;
|
|
}
|
|
```
|
|
### if use only parrallel tests
|
|
```
|
|
int main(){
|
|
run_all_tests_parallel(4); /* to use 4 threads */
|
|
return 0;
|
|
}
|
|
```
|
|
|
|
# FMOCK
|
|
## How to create fmock
|
|
|
|
```
|
|
#include "fmock/fmock.h"
|
|
```
|
|
outside all functions:
|
|
```
|
|
MOCK_FUNC(returnType, name_function_mock,(prototype of the function with paranthesis),(args when call the funct with parathesis))
|
|
/* use (returnType) in parathesis if the returType has more than 1 words for example (long int) or (struct someStruct) */
|
|
```
|
|
For example, to create a function mock as signature:
|
|
```
|
|
int f_mock(int a,int b);
|
|
```
|
|
we use
|
|
```
|
|
MOCK_FUNC(int, f_mock,(int a,int b),(a,b))
|
|
```
|
|
args:
|
|
```
|
|
returnType: int,
|
|
name_function_mock: f_mock,
|
|
args prototype with paranthesis: (int a,int b),
|
|
args variable names with parathesis (same variable names as prototype): (a,b)
|
|
```
|
|
## print variables
|
|
We may define a function to print variables of the mock function, it is usefull in logs, the macro has almost the same args as MOCK_FUNC, without returnType wich is alway `char*`.
|
|
For example with `f_mock` we define:
|
|
```
|
|
STR_PRINT_CUR_VAR(f_mock, (int a,int b),(a,b)){
|
|
char *ret=malloc(150);
|
|
sprintf(ret,"(int)a: %d, (int)b: %d",a,b);
|
|
return ret;
|
|
}
|
|
```
|
|
## define expect call
|
|
```
|
|
EXPECT_MOCK_CALL(int, f_mock, (int a,int b), (a<b), 3){
|
|
return a+b;
|
|
}
|
|
```
|
|
args:
|
|
```
|
|
returnType: int,
|
|
name_function_mock: f_mock,
|
|
arg prototype of the function with paranthesis: (int a,int b),
|
|
conditions to check on args before calling the function:(bool expression): (a<b)
|
|
number of repetition response (number of call times): 3
|
|
```
|
|
## define will call
|
|
```
|
|
WILL_MOCK_CALL(int, f_mock, (int a,int b), (a==b), 1){
|
|
return a*b;
|
|
}
|
|
```
|
|
same args as EXPECT_MOCK_CALL, the difference is, the EXPECT_MOCK_CALL have to be call by the test earlier, but not WILL_MOCK_CALL.
|
|
|
|
## init call and call
|
|
in TEST environement, we may use macro `INIT_CALLER_MOCK(f_mock);` before calling `f_mock` to have explicit logs again!
|
|
|
|
Call function mock is the same as other normal functions.
|
|
|
|
Example:
|
|
```
|
|
TEST(f_mock_test){
|
|
INIT_CALLER_MOCK(f_mock);
|
|
PRINTF(" first call: %d\n",f_mock(2,3));
|
|
PRINTF(" second call: %d\n",f_mock(3,3));
|
|
}
|
|
```
|
|
# PRINTF
|
|
We may use standard printf function, but I provide a macro PRINTF to allow us record logs in files and also ordered logs when we use parallel tests.
|
|
|
|
args are the same as `printf` stdio.h function.
|
|
example:
|
|
```
|
|
PRINTF("hello\n");
|
|
```
|
|
I introduce also an alias `LOG` for `PRINTF`
|
|
|
|
|
|
|