onefileheader_test/README.md

y_test_h

It is a copy of a project of test like gtest but write in C only.

But here, it suffice to copy one file "y_test_h.h" and include it in the test file, and add somme macro functions like IMPLEMENTATION_FTEST() to generate all ftest functions and IMPLEMENTATION_FMOCK() to generate all fmock functions.

How to create test (ftest)

Example

Example for this file test.c:

#include "y_test_h.h"
IMPLEMENTATION_FTEST()

TEST(nametest){ 
	EXPECT_EQ(1,1);
}
/* allow empty nametest, e.g*/
TEST(){}
/* allow duplicate name test, to have suit test */
TEST(){
	EXPECT_TRUE(true);
}

requirement

I write this program to work on linux, I do not test it on windows or mac!

$ ls
$ test.c y_test_h.h

compile

gcc -o exectest test.c

Normaly, it works with gcc and clang !

launch

./exectest

In function main

If using options:

int main(int arc, char** argv){
	run_all_tests_args(argc, argv);
	return 0;
}

We can add execution option like:

./exectest -h to print help

./exectest -p 5 to parallelize tests, using 5 threads.

./exectest launch sequential test (1 thread).

If using only sequential tests

int main(){
	run_all_tests();
	return 0;
}

./exectest does not read args!

If using only parrallel tests

int main(){
	run_all_tests_parallel(4); /* to use 4 threads */
	return 0;
}

./exectest does not read args!

FMOCK

We can create and predefined return function regarding the call and condition.

To simulate response of a function call !

How to create fmock

#include "y_test_h.h"
IMPLEMENTATION_FMOCK()

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 always 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 has to be called 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