diff --git a/ctestfmk.c b/ctestfmk.c
index b501db8..5140211 100644
--- a/ctestfmk.c
+++ b/ctestfmk.c
@@ -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)
 {
@@ -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;
@@ -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;
@@ -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;
@@ -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);
diff --git a/ctestfmk.h b/ctestfmk.h
index 8b661d7..af40804 100644
--- a/ctestfmk.h
+++ b/ctestfmk.h
@@ -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;
@@ -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
\ No newline at end of file
diff --git a/ctestfmk_asserts.c b/ctestfmk_asserts.c
index 9ed36bc..a26848e 100644
--- a/ctestfmk_asserts.c
+++ b/ctestfmk_asserts.c
@@ -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);
 }
diff --git a/tests_fake.c b/tests_fake.c
index b1d1749..a172b91 100644
--- a/tests_fake.c
+++ b/tests_fake.c
@@ -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);
 }
\ No newline at end of file