Add assertion handler

Author: Bigomby

tests/assertion_handler.c

@@ -1,147 +1,89 @@
 #include "assertion_handler.h"
 
-#include <assert.h>
-#include <jansson.h>
-
-struct assertion_handler_s {
-  TAILQ_HEAD(, assertion_e) assertion_q;
-  TAILQ_HEAD(, value_e) value_q;
-  pthread_mutex_t assertion_mutex;
-  pthread_mutex_t value_mutex;
+/**
+ * Queue for store assertions
+ */
+struct assertion_e {
+  TAILQ_ENTRY(assertion_e) tailq;
+  char *assertion;
 };
 
 /**
- * Creates a new assertion_handler
- * @return assertion_handler The new assertion handler
+ * Initializes the handler
+ * @param  assertion_handler Handler that will be used
+ * @return                   Error code
  */
-struct assertion_handler_s *assertion_handler_new() {
+struct assertion_handler_s *assertion_handler_create() {
   struct assertion_handler_s *assertion_handler =
-      (struct assertion_handler_s *)malloc(sizeof(struct assertion_handler_s));
-  TAILQ_INIT(&assertion_handler->assertion_q);
-  TAILQ_INIT(&assertion_handler->value_q);
+      (struct assertion_handler_s *)calloc(1,
+                                           sizeof(struct assertion_handler_s));
 
-  if ((pthread_mutex_init(&assertion_handler->assertion_mutex, NULL) ||
-       pthread_mutex_init(&assertion_handler->value_mutex, NULL)) != 0) {
-    printf("\n mutex init failed\n");
+  if (pthread_mutex_init(&assertion_handler->mutex, NULL) != 0) {
+    return NULL;
   }
 
+  TAILQ_INIT(&assertion_handler->assertion_q);
+
   return assertion_handler;
 }
 
 /**
- * Inserts an assertion at the end of the assertion queue
- * @param assertion_handler assertion_handler_s to add the assertion
- * @param assertion         New assertion to add
+ * Adds an assertion to a given handler
+ * @param  assertion_handler Handler that will be used
+ * @param  message_assertion Message to assert
+ * @return                   Error code
  */
-void assertion_handler_push_assertion(
-    struct assertion_handler_s *assertion_handler,
-    struct assertion_e *assertion) {
+int assertion_handler_add(struct assertion_handler_s *assertion_handler,
+                          char *message_assertion) {
 
-  pthread_mutex_lock(&assertion_handler->assertion_mutex);
-  TAILQ_INSERT_TAIL(&assertion_handler->assertion_q, assertion, tailq);
-  pthread_mutex_unlock(&assertion_handler->assertion_mutex);
-}
+  if (NULL == message_assertion) {
+    return 1;
+  }
 
-/**
- * Inserts a new value at the end of the value queue
- * @param assertion_handler assertion_handler_s to add the assertion
- * @param value             New value to add
- */
-void assertion_handler_push_value(struct assertion_handler_s *assertion_handler,
-                                  struct value_e *value) {
+  struct assertion_e *assertion =
+      (struct assertion_e *)calloc(1, sizeof(struct assertion_e));
 
-  pthread_mutex_lock(&assertion_handler->value_mutex);
-  TAILQ_INSERT_TAIL(&assertion_handler->value_q, value, tailq);
-  pthread_mutex_unlock(&assertion_handler->value_mutex);
+  assertion->assertion = strdup(message_assertion);
+
+  if (strlen(message_assertion) > 0) {
+    pthread_mutex_lock(&assertion_handler->mutex);
+    TAILQ_INSERT_TAIL(&assertion_handler->assertion_q, assertion, tailq);
+    pthread_mutex_unlock(&assertion_handler->mutex);
+  }
+
+  return 0;
 }
 
 /**
- * Iterates the assertions and check for matchs between assertions and values
- * @param assertion_handler assertion_handler_s to use
+ * Assert every element in the queue
+ * @param  assertion_handler Handler that will be used
+ * @return                   Error code
  */
 int assertion_handler_assert(struct assertion_handler_s *assertion_handler) {
-  uint found = 0;
-  int err = 0;
-
-  pthread_mutex_lock(&assertion_handler->value_mutex);
-  pthread_mutex_lock(&assertion_handler->assertion_mutex);
-
   struct assertion_e *assertion;
-  TAILQ_FOREACH(assertion, &assertion_handler->assertion_q, tailq) {
-    struct value_e *value;
-
-    json_error_t assertion_jerr;
-    char *assertion_message = NULL;
-
-    json_t *assertion_json = json_loads(assertion->str, 0, &assertion_jerr);
-    json_unpack_ex(assertion_json, &assertion_jerr, JSON_STRICT, "{s:s}",
-                   "message", &assertion_message);
 
-    found = 0;
-
-    TAILQ_FOREACH(value, &assertion_handler->value_q, tailq) {
-      json_error_t value_jerr;
-      char *value_message = NULL;
-
-      json_t *value_json = json_loads(value->str, 0, &value_jerr);
-      json_unpack_ex(value_json, &value_jerr, JSON_STRICT, "{s:s}",
-                              "message", &value_message);
-
-      if (assertion_message == NULL || value_message == NULL) {
-        return 1;
-      }
-
-      // printf("%s:%s -> %d\n", assertion_message, value_message,
-      //        strcmp(assertion_message, value_message) == 0);
-
-      if (strcmp(assertion_message, value_message) == 0) {
-        found++;
-        json_decref(value_json);
-        break;
-      }
-
-      json_decref(value_json);
-    }
-
-    json_decref(assertion_json);
-
-    if (!found) {
-      err++;
-      break;
-    }
+  //// NOTE Debug block
+  pthread_mutex_lock(&assertion_handler->mutex);
+  TAILQ_FOREACH(assertion, &assertion_handler->assertion_q, tailq) {
+    printf("ASSERTION: %s\n", assertion->assertion);
+    pthread_mutex_unlock(&assertion_handler->mutex);
   }
+  ////
 
-  pthread_mutex_unlock(&assertion_handler->assertion_mutex);
-  pthread_mutex_unlock(&assertion_handler->value_mutex);
+  // TODO Assert here
 
-  return err;
+  return 0;
 }
 
-void assertion_handler_destroy(struct assertion_handler_s *assertion_handler) {
-  pthread_mutex_lock(&assertion_handler->value_mutex);
-  pthread_mutex_lock(&assertion_handler->assertion_mutex);
-
-  struct assertion_e *assertion = NULL;
-  while (!TAILQ_EMPTY(&assertion_handler->assertion_q)) {
-    assertion = TAILQ_FIRST(&assertion_handler->assertion_q);
-    TAILQ_REMOVE(&assertion_handler->assertion_q, assertion, tailq);
-    free(assertion->str);
-    free(assertion);
-  }
-
-  struct value_e *value;
-  while (!TAILQ_EMPTY(&assertion_handler->value_q)) {
-    value = TAILQ_FIRST(&assertion_handler->value_q);
-    TAILQ_REMOVE(&assertion_handler->value_q, value, tailq);
-    free(value->str);
-    free(value);
-  }
-
-  pthread_mutex_unlock(&assertion_handler->assertion_mutex);
-  pthread_mutex_unlock(&assertion_handler->value_mutex);
-
-  pthread_mutex_destroy(&assertion_handler->value_mutex);
-  pthread_mutex_destroy(&assertion_handler->assertion_mutex);
+/**
+ * Removes every element in the queue and free the handler
+ * @param  assertion_handler Handler that will be used
+ * @return                   Error code
+ */
+int assertion_handler_destroy(struct assertion_handler_s *assertion_handler) {
+  // TODO Free elements
 
+  pthread_mutex_destroy(&assertion_handler->mutex);
   free(assertion_handler);
+  return 0;
 }

tests/assertion_handler.h

@@ -1,31 +1,19 @@
-#include "stdio.h"
-#include "stdlib.h"
-
-#include <string.h>
 #include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include <sys/queue.h>
 
-// Public structs
-struct assertion_e {
-  TAILQ_ENTRY(assertion_e) tailq;
-  char *str;
+/**
+ * assertion_handler_s is used to store assertions and check them later.
+ */
+struct assertion_handler_s {
+  TAILQ_HEAD(, assertion_e) assertion_q;
+  pthread_mutex_t mutex; // Mutex used to keep the handle memory safe
 };
 
-struct value_e {
-  TAILQ_ENTRY(value_e) tailq;
-  char *str;
-  size_t len;
-};
-
-// Private structs
-struct assertion_handler_s;
-
-// Functions
-struct assertion_handler_s *assertion_handler_new();
-void assertion_handler_push_assertion(
-    struct assertion_handler_s *assertion_handler,
-    struct assertion_e *assertion);
-void assertion_handler_push_value(struct assertion_handler_s *assertion_handler,
-                                  struct value_e *value);
+struct assertion_handler_s *assertion_handler_create();
+int assertion_handler_add(struct assertion_handler_s *assertion_handler,
+                          char *message_assertion);
 int assertion_handler_assert(struct assertion_handler_s *assertion_handler);
-void assertion_handler_destroy(struct assertion_handler_s *assertion_handler);
+int assertion_handler_destroy(struct assertion_handler_s *assertion_handler);