Skip to content

Commit

Permalink
Issue #1 In reporting display when assertion failed, add filename and…
Browse files Browse the repository at this point in the history 
… line
  • Loading branch information
@epatrizio
epatrizio committed Apr 30, 2021
1 parent 32a4657 commit 367ae1f
Show file tree
Hide file tree
Showing 4 changed files with 86 additions and 56 deletions.
16 changes: 12 additions & 4 deletions ctestfmk.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@
#include "ctestfmk.h"

void insertList(TestFunctionList *list, const char *name, TestFunction function);
long get_memory_usage();
long getMemoryUsage();

TestSuite *createTestSuite(const char *name)
{
Expand All @@ -19,7 +19,7 @@ TestSuite *createTestSuite(const char *name)
empty_test_suite->nb_tests = 0;
empty_test_suite->nb_asserts = 0;
empty_test_suite->execution_time = 0;
empty_test_suite->memory_usage = get_memory_usage();
empty_test_suite->memory_usage = getMemoryUsage();
empty_test_suite->functions = empty_list;

return empty_test_suite;
Expand Down Expand Up @@ -114,13 +114,19 @@ void insertList(TestFunctionList *list, const char *name, TestFunction function)
}
}

void addTestFunctionAssert(TestFunctionNode* function_node, bool in_success, char *error_message)
void addTestFunctionAssert(TestFunctionNode* function_node, char *file, int line, bool in_success, char *error_message)
{
char *message;
message = (char *) malloc(strlen(error_message)+1);
strcpy(message, error_message);

char *filename;
filename = (char *) malloc(strlen(file)+1);
strcpy(filename, file);

TestFunctionAssertNode *node = (TestFunctionAssertNode *) malloc(sizeof(TestFunctionAssertNode));
node->file = filename;
node->line = line;
node->in_success = in_success;
node->error_message = message;
node->next = NULL;
Expand Down Expand Up @@ -176,6 +182,8 @@ void displayTestSuite(TestSuite *suite)
printf(" - Number of asserts: %i\n", current_node->nb_asserts);
TestFunctionAssertNode *current_assert_node = current_node->assert_functions.first_node;
while (current_assert_node != NULL) {
printf(" * File call name: %s\n", current_assert_node->file);
printf(" * File call line: %i\n", current_assert_node->line);
printf(" * In success: %s\n", current_assert_node->in_success ? "YES" : "NO");
printf(" * Error message: %s\n", current_assert_node->error_message);
current_assert_node = current_assert_node->next;
Expand All @@ -184,7 +192,7 @@ void displayTestSuite(TestSuite *suite)
}
}

