From 0e16dbc5c78a2715fbbda5cae8a3b422d721b871 Mon Sep 17 00:00:00 2001
From: sanine <sanine.not@pm.me>
Date: Mon, 27 Dec 2021 17:20:55 -0600
Subject: add basic assertions

---
 lily-test.c        | 120 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 lily-test.h        |  69 ++++++++++++++++++++++++++++++
 tests/assertions.c |  29 +++++++++++++
 tests/main.c       |   1 +
 tests/tests.h      |   1 +
 5 files changed, 220 insertions(+)

diff --git a/lily-test.c b/lily-test.c
index 69bd0ce..9b54021 100644
--- a/lily-test.c
+++ b/lily-test.c
@@ -54,3 +54,123 @@ void lily_assert_msg(bool statement, const char *location,
    // _lily_assert_msg may long jump, so it takes calls va_end(args) for you
    _lily_assert_msg(statement, location, format_string, args);
 }
+
+
+void _lily_assert_true(const char *statement, bool value, const char *location)
+{
+   lily_assert_msg(value, location,
+		   "%s is not true",
+		   statement);
+}
+
+
+void _lily_assert_false(const char *statement, bool value, const char *location)
+{
+   lily_assert_msg(value, location,
+		   "%s is not false",
+		   statement);
+}
+
+
+void _lily_assert_not_null(const char *name, void *ptr, const char *location)
+{
+   lily_assert_msg(ptr != NULL, location,
+		   "%s is NULL",
+		   name);
+}
+
+
+void _lily_assert_null(const char *name, void *ptr, const char *location)
+{
+   lily_assert_msg(ptr == NULL, location,
+		   "%s (%p) is not NULL",
+		   name, ptr);
+}
+
+
+void _lily_assert_ptr_equal(const char *name_a, const char *name_b,
+			    void *a, void *b, const char *location)
+{
+   lily_assert_msg(a == b, location,
+		   "%s (%p) is not equal to %s (%p)",
+		   name_a, a, name_b, b);
+}
+
+
+void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b,
+			    void *a, void *b, const char *location)
+{
+   lily_assert_msg(a != b, location,
+		   "%s (%p) is equal to %s",
+		   name_a, a, name_b);
+}
+
+
+void _lily_assert_int_equal(const char *name_a, const char *name_b,
+			    intmax_t a, intmax_t b, const char *location)
+{
+   lily_assert_msg(a == b, location,
+		   "%s (%d) is not equal to %s (%d)",
+		   name_a, a, name_b, b);
+}
+
+
+void _lily_assert_int_not_equal(const char *name_a, const char *name_b,
+			    intmax_t a, intmax_t b, const char *location)
+{
+   lily_assert_msg(a != b, location,
+		   "%s (%d) is equal to %s",
+		   name_a, a, name_b);
+}
+
+
+void _lily_assert_float_equal(const char *name_a, const char *name_b,
+			      double a, double b, double epsilon, const char *location)
+{
+   lily_assert_msg(abs(a - b) <= epsilon,
+		   "%s (%f) is not equal to %s (%f) (epsilon: %f)",
+		   name_a, a, name_b, b, epsilon);
+}
+
+
+void _lily_assert_float_not_equal(const char *name_a, const char *name_b,
+				  double a, double b, double epsilon, const char *location)
+{
+   lily_assert_msg(abs(a - b) > epsilon,
+		   "%s (%f) is equal to %s (%f) (epsilon: %f)",
+		   name_a, a, name_b, b, epsilon);
+}
+
+
+void _lily_assert_string_equal(const char *name_a, const char *name_b,
+			       char *a, char *b, const char *location)
+{
+   lily_assert_msg(strcmp(a, b) == 0,
+		   "%s ('%s') is not equal to %s ('%s')",
+		   name_a, a, name_b, b);
+}
+
+
+void _lily_assert_string_not_equal(const char *name_a, const char *name_b,
+				   char *a, char *b, const char *location)
+{
+   lily_assert_msg(strcmp(a, b) != 0,
+		   "%s ('%s') is equal to %s",
+		   name_a, a, name_b);
+}
+
+
+void _lily_assert_memory_equal(const char *name_a, const char *name_b,
+			       void *a, void *b, size_t size, const char *location)
+{
+   lily_assert_msg(memcmp(a, b, size) == 0,
+		   "%s and %s contain different data", name_a, name_b);
+}
+
+
+void _lily_assert_memory_not_equal(const char *name_a, const char *name_b,
+				   void *a, void *b, size_t size, const char *location)
+{
+   lily_assert_msg(memcmp(a, b, size) == 0,
+		   "%s contains the same data s %s", name_a, name_b);
+}
diff --git a/lily-test.h b/lily-test.h
index 01eb34a..de69e92 100644
--- a/lily-test.h
+++ b/lily-test.h
@@ -28,4 +28,73 @@ void lily_init();
 void lily_assert_msg(bool statement, const char *location,
 		     const char *format_string, ...);
 
+#define lily_assert_true(statement) _lily_assert_true(#statement, statement, LILY_LOCATION)
+void _lily_assert_true(const char *statement, bool value, const char *location);
+
+
+#define lily_assert_false(statement) _lily_assert_false(#statement, statement, LILY_LOCATION)
+void _lily_assert_false(const char *statement, bool value, const char *location);
+
+
+#define lily_assert_not_null(ptr) _lily_assert_not_null(#ptr, ptr, LILY_LOCATION)
+void _lily_assert_not_null(const char *name, void *ptr, const char *location);
+
+
+#define lily_assert_null(ptr) _lily_assert_null(#ptr, ptr, LILY_LOCATION)
+void _lily_assert_null(const char *name, void *ptr, const char *location);
+
+
+#define lily_assert_ptr_equal(a, b) _lily_assert_ptr_equal(#a, #b, a, b, LILY_LOCATION)
+void _lily_assert_ptr_equal(const char *name_a, const char *name_b,
+			    void *a, void *b, const char *location);
+
+
+#define lily_assert_ptr_not_equal(a, b) _lily_assert_ptr_not_equal(#a, #b, a, b, LILY_LOCATION)
+void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b,
+				void *a, void *b, const char *location);
+
+
+#define lily_assert_int_equal(a, b) _lily_assert_int_equal(#a, #b, a, b, LILY_LOCATION)
+void _lily_assert_int_equal(const char *name_a, const char *name_b,
+			    intmax_t a, intmax_t b, const char *location);
+
+
+#define lily_assert_int_not_equal(a, b) _lily_assert_int_not_equal(#a, #b, a, b, LILY_LOCATION)
+void _lily_assert_int_not_equal(const char *name_a, const char *name_b,
+				intmax_t a, intmax_t b, const char *location);
+
+
+#define lily_assert_float_equal(a, b, epsilon)				\
+   _lily_assert_float_equal(#a, #b, a, b, epsilon, LILY_LOCATION)
+void _lily_assert_float_equal(const char *name_a, const char *name_b,
+			      double a, double b, double epsilon, const char *location);
+
+
+#define lily_assert_float_not_equal(a, b, epsilon)	\
+   _lily_assert_float_not_equal(#a, #b, a, b, epsilon, LILY_LOCATION)
+void _lily_assert_float_not_equal(const char *name_a, const char *name_b,
+				  double a, double b, double epsilon, const char *location);
+
+
+#define lily_assert_string_equal(a, b) _lily_assert_string_equal(#a, #b, a, b, LILY_LOCATION)
+void _lily_assert_string_equal(const char *name_a, const char *name_b,
+			       char *a, char *b, const char *location);
+
+
+#define lily_assert_string_not_equal(a, b) _lily_assert_string_not_equal(#a, #b, a, b, LILY_LOCATION)
+void _lily_assert_string_not_equal(const char *name_a, const char *name_b,
+				   char *a, char *b, const char *location);
+
+
+#define lily_assert_memory_equal(a, b, size)			\
+   _lily_assert_memory_equal(#a, #b, a, b, size, LILY_LOCATION)
+void _lily_assert_memory_equal(const char *name_a, const char *name_b,
+			       void *a, void *b, size_t size, const char *location);
+
+
+#define lily_assert_memory_not_equal(a, b, size)	\
+   _lily_assert_memory_not_equal(#a, #b, a, b, size, LILY_LOCATION)
+void _lily_assert_memory_not_equal(const char *name_a, const char *name_b,
+				   void *a, void *b, size_t size, const char *location);
+
 #endif
diff --git a/tests/assertions.c b/tests/assertions.c
index baa0045..0a2875d 100644
--- a/tests/assertions.c
+++ b/tests/assertions.c
@@ -44,3 +44,32 @@ const char *test_assert_msg()
 
    return 0;
 }
+
+
+const char *test_assert_true()
+{
+   int val = setjmp(_lily_globals.env);
+   if (val != 0)
+      return "true assertion failed incorrectly!";
+
+   lily_assert_true(true);
+
+   int passed_thru = 0;
+   _lily_globals.error_msg = NULL;
+   _lily_globals.error_location = "";
+   val = setjmp(_lily_globals.env);
+
+   if (passed_thru == 0) {
+      passed_thru = 1;
+      lily_assert_true(false);
+      return "false assertion incorrectly succeeded!";
+   }
+   else {
+      if (strcmp(_lily_globals.error_msg, "false is not true") != 0)
+	 return "false assertion produced incorrect error message!";
+      if (strcmp(_lily_globals.error_location, "tests/assertions.c:64") != 0)
+	 return "false assertion produced incorrect error location!";
+   }
+
+   return 0;
+}
diff --git a/tests/main.c b/tests/main.c
index 0ac74ac..65683ee 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -12,6 +12,7 @@ int main()
    
    run_test(test_LILY_LOCATION);
    run_test(test_assert_msg);
+   run_test(test_assert_true);
    
    return 0;
 }
diff --git a/tests/tests.h b/tests/tests.h
index 7889445..7962104 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -9,5 +9,6 @@ int validate_message(const char* received, const char* expected,
 // test cases
 const char* test_LILY_LOCATION();
 const char* test_assert_msg();
+const char* test_assert_true();
 
 #endif
-- 
cgit v1.2.1