1 files changed, 77 insertions, 8 deletions

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;
+}