long get_memory_usage()
long getMemoryUsage()
{
struct rusage r_usage;
int ret = getrusage(RUSAGE_SELF,&r_usage);
Expand Down
23 changes: 16 additions & 7 deletions ctestfmk.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -11,6 +11,8 @@
typedef void (* TestFunction)(const void*); // Test function pointer

typedef struct _TestFunctionAssertNode {
char *file;
int line;
bool in_success;
char *error_message;
struct _TestFunctionAssertNode *next;
Expand Down Expand Up @@ -52,15 +54,22 @@ void runTestSuite(TestSuite*);
void displayTestSuite(TestSuite*);
void deleteTestSuite(TestSuite*);

void addTestFunctionAssert(TestFunctionNode*, bool, char*);
void addTestFunctionAssert(TestFunctionNode*, char*, int, bool, char*);

// ***** Asserts *****

void assertEqualsInt(int, int, const void*);
void assertEqualsDouble(double, double, const void*);
void assertEqualsChar(char, char, const void*);
void assertEqualsCharP(char*, char*, const void*);
void assertTrue(bool, const void*);
void assertFalse(bool, const void*);
void assertEqualsInt(int, int, const void*, char*, int);
void assertEqualsDouble(double, double, const void*, char*, int);
void assertEqualsChar(char, char, const void*, char*, int);
void assertEqualsCharP(char*, char*, const void*, char*, int);
void assertTrue(bool, const void*, char*, int);
void assertFalse(bool, const void*, char*, int);

#define assert_eaquals_int(expected, actual, function_node) assertEqualsInt(expected, actual, function_node, __FILE__, __LINE__)
#define assert_eaquals_double(expected, actual, function_node) assertEqualsDouble(expected, actual, function_node, __FILE__, __LINE__)
#define assert_eaquals_char(expected, actual, function_node) assertEqualsChar(expected, actual, function_node, __FILE__, __LINE__)
#define assert_eaquals_charp(expected, actual, function_node) assertEqualsCharP(expected, actual, function_node, __FILE__, __LINE__)
#define assert_true(actual, function_node) assertTrue(actual, function_node, __FILE__, __LINE__)
#define assert_false(actual, function_node) assertFalse(actual, function_node, __FILE__, __LINE__)

#endif
49 changes: 29 additions & 20 deletions ctestfmk_asserts.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,65 +3,74 @@

#include "ctestfmk.h"

void updateTestFunctionNode(const void *function_node, bool success, char *error_message)
void updateTestFunctionNode(const void *function_node, char* file, int line, bool success, char *error_message)
{
TestFunctionNode* current_function_node = (TestFunctionNode*) function_node;
current_function_node->nb_asserts++;
current_function_node->in_success = current_function_node->in_success && success;
addTestFunctionAssert(current_function_node, success, error_message);
addTestFunctionAssert(current_function_node, file, line, success, error_message);
}

void assertEqualsInt(int expected, int actual, const void *function_node)
void assertEqualsInt(int expected, int actual, const void *function_node, char* file, int line)
{
bool success = (expected == actual);
char error_message[ERROR_MESSAGE_MAX_SIZE] = {'\0'};
if (!success)
sprintf(error_message, "[error] assertEqualsInt: expected %i - actual %i", expected, actual);
sprintf(error_message, "[error %s:%i] assertEqualsInt: %i expected %i", file, line, actual, expected);

updateTestFunctionNode(function_node, success, error_message);
updateTestFunctionNode(function_node, file, line, success, error_message);
}

void assertEqualsDouble(double expected, double actual, const void *function_node)
void assertEqualsDouble(double expected, double actual, const void *function_node, char* file, int line)
{
bool success = (expected == actual);
char error_message[ERROR_MESSAGE_MAX_SIZE] = {'\0'};
if (!success)
sprintf(error_message, "[error] assertEqualsDouble: expected %f - actual %f", expected, actual);
sprintf(error_message, "[error %s:%i] assertEqualsDouble: %f expected %f", file, line, actual, expected);

updateTestFunctionNode(function_node, success, error_message);
updateTestFunctionNode(function_node, file, line, success, error_message);
}

void assertEqualsChar(char expected, char actual, const void *function_node)
void assertEqualsChar(char expected, char actual, const void *function_node, char* file, int line)
{
bool success = (expected == actual);
char error_message[ERROR_MESSAGE_MAX_SIZE] = {'\0'};
if (!success)
sprintf(
error_message,
"[error] assertEqualsChar: expected %c (%i) - actual %c (%i)",
expected, expected,
actual, actual
"[error %s:%i] assertEqualsChar: %c (%i) expected %c (%i)",
file, line,
actual, actual,
expected, expected
);

updateTestFunctionNode(function_node, success, error_message);
updateTestFunctionNode(function_node, file, line, success, error_message);
}

void assertEqualsCharP(char* expected, char* actual, const void *function_node)
void assertEqualsCharP(char* expected, char* actual, const void *function_node, char* file, int line)
{
bool success = (strcmp(expected, actual) == 0);
char error_message[ERROR_MESSAGE_MAX_SIZE] = {'\0'};
if (!success)
sprintf( error_message, "[error] assertEqualsCharP: expected %s - actual %s", expected, actual);
sprintf( error_message, "[error %s:%i] assertEqualsCharP: %s expected %s", file, line, actual, expected);

updateTestFunctionNode(function_node, success, error_message);
updateTestFunctionNode(function_node, file, line, success, error_message);
}

void assertTrue(bool actual, const void *function_node)
void assertTrue(bool actual, const void *function_node, char* file, int line)
{
updateTestFunctionNode(function_node, actual, actual ? "" : "[error] assertEqualsTrue: False return");
char error_message[ERROR_MESSAGE_MAX_SIZE] = {'\0'};
if (!actual)
sprintf(error_message, "[error %s:%i] assertEqualsTrue: False return", file, line);

updateTestFunctionNode(function_node, file, line, actual, error_message);
}

void assertFalse(bool actual, const void *function_node)
void assertFalse(bool actual, const void *function_node, char* file, int line)
{
updateTestFunctionNode(function_node, !actual, !actual ? "" : "[error] assertEqualsFalse: True return");
char error_message[ERROR_MESSAGE_MAX_SIZE] = {'\0'};
if (actual)
sprintf(error_message, "[error %s:%i] assertEqualsFalse: True return", file, line);

updateTestFunctionNode(function_node, file, line, !actual, error_message);
}
54 changes: 29 additions & 25 deletions tests_fake.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,59 +7,63 @@ void test_fake(const void *function_node)

void test_fake_int(const void *function_node)
{
assertEqualsInt(2, 2, function_node);
assertEqualsInt(3, 3, function_node);
assert_eaquals_int(2, 2, function_node);
assert_eaquals_int(2, 3, function_node);
}

void test_fake_double(const void *function_node)
{
assertEqualsDouble(1.1, 1.23, function_node);
assertEqualsDouble(222.20, 222.20, function_node);
assert_eaquals_double(1.1, 1.23, function_node);
assert_eaquals_double(222.20, 222.20, function_node);
double d1 = 2.45;
double d2 = 12.45;
assertEqualsDouble(d1, d2, function_node);
assert_eaquals_double(d1, d2, function_node);
float f1 = 123.78;
float f2 = 123.78;
assertEqualsDouble(f1, f2, function_node);
assert_eaquals_double(f1, f2, function_node);
}

void test_fake_char(const void *function_node)
{
assertEqualsChar('a', 'a', function_node);
assertEqualsChar('a', 'b', function_node);
assert_eaquals_char('a', 'a', function_node);
assert_eaquals_char('a', 'b', function_node);
}

void test_fake_charp(const void *function_node)
{
assertEqualsCharP("fake", "fake", function_node);
assertEqualsCharP("fake1", "fake2", function_node);
assertEqualsCharP("fake_fake", "fake", function_node);
assertEqualsCharP("fake", "fake_fake", function_node);
assert_eaquals_charp("fake", "fake", function_node);
assert_eaquals_charp("fake1", "fake2", function_node);
assert_eaquals_charp("fake_fake", "fake", function_node);
assert_eaquals_charp("fake", "fake_fake", function_node);

char *s1 = "fake1";
char *s2 = "fake2";
char *s3 = "fake3";
assertEqualsCharP(s1, s2, function_node);
assertEqualsCharP(s1, s3, function_node);
assert_eaquals_charp(s1, s2, function_node);
assert_eaquals_charp(s1, s3, function_node);

char s4[] = "fake4";
char s5[] = "fake5";
char s6[] = "fake6";
char s11[] = "fake1";
assertEqualsCharP(s4, s5, function_node);
assertEqualsCharP(s4, s6, function_node);
assertEqualsCharP(s1, s11, function_node);
assert_eaquals_charp(s4, s5, function_node);
assert_eaquals_charp(s4, s6, function_node);
assert_eaquals_charp(s1, s11, function_node);
}

void test_fake_bool(const void *function_node)
{
assertTrue(true, function_node);
assertTrue(false, function_node);
assertTrue(1 == 1, function_node);
assertTrue(1 == 2, function_node);
assert_true(true, function_node);
assert_true(false, function_node);
assert_true(1 == 1, function_node);
assert_true(1 == 2, function_node);
assert_true(12.0 == 12, function_node);
assert_true('a' == 'a', function_node);

assertFalse(false, function_node);
assertFalse(true, function_node);
assertFalse(12 == 23, function_node);
assertFalse(12 == 12, function_node);
assert_false(false, function_node);
assert_false(true, function_node);
assert_false(12 == 23, function_node);
assert_false(12 == 12, function_node);
assert_false('a' == 'a', function_node);
assert_false(12.0 == 12, function_node);
}

0 comments on commit 367ae1f

Please sign in to comment.