add basic mock queue + test

6 files changed, 161 insertions, 8 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d36e1b3..397284c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -14,6 +14,7 @@ add_executable(lily-metatest
   ${TEST_SRC}/main.c
   ${TEST_SRC}/helpers.c
   ${TEST_SRC}/assertions.c
+  ${TEST_SRC}/mock_queue.c
   )
 set_target_properties(lily-metatest PROPERTIES
   C_STANDARD 99
diff --git a/lily-test.c b/lily-test.c
index cae4657..7484894 100644
--- a/lily-test.c
+++ b/lily-test.c
@@ -9,6 +9,7 @@ struct lily_globals_t _lily_globals;
 
 void lily_init()
 {
+   _lily_globals.error_msg_len = 0;
    _lily_globals.error_msg = NULL;
    _lily_globals.error_location = "";
 }
@@ -29,19 +30,30 @@ static void _lily_assert_msg(bool statement, const char *location,
    size_t length = vsnprintf(NULL, 0, format_string, args_len);
    va_end(args_len);
 
-   char *msg = realloc(_lily_globals.error_msg, (length+1) * sizeof(char));
-   if (msg == NULL) {
-      fprintf(stderr, "WARNING: failed to allocate memory for failed test message!\n");
-      if (_lily_globals.error_msg != NULL) {
+   if (_lily_globals.error_msg_len < length+1) {
+      if (_lily_globals.error_msg != NULL)
 	 free(_lily_globals.error_msg);
+
+      char *msg = malloc((length+2) * sizeof(char));
+
+      if (msg == NULL) {
+	 fprintf(stderr, "WARNING: failed to allocate memory for failed test message!\n");
 	 _lily_globals.error_msg = NULL;
+	 va_end(args);
+	 longjmp(_lily_globals.env, 1);
+	 return;
+      }
+      else {
+	 _lily_globals.error_msg = msg;
+	 _lily_globals.error_msg_len = length+1;
+	 printf("reallocated global msg: %p ", msg);
       }
-   }
-   else {
-      vsnprintf(msg, length+1, format_string, args);
-      _lily_globals.error_msg = msg;
    }
 
+   printf("length: %lu ", length);
+
+   vsnprintf(_lily_globals.error_msg, length+1, format_string, args);
+
    va_end(args);
    longjmp(_lily_globals.env, 1);
 }
@@ -175,3 +187,60 @@ void _lily_assert_memory_not_equal(const char *name_a, const char *name_b,
    lily_assert_msg(memcmp(a, b, size) == 0,
 		   "%s contains the same data s %s", name_a, name_b);
 }
+
+
+lily_mock_queue_t* lily_queue_create()
+{
+   const size_t size = 256 * sizeof(uint8_t);
+
+   lily_mock_queue_t *q = malloc(sizeof(lily_mock_queue_t));
+   q->buf_size = size;
+   q->buf = malloc(size);
+   q->front = q->buf;
+   q->back = q->front;
+
+   return q;
+}
+
+
+void lily_queue_destroy(lily_mock_queue_t *q)
+{
+   free(q->buf);
+   free(q);
+}
+
+
+void _lily_enqueue(lily_mock_queue_t *q, size_t size, uint8_t *data)
+{
+   size_t used = q->back - q->buf;
+   size_t remaining = q->buf_size - used;
+
+   if (remaining < size) {
+      /* re-allocate bigger buffer */
+      size_t size_new = 2 * q->buf_size;
+      uint8_t *buf_new = realloc(q->buf, size_new);
+      if (buf_new == NULL) {
+	 fprintf(stderr, "failed to allocated %lu bytes for queue %p!\n",
+		 size_new, q);
+	 return;
+      }
+      q->buf = buf_new;
+   }
+
+   memcpy(q->back, data, size);
+   q->back += size;
+}
+
+
+void _lily_dequeue(lily_mock_queue_t *q, size_t size, uint8_t *ptr)
+{
+   size_t dist = q->back - q->front;
+   if (dist < size) {
+      fprintf(stderr, "attempted to read %lu bytes out of queue %p, "
+	      "which has %lu bytes presently queued\n", size, q, dist);
+      return;
+   }
+
+   memcpy(ptr, q->front, size);
+   q->front += size;
+}
diff --git a/lily-test.h b/lily-test.h
index de69e92..783e134 100644
--- a/lily-test.h
+++ b/lily-test.h
@@ -18,6 +18,7 @@
 
 struct lily_globals_t {
    jmp_buf env;
+   size_t error_msg_len;
    char *error_msg;
    const char *error_location;
 };
@@ -25,6 +26,14 @@ struct lily_globals_t {
 extern struct lily_globals_t _lily_globals;
 void lily_init();
 
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * assertions
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
 void lily_assert_msg(bool statement, const char *location,
 		     const char *format_string, ...);
 
@@ -97,4 +106,35 @@ void _lily_assert_memory_equal(const char *name_a, const char *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);
 
+
+/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * mocks
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+typedef struct lily_mock_queue_t {
+   size_t buf_size;
+   uint8_t *buf;
+   uint8_t *front, *back;
+} lily_mock_queue_t;
+
+
+lily_mock_queue_t* lily_queue_create();
+void lily_queue_destroy(lily_mock_queue_t *q);
+
+#define lily_enqueue(q, type, value)		\
+   do {						\
+   type _var = value;					\
+   _lily_enqueue(q, sizeof(type), (uint8_t*)(&_var));			\
+   } while(0)
+void _lily_enqueue(lily_mock_queue_t *q, size_t size, uint8_t *data);
+
+
+#define lily_dequeue(q, type, ptr)		\
+   _lily_dequeue(q, sizeof(type), (uint8_t*) ptr)
+void _lily_dequeue(lily_mock_queue_t *q, size_t size, uint8_t *ptr);
+
+
 #endif
diff --git a/tests/main.c b/tests/main.c
index 3c94cf7..f8e272f 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -20,6 +20,8 @@ int main()
    run_test(test_assert_ptr_not_equal);
    run_test(test_assert_int_equal);
    run_test(test_assert_int_not_equal);
+
+   run_test(test_mock_enqueue_dequeue_int);
    
    return 0;
 }
diff --git a/tests/mock_queue.c b/tests/mock_queue.c
new file mode 100644
index 0000000..e9527b2
--- /dev/null
+++ b/tests/mock_queue.c
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "lily-test.h"
+#include "tests.h"
+
+
+const char* test_mock_enqueue_dequeue_int() {
+   lily_mock_queue_t *q = lily_queue_create(); 
+
+   /* enqueue A259482, for no particular reason */
+   lily_enqueue(q, int, 2);
+   lily_enqueue(q, int, 6);
+   lily_enqueue(q, int, 44);
+   int n = 2014;
+   lily_enqueue(q, int, n);
+
+   lily_dequeue(q, int, &n);
+   if (n != 2) return "dequeued incorrect first value";
+   lily_dequeue(q, int, &n);
+
+   /* queue next value after already popping */
+   lily_enqueue(q, long, 1651377);
+   
+   if (n != 6) return "dequeued incorrect second value";
+   lily_dequeue(q, int, &n);
+   if (n != 44) return "dequeued incorrect third value";
+   lily_dequeue(q, int, &n);
+   if (n != 2014) return "dequeued incorrect fourth value";
+   long m;
+   lily_dequeue(q, long, &m);
+   if (m != 1651377) return "dequeued incorrect fifth value";
+
+   lily_queue_destroy(q);
+   
+   return 0;
+}
diff --git a/tests/tests.h b/tests/tests.h
index 995beaf..266cc04 100644
--- a/tests/tests.h
+++ b/tests/tests.h
@@ -17,4 +17,8 @@ const char* test_assert_ptr_equal();
 const char* test_assert_ptr_not_equal();
 const char* test_assert_int_equal();
 const char* test_assert_int_not_equal();
+
+const char* test_mock_enqueue_dequeue_int();
+const char* test_mock_enqueue_dequeue_heterogenous();
+
 #endif