y_test_h

This is a C-only testing library, similar to gtest but written entirely in C.

To use it, simply copy the y_test_h.h file into your project, include it in your test files, and use the following macros:

-IMPLEMENTATION_FTEST() to generate all test functions.

-IMPLEMENTATION_FMOCK() to generate all mock functions.

How to create test (ftest)

Example

Example for this file test.c:

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);
}

Requirements

This program was developed for Linux. It has not been tested on Windows or macOS yet.

Bash

$ ls
test.c y_test_h.h

Compilation

gcc -o exectest test.c

Its typically works with gcc and clang.

Running test

./exectest

The main function

Using command-line options:

C

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

We can add execution option like:

./exectest -h : Print help

./exectest -p 5 : Parallelize tests using 5 threads.

./exectest : Run tests sequentially (1 thread).

Using only sequential tests

C

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

Note: In this case, ./exectest does not read command-line arguments.

Using only parrallel tests

C

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

Note: In this case, ./exectest does not read command-line arguments.

FMOCK

You can create functions with predefined return values based on specific calls and conditions to simulate the behavior of real functions.

How to create fmock

C

#include "y_test_h.h"
IMPLEMENTATION_FMOCK()

outside of any function:

C

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) */

Example

To mock a function with the signature int f_mock(int a,int b);

C

MOCK_FUNC(int, f_mock,(int a,int b),(a,b))

Arguments breakdown

returnType: 	int,
function_name:	f_mock,
Prototype:	(int a,int b),
Variables :	(a,b)

Printing variables

You can define a function to print the mock function's variables for logging purposes. The macro uses similar arguments to MOCK_FUNC, but the return type is always char*.

Example for f_mock :

C

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 an expected call

C

EXPECT_MOCK_CALL(int, f_mock, (int a,int b), (a<b), 3){
  return a+b;
}

Arguments:

returnType: 	int,
function_name:	f_mock,
Prototype :	(int a,int b),
Condition :	(a<b) (boolean expression checked before execution)
Repetition :	3 (number of times this response is expected)	  

Define a "will" call

C

WILL_MOCK_CALL(int, f_mock, (int a,int b), (a==b), 1){
  return a*b;
}

The arguments are the same as EXPECT_MOCK_CALL. The difference is that EXPECT_MOCK_CALL must be triggered during the test, whereas WILL_MOCK_CALL is optional.

Initializing and calling mocks

In a TEST environment, you should use the INIT_CALLER_MOCK(f_mock); macro before calling the mock to get explicit logs.

Calling a mock function is done exactly like a normal functions.

Example:

C

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

While you can use the standard printf, this library provides a PRINTF macro. It allows logs to be recorded in files and ensures that logs remain ordered when running parallel tests.

The arguments are identical to the standard stdio.h printf.

PRINTF("hello\n");

Note : LOG is also available as an alias for PRINTF