thoehne/Small-Enough-Tester
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feature (#1)

Browse Source 
This feature adds the following functions:

 - set_malloc()
 - set_free()

Which is a safe malloc wrapper, that frees all memory after a test has finished.

Reviewed-on: #1
This commit is contained in:
Thorben Höhne
2025-06-25 23:17:02 +00:00
parent 3f78db4cb7
commit ed41c04209
10 changed files with 377 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
include/list.h Normal file
View File

@@ -0,0 +1,33 @@
#include <stddef.h>
struct SETBlockMeta
{
struct SETBlockMeta *next;
struct SETBlockMeta *prev;
struct SETBlockMeta *end;
};
/**
* Adds a new element to the list. The MetaData should sit at the start
* of a block.
*
* head (SETBlockMeta) List head.
* next (SETBlockMeta) Next meta to append.
*/
void set_ll_append(struct SETBlockMeta *head, struct SETBlockMeta *next);
/**
* Frees all blocks in the list.
*
* head (SETBlockMeta) List head.
*/
void set_ll_free_all(struct SETBlockMeta *head);
/**
* Frees the block with the given address and returns the new head.
*
* head (SETBlockMeta) List head.
* address (void*) Address to free.
*/
struct SETBlockMeta *set_ll_free_one(struct SETBlockMeta *head, void *address);

244
include/set.h Normal file
View File

@@ -0,0 +1,244 @@
#define _GNU_SOURCE
#include <stdbool.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include "utils.h"
#ifndef INCLUDE_SET_H
#define INCLUDE_SET_H
#define SET_MAX_ERROR_MSG_SIZE 256
#define SET_MAX_NAME_SIZE 64
/**
* Meta data for one test function.
*
* See also: struct SETSuit
*/
struct SETest
{
void (*function)(struct SETest *test);
const char *error_msg;
const char *name;
bool passed;
};
/**
* Meta data for one test suit.
*
* See also: struct SETest
*/
struct SETSuit
{
const char *name;
struct SETest *tests;
int len;
int shm_key;
bool (*setup)();
bool (*tear_down)();
bool passed;
};
/**
* Internal function header for bundle. Use BUNDLE() macro to define bundle in
* test.
*/
void set_bundle_suits(struct SETSuit **suits, int *counter, bool count);
/**
* Empty suit_setup. Resolving EMPTY in a suit constructor gets
* us here.
*
* Note: Use EMPTY instead of this function.
*/
static bool EMPTY_suit_setup() { return true; }
/**
* Empty suit_tear_down. Resolving EMPTY in a suit constructor gets
* us here.
*
* Note: Use EMPTY instead of this function.
*/
static bool EMPTY_suit_tear_down() { return true; }
/**
* Internal header for global setup. Use SETUP() macro instead.
*/
bool set_up();
/**
* Internal header for global tear down. Use TEAR_DOWN() macro instead.
*/
bool tear_down();
/**
* Global setup function.
* Gets called at the start of the whole test program.
*
* Should return True if setup was successfull, false if not.
* Tests are not executed on false.
*
* Note: This function has to be set in the tests even if it is not used.
*
* See also: NO_SETUP()
*/
#define SETUP() bool set_up()
/**
* Empty setup function returning true.
*/
#define NO_SETUP \
bool set_up() { return true; }
/**
* Setup function that allways fails. May be usefull to set if tests shouldn't
* be executed.
*/
#define DEACTIVATE \
bool set_up() \
{ \
printf("All tests are deactivated.\n"); \
return false; \
}
/**
* Global tear down function.
* Gets called at the end of the while test program.
*
* Should return true if tear down was successfull, false if not.
*
* Note: This function has to be set in the tests even if it is not used.
*/
#define TEAR_DOWN() bool tear_down()
/**
* Empty tear down function returning true.
*/
#define NO_TEAR_DOWN \
bool tear_down() { return true; }
/**
* Section in the tests to register all suits for execution.
*
* See also: ADD_SUIT()
* See also: SUIT, SUIT_ST
*/
#define BUNDLE() \
void set_bundle_suits(struct SETSuit **suits, int *counter, bool count)
/**
* Used in BUNDLE() to register suit.
*
* suit_name (Parameter) Name of the test suit to add.
*/
#define ADD_SUIT(suit_name) \
if (!count) \
{ \
suits[(*counter)] = suit_name##_suit_contructor(); \
} \
(*counter)++;
/**
* Creates a new test suit with local setup and tear_down function.
*
* suit_name (Parameter) Name of the suit. (Must be globally unique for suits.)
* setup_func (SUIT_SETUP) Suit setup function name. (Write name EMPTY if no
* setup is required.) tear_down_func (SUIT_TEAR_DOWN) Suit tear down function
* name. (Write name EMPTY if no tear down is required)
*
* See also: SUIT_SETUP()
* See also: SUIT_TEAR_DOWN()
*
* Technical Note: We manually allocate suits via mmap to be able to mark them
* DONTFORK. Since we don't need the suits in a test fork.
*/
#define SUIT_ST(suit_name, setup_func, tear_down_func) \
void suit_name##_suit(struct SETSuit *suit, bool count); \
struct SETSuit *suit_name##_suit_contructor() \
{ \
struct SETSuit *suit = \
mmap(NULL, sizeof(struct SETSuit), PROT_READ | PROT_WRITE, \
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0); \
madvise(suit, sizeof(struct SETSuit), MADV_DONTFORK); \
suit->len = 0; \
suit_name##_suit(suit, true); \
suit->shm_key = \
create_shared_suit_space(suit->len * sizeof(struct SETest)); \
suit->name = #suit_name; \
suit->tests = shmat(suit->shm_key, 0, 0); \
if (suit->tests == (struct SETest *)-1) \
{ \
fprintf(stderr, "Couldn't attach suit space.\n"); \
perror("shmat"); \
exit(1); \
} \
suit->len = 0; \
suit->setup = &setup_func##_suit_setup; \
suit->tear_down = &tear_down_func##_suit_tear_down; \
suit_name##_suit(suit, false); \
return suit; \
} \
void suit_name##_suit(struct SETSuit *suit, bool count)
/**
* Suit local setup function. If registered in suit it get's executed before the
* suit starts the first test.
*
* suit_name (Parameter) Name of the suit setup function. (Must be globally
* unique for suit setup functions!)
*/
#define SUIT_SETUP(suit_name) bool suit_name##_suit_setup()
/**
* Suit local tear down function. If registered in suit it get's executed after
* the last test was executed.
*
* suit_name (Parameter) Name of the suit setup function. (Must be globally
* unique for suit tear down functions!)
*/
#define SUIT_TEAR_DOWN(suit_name) bool suit_name##_suit_tear_down()
/**
* Suit without setup or tear down.
*
* suit_name (Parameter) Name of the suit. (Must be globally unique for suits!)
*/
#define SUIT(suit_name) SUIT_ST(suit_name, EMPTY, EMPTY)
/**
* Registers a test with a test suit.
*
* test_name (Parameter) Name of the test.
*
* See also: TEST()
*/
#define ADD_TEST(test_name) \
if (!count) \
{ \
test_name##_test_constructor(&suit->tests[suit->len]); \
} \
suit->len++;
/**
* Test function. If registered in suit it gets executed be that suit.
*
* test_name (Parameter) Name of the test (Must be globally unique for tests!)
*
* See also: set_asserts.h
*/
#define TEST(test_name) \
void test_name##_test(struct SETest *test); \
void test_name##_test_constructor(struct SETest *test) \
{ \
test->name = #test_name; \
test->function = &test_name##_test; \
test->passed = true; \
test->error_msg = NULL; \
} \
void test_name##_test(struct SETest *test)
#endif // !INCLUDE_SET_H

88
include/set_asserts.h Normal file
View File

@@ -0,0 +1,88 @@
#include <math.h>
#include <string.h>
#include "set.h"
#ifndef ASSERT_H
#define ASSERT_H
#define STATIC_ASSERT(condition) (void)sizeof(char[1 - 2 * (!(condition))])
#define ASSERT_EQ(exp, act) \
if (exp != act) \
{ \
test->passed = false; \
test->error_msg = format_string("Expected %d to be %d\n.", act, exp); \
return; \
}
#define ASSERT_NEQ(exp, act) \
if (exp == act) \
{ \
test->passed = false; \
test->error_msg = \
format_string("Expect %d to be %d.\n", act, exp) return; \
}
#define ASSERT_EQ_MSG(exp, act, msg) \
if (exp != act) \
{ \
test->passed = false; \
test->error_msg = format_string( \
"Expected %d to be %d\n Failed with message: " msg, act, exp); \
return; \
}
#define ASSERT_TRUE(x) \
if (!x) \
{ \
test->passed = false; \
test->error_msg = format_string("Expected true got false."); \
return; \
}
#define ASSERT_FALSE(x) \
if (x) \
{ \
test->passed = false; \
test->error_msg = format_string("Expected false got true."); \
return; \
}
#define ASSERT_EQ_FLOAT(exp, act, epsilon) \
if (fabs(exp - act) <= epsilon) \
{ \
test->passed = false; \
test->error_msg = \
format_string("Expected %f to be %f (e: %f)", act, exp, epsilon); \
return; \
}
#define ASSERT_NEQ_FLOAT(exp, act, epsilon) \
if (fabs(exp - act) > epsilon) \
{ \
test->passed = false; \
test->error_msg = \
format_string("Expected %f to be %f (e: %f)", act, exp, epsilon); \
return; \
}
#define ASSERT_EQ_STR(exp, act) \
if (strcmp(exp, act) != 0) \
{ \
test->passed = false; \
type->error_msg = \
format_string("Expected: %d\nBut got: %d", act, exp); \
return; \
}
#define ASSERT_NEQ_STR(exp, act) \
if (strcmp(exp, act) == 0) \
{ \
test->passed = false; \
type->error_msg = \
format_string("Expected: %d\nBut got: %d", act, exp); \
return; \
}
#endif

54
include/utils.h Normal file
View File

@@ -0,0 +1,54 @@
#include <stddef.h>
/*
* Returns pointer to formatted the string.
*
* fmt (const char*) Formatter string.
* ... (args) Arguments.
*
* Note: The string is dynamically allocated and must be freed.
*/
char *format_string(const char *fmt, ...);
/**
* Internal function to create shared memory for all tests in a suit.
*
* size (size_t) Size of space in bytes.
*/
int create_shared_suit_space(size_t size);
/**
* Wrapper for malloc function that notes down the allocated blocks. All
* blocks allocated with this function get freed after test execution.
* This function should only be used if the object might still be in memory
* once a test fails. Manual allocation should be preferred.
*
* n (size_t) Amount of bytes to allocate.
*/
void *set_malloc(size_t n);
/**
* Wrapper for fee(void*).
*
* See also: set_malloc()
*/
void set_free(void *address);
/**
* Internal function to free all allocated and registered memory.
*/
void set_free_all();
/**
* Wrapper for calloc.
*
* See also: set_malloc()
*/
void *set_calloc(size_t n, size_t size);
/**
* Wrapper for realloc().
*
* See also: set_malloc()
*/
void *set_realloc(size_t n);