iodine 0.4.8 → 0.4.10

data/ext/iodine/fiobj_sym.c

@@ -0,0 +1,213 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+Hashing (SipHash copy)
+***************************************************************************** */
+
+#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) &&                 \
+    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+/* the algorithm was designed as little endian... so, byte swap 64 bit. */
+#define sip_local64(i)                                                         \
+  (((i)&0xFFULL) << 56) | (((i)&0xFF00ULL) << 40) |                            \
+      (((i)&0xFF0000ULL) << 24) | (((i)&0xFF000000ULL) << 8) |                 \
+      (((i)&0xFF00000000ULL) >> 8) | (((i)&0xFF0000000000ULL) >> 24) |         \
+      (((i)&0xFF000000000000ULL) >> 40) | (((i)&0xFF00000000000000ULL) >> 56)
+#else
+/* no need */
+#define sip_local64(i) (i)
+#endif
+
+/* 64Bit left rotation, inlined. */
+#define lrot64(i, bits)                                                        \
+  (((uint64_t)(i) << (bits)) | ((uint64_t)(i) >> (64 - (bits))))
+
+uint64_t fiobj_sym_hash(const void *data, size_t len) {
+  /* initialize the 4 words */
+  uint64_t v0 = (0x0706050403020100ULL ^ 0x736f6d6570736575ULL);
+  uint64_t v1 = (0x0f0e0d0c0b0a0908ULL ^ 0x646f72616e646f6dULL);
+  uint64_t v2 = (0x0706050403020100ULL ^ 0x6c7967656e657261ULL);
+  uint64_t v3 = (0x0f0e0d0c0b0a0908ULL ^ 0x7465646279746573ULL);
+  const uint64_t *w64 = data;
+  uint8_t len_mod = len & 255;
+  union {
+    uint64_t i;
+    uint8_t str[8];
+  } word;
+
+#define hash_map_SipRound                                                      \
+  do {                                                                         \
+    v2 += v3;                                                                  \
+    v3 = lrot64(v3, 16) ^ v2;                                                  \
+    v0 += v1;                                                                  \
+    v1 = lrot64(v1, 13) ^ v0;                                                  \
+    v0 = lrot64(v0, 32);                                                       \
+    v2 += v1;                                                                  \
+    v0 += v3;                                                                  \
+    v1 = lrot64(v1, 17) ^ v2;                                                  \
+    v3 = lrot64(v3, 21) ^ v0;                                                  \
+    v2 = lrot64(v2, 32);                                                       \
+  } while (0);
+
+  while (len >= 8) {
+    word.i = sip_local64(*w64);
+    v3 ^= word.i;
+    /* Sip Rounds */
+    hash_map_SipRound;
+    hash_map_SipRound;
+    v0 ^= word.i;
+    w64 += 1;
+    len -= 8;
+  }
+  word.i = 0;
+  uint8_t *pos = word.str;
+  uint8_t *w8 = (void *)w64;
+  switch (len) { /* fallthrough is intentional */
+  case 7:
+    pos[6] = w8[6];
+  case 6:
+    pos[5] = w8[5];
+  case 5:
+    pos[4] = w8[4];
+  case 4:
+    pos[3] = w8[3];
+  case 3:
+    pos[2] = w8[2];
+  case 2:
+    pos[1] = w8[1];
+  case 1:
+    pos[0] = w8[0];
+  }
+  word.str[7] = len_mod;
+
+  /* last round */
+  v3 ^= word.i;
+  hash_map_SipRound;
+  hash_map_SipRound;
+  v0 ^= word.i;
+  /* Finalization */
+  v2 ^= 0xff;
+  /* d iterations of SipRound */
+  hash_map_SipRound;
+  hash_map_SipRound;
+  hash_map_SipRound;
+  hash_map_SipRound;
+  /* XOR it all together */
+  v0 ^= v1 ^ v2 ^ v3;
+#undef hash_map_SipRound
+  return v0;
+}
+
+/* *****************************************************************************
+Symbol VTable
+***************************************************************************** */
+
+static int fiobj_sym_is_eq(fiobj_s *self, fiobj_s *other) {
+  if (!other || other->type != self->type)
+    return 0;
+  return obj2sym(self)->hash == obj2sym(other)->hash;
+}
+
+static fio_cstr_s fio_sym2str(fiobj_s *o) {
+  return (fio_cstr_s){.buffer = obj2sym(o)->str, .len = obj2sym(o)->len};
+}
+static int64_t fio_sym2i(fiobj_s *o) {
+  char *s = obj2str(o)->str;
+  return fio_atol(&s);
+}
+static double fio_sym2f(fiobj_s *o) {
+  char *s = obj2sym(o)->str;
+  return fio_atof(&s);
+}
+
+static struct fiobj_vtable_s FIOBJ_VTABLE_SYMBOL = {
+    .free = fiobj_simple_dealloc,
+    .to_i = fio_sym2i,
+    .to_f = fio_sym2f,
+    .to_str = fio_sym2str,
+    .is_eq = fiobj_sym_is_eq,
+    .count = fiobj_noop_count,
+    .each1 = fiobj_noop_each1,
+};
+
+/* *****************************************************************************
+Symbol API
+***************************************************************************** */
+
+static inline fiobj_s *fiobj_sym_alloc(size_t len) {
+  fiobj_head_s *head;
+  head = malloc(sizeof(*head) + sizeof(fio_sym_s) + len + 1);
+  if (!head)
+    perror("ERROR: fiobj symbol couldn't allocate memory"), exit(errno);
+  *head = (fiobj_head_s){
+      .ref = 1, .vtable = &FIOBJ_VTABLE_SYMBOL,
+  };
+  *obj2sym(HEAD2OBJ(head)) = (fio_sym_s){
+      .type = FIOBJ_T_SYMBOL, .len = len,
+  };
+  obj2sym(HEAD2OBJ(head))->str[len] = 0;
+  return HEAD2OBJ(head);
+}
+
+/** Creates a Symbol object. Use `fiobj_free`. */
+fiobj_s *fiobj_sym_new(const char *str, size_t len) {
+  fiobj_s *s = fiobj_sym_alloc(len);
+  if (str)
+    memcpy(obj2sym(s)->str, str, len);
+  obj2sym(s)->hash = (uintptr_t)fiobj_sym_hash(str, len);
+  return s;
+}
+
+/** Creates a Symbol object using a printf like interface. */
+__attribute__((format(printf, 1, 0))) fiobj_s *
+fiobj_symvprintf(const char *format, va_list argv) {
+  fiobj_s *sym = NULL;
+  va_list argv_cpy;
+  va_copy(argv_cpy, argv);
+  int len = vsnprintf(NULL, 0, format, argv_cpy);
+  va_end(argv_cpy);
+  if (len == 0) {
+    sym = fiobj_sym_alloc(0);
+    ((fio_sym_s *)(sym))->hash = fiobj_sym_hash(NULL, 0);
+  }
+  if (len <= 0)
+    return sym;
+  sym = fiobj_sym_alloc(len); /* adds 1 to len, for NUL */
+  vsnprintf(((fio_sym_s *)(sym))->str, len + 1, format, argv);
+  ((fio_sym_s *)(sym))->hash =
+      (uintptr_t)fiobj_sym_hash(((fio_sym_s *)(sym))->str, len);
+  return sym;
+}
+__attribute__((format(printf, 1, 2))) fiobj_s *
+fiobj_symprintf(const char *format, ...) {
+  va_list argv;
+  va_start(argv, format);
+  fiobj_s *sym = fiobj_symvprintf(format, argv);
+  va_end(argv);
+  return sym;
+}
+
+/** Returns 1 if both Symbols are equal and 0 if not. */
+int fiobj_sym_iseql(fiobj_s *sym1, fiobj_s *sym2) {
+  if (sym1->type != FIOBJ_T_SYMBOL || sym2->type != FIOBJ_T_SYMBOL)
+    return 0;
+  return (((fio_sym_s *)sym1)->hash == ((fio_sym_s *)sym2)->hash);
+}
+
+/**
+ * Returns a symbol's identifier.
+ *
+ * The unique identifier is calculated using SipHash and is equal for all Symbol
+ * objects that were created using the same data.
+ */
+uintptr_t fiobj_sym_id(fiobj_s *sym) {
+  if (sym->type != FIOBJ_T_SYMBOL)
+    return 0;
+  return obj2sym(sym)->hash;
+}

data/ext/iodine/fiobj_tests.c

@@ -0,0 +1,474 @@
+#ifdef DEBUG
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+#include "bscrypt.h"
+#include "fio2resp.h"
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+A JSON testing
+***************************************************************************** */
+
+int fiobj_test_json_str(char const *json, size_t len, uint8_t print_result) {
+  clock_t start, end;
+
+  fiobj_s *result = NULL;
+  start = clock();
+  size_t i = fiobj_json2obj(&result, json, len);
+  end = clock();
+  if (!i || !result) {
+    fprintf(stderr, "FAILED to parse JSON?! consumed %lu and result == %p\n", i,
+            (void *)result);
+    return -1;
+  }
+  fprintf(stderr, "* Parsed JSON in %lu\n", end - start);
+  start = clock();
+  fiobj_s *jstr = fiobj_obj2json(result, 1);
+  end = clock();
+  fprintf(stderr, "* Formatted JSON in %lu\n", end - start);
+  fprintf(stderr,
+          "Consumed %lu bytes out of %lu with result length %llu:\n%s\n", i,
+          len, fiobj_obj2cstr(jstr).length,
+          (print_result) ? fiobj_obj2cstr(jstr).buffer
+                         : "\t\tfiles aren't printed.");
+
+  start = clock();
+  fiobj_free(result);
+  end = clock();
+  fprintf(stderr, "* Freed JSON result in %lu\n", end - start);
+
+  start = clock();
+  fiobj_free(jstr);
+  end = clock();
+  fprintf(stderr, "* Freed JSON String in %lu\n", end - start);
+  return 0;
+}
+void fiobj_test_hash_json(void) {
+  fiobj_pt hash = fiobj_hash_new();
+  fiobj_pt hash2 = fiobj_hash_new();
+  fiobj_pt hash3 = fiobj_hash_new();
+  fiobj_pt syms = fiobj_ary_new(); /* freed within Hashes */
+  char num_buffer[68] = "0x";
+  fiobj_pt tmp, sym;
+
+  sym = fiobj_sym_new("id", 2);
+  fiobj_ary_push(syms, sym);
+  fiobj_hash_set(hash, sym, fiobj_num_new(bscrypt_rand64()));
+
+  sym = fiobj_sym_new("number", 6);
+  fiobj_ary_push(syms, sym);
+  fiobj_hash_set(hash, sym, fiobj_num_new(42));
+
+  sym = fiobj_sym_new("float", 5);
+  fiobj_ary_push(syms, sym);
+  fiobj_hash_set(hash, sym, fiobj_float_new(42.42));
+
+  sym = fiobj_sym_new("string", 6);
+  fiobj_ary_push(syms, sym);
+  fiobj_hash_set(
+      hash, sym,
+      fiobj_strprintf(u8"𝄞\n\ttake \\ my  \\ %s"
+                      "\n\ttake \\ my  \\ whole ❤️  %s ❤️  too...\n",
+                      "hand", "heart"));
+  sym = fiobj_sym_new("hash", 4);
+  fiobj_ary_push(syms, sym);
+  tmp = fiobj_hash_new();
+  fiobj_hash_set(hash, sym, tmp);
+
+  for (int i = 1; i < 6; i++) {
+    /* creates a temporary symbol, since we're not retriving the data */
+    sym = fiobj_symprintf("%d", i);
+    /* make sure the Hash isn't leaking */
+    for (size_t j = 0; j < 7; j++) {
+      /* set alternating key-value pairs */
+      if (i & 1)
+        fiobj_hash_set(
+            tmp, sym,
+            fiobj_str_new(num_buffer, fio_ltoa(num_buffer + 2, i, 16) + 2));
+      else
+        fiobj_hash_set(tmp, sym, fiobj_num_new(i));
+    }
+    fiobj_free(sym);
+  }
+
+  sym = fiobj_sym_new("symbols", 7);
+  fiobj_ary_push(syms, sym);
+  fiobj_hash_set(hash, sym, syms);
+
+  /* test`fiobj_iseq */
+  {
+    /* shallow copy in order */
+    size_t len = fiobj_ary_count(syms) - 1;
+    for (size_t i = 0; i <= len; i++) {
+      sym = fiobj_ary_entry(syms, i);
+      fiobj_hash_set(hash2, sym, fiobj_dup(fiobj_hash_get(hash, sym)));
+    }
+    /* shallow copy in reverse order */
+    for (size_t i = 0; i <= len; i++) {
+      sym = fiobj_ary_entry(syms, len - i);
+      fiobj_hash_set(hash3, sym, fiobj_dup(fiobj_hash_get(hash, sym)));
+    }
+    fprintf(stderr, "* Testing shallow copy reference count: %s\n",
+            (OBJ2HEAD(syms).ref == 3) ? "passed." : "FAILED!");
+    fprintf(stderr,
+            "* Testing deep object equality review:\n"
+            "  * Eq. Hash (ordered): %s\n"
+            "  * Eq. Hash (unordered): %s\n"
+            "  * Hash vs. Array: %s\n",
+            (fiobj_iseq(hash, hash2)) ? "passed." : "FAILED!",
+            (fiobj_iseq(hash, hash3)) ? "passed." : "FAILED!",
+            (fiobj_iseq(hash, syms)) ? "FAILED!" : "passed.");
+  }
+  /* print JSON string and test parser */
+  {
+    tmp = fiobj_obj2json(hash, 0);
+    fprintf(stderr,
+            "* Printing JSON (len: %llu real len: %lu capa: %lu ref: %llu):\n  "
+            " %s\n",
+            fiobj_obj2cstr(tmp).len, strlen(fiobj_obj2cstr(tmp).data),
+            fiobj_str_capa(tmp), OBJ2HEAD(tmp).ref, fiobj_obj2cstr(tmp).data);
+    fiobj_s *parsed = NULL;
+    if (fiobj_json2obj(&parsed, fiobj_obj2cstr(tmp).buffer,
+                       fiobj_obj2cstr(tmp).len) == 0) {
+      fprintf(stderr, "* FAILD to parse the JSON printed.\n");
+    } else {
+      // if (!fiobj_iseq(parsed, hash)) {
+      //   fiobj_free(tmp);
+      //   tmp = fiobj_obj2json(parsed);
+      //   fprintf(stderr, "* Parsed JSON is NOT EQUAL to original:\n%s\n\n",
+      //           fiobj_obj2cstr(tmp).data);
+      //   fiobj_free(tmp);
+      //   tmp = fiobj_obj2json(fiobj_hash_get2(parsed, "symbols", 7));
+      //   fprintf(stderr, "* Just the Symbols array (str eql == %u):\n%s\n\n",
+      //           fiobj_iseq(fiobj_hash_get2(parsed, "string", 6),
+      //                      fiobj_hash_get2(hash, "string", 6)),
+      //           fiobj_obj2cstr(tmp).data);
+      //
+      // } else {
+      //   fprintf(stderr, "* Parsed JSON is equal to original.\n");
+      // }
+      fiobj_free(parsed);
+    }
+    fiobj_free(tmp);
+  }
+#ifdef H_FIO2RESP_FORMAT_H
+  /* print RESP string */
+  tmp = resp_fioformat(hash);
+  fprintf(stderr, "* Printing RESP (len: %llu capa: %lu):\n   %s\n",
+          fiobj_obj2cstr(tmp).len, fiobj_str_capa(tmp),
+          fiobj_obj2cstr(tmp).data);
+  fiobj_free(tmp);
+#endif
+
+  sym = fiobj_sym_new("hash", 4);
+  tmp = fiobj_sym_new("1", 1);
+
+  fprintf(stderr,
+          "* Reference count for "
+          "couplet in nested Hash: %llu\n",
+          OBJ2HEAD(obj2hash(hash3)->items.next->obj).ref);
+
+  fiobj_free(hash);
+  fprintf(stderr, "* Testing nested Array delete reference count: %s\n",
+          (OBJ2HEAD(syms).ref == 2) ? "passed." : "FAILED!");
+  fprintf(stderr, "* Testing nested Hash delete reference count: %s\n",
+          (OBJ2HEAD(obj2hash(hash3)->items.next->obj).ref == 2) ? "passed."
+                                                                : "FAILED!");
+  fprintf(stderr,
+          "* Testing reference count for "
+          "nested nested object in nessted Hash: %s\n",
+          (OBJ2HEAD(fiobj_hash_get(fiobj_hash_get(hash3, sym), tmp)).ref == 2)
+              ? "passed."
+              : "FAILED!");
+  fprintf(stderr,
+          "* Reference count for "
+          "nested nested object in nested Hash: %llu\n",
+          OBJ2HEAD(fiobj_hash_get(fiobj_hash_get(hash3, sym), tmp)).ref);
+
+  fiobj_free(hash2);
+  fprintf(stderr, "* Testing nested Array delete reference count: %s\n",
+          (OBJ2HEAD(syms).ref == 1) ? "passed." : "FAILED!");
+  fprintf(stderr, "* Testing nested Hash delete reference count: %s\n",
+          (OBJ2HEAD(obj2hash(hash3)->items.next->obj).ref == 1) ? "passed."
+                                                                : "FAILED!");
+  fprintf(stderr,
+          "* Testing reference count for "
+          "nested nested object in nessted Hash: %s\n",
+          (OBJ2HEAD(obj2hash(hash3)->items.next->obj).ref == 1) ? "passed."
+                                                                : "FAILED!");
+  fprintf(stderr,
+          "* Reference count for "
+          "nested nested object in nested Hash: %llu\n",
+          OBJ2HEAD(fiobj_hash_get(fiobj_hash_get(hash3, sym), tmp)).ref);
+
+  fiobj_free(hash3);
+  fiobj_free(sym);
+  fiobj_free(tmp);
+}
+
+/* *****************************************************************************
+Test Hash performance
+***************************************************************************** */
+
+#include <time.h>
+#define HASH_TEST_SIZE ((4194304 >> 3) + (4194304 >> 4))
+#define HASH_TEST_REPEAT 1
+
+void fiobj_hash_test(void) {
+  clock_t start, end;
+  fiobj_s *syms;
+  fiobj_s *strings;
+  fiobj_s *hash;
+  fprintf(stderr, "\nTesting Hash and Array allocations\n");
+
+  start = clock();
+  syms = fiobj_ary_new();
+  strings = fiobj_ary_new();
+  for (size_t i = 0; i < HASH_TEST_SIZE; i++) {
+    fiobj_ary_push(syms, fiobj_symprintf("sym %lu", i));
+    fiobj_ary_push(strings, fiobj_strprintf("str %lu", i));
+  }
+  end = clock();
+  fprintf(stderr,
+          "* Created 2 arrays with %d symbols and strings "
+          "using printf in %lu.%lus\n",
+          HASH_TEST_SIZE << 1, (end - start) / CLOCKS_PER_SEC,
+          (end - start) - ((end - start) / CLOCKS_PER_SEC));
+
+  /******* Repeat Testing starts here *******/
+  for (size_t i = 0; i < HASH_TEST_REPEAT; i++) {
+
+    start = clock();
+    hash = fiobj_hash_new();
+    for (size_t i = 0; i < HASH_TEST_SIZE; i++) {
+      fiobj_hash_set(hash, fiobj_ary_entry(syms, i),
+                     fiobj_dup(fiobj_ary_entry(strings, i)));
+    }
+    end = clock();
+    fprintf(stderr, "* Set %d items in %lu.%lus\n", HASH_TEST_SIZE,
+            (end - start) / CLOCKS_PER_SEC,
+            (end - start) - ((end - start) / CLOCKS_PER_SEC));
+    fprintf(stderr,
+            "   - Final hash-map "
+            "length/capacity == %lu/%lu\n",
+            obj2hash(hash)->count, obj2hash(hash)->map.capa);
+    start = clock();
+    for (size_t i = 0; i < HASH_TEST_SIZE; i++) {
+      fiobj_hash_set(hash, fiobj_ary_entry(syms, i),
+                     fiobj_dup(fiobj_ary_entry(strings, i)));
+    }
+    end = clock();
+    fprintf(stderr,
+            "* Resetting %d (test count == %lu) "
+            "items in %lu.%lus\n",
+            HASH_TEST_SIZE, fiobj_hash_count(hash),
+            (end - start) / CLOCKS_PER_SEC,
+            (end - start) - ((end - start) / CLOCKS_PER_SEC));
+
+    start = clock();
+    for (size_t i = 0; i < HASH_TEST_SIZE; i++) {
+      if (fiobj_hash_get(hash, fiobj_ary_entry(syms, i)) !=
+          fiobj_ary_entry(strings, i))
+        fprintf(stderr, "ERROR: fiobj_hash_get FAILED for %s != %s\n",
+                fiobj_obj2cstr(fiobj_ary_entry(strings, i)).data,
+                fiobj_obj2cstr(fiobj_hash_get(hash, fiobj_ary_entry(syms, i)))
+                    .data),
+            exit(-1);
+    }
+    end = clock();
+    fprintf(stderr, "* Seek and test %d items in %lu.%lus\n", HASH_TEST_SIZE,
+            (end - start) / CLOCKS_PER_SEC,
+            (end - start) - ((end - start) / CLOCKS_PER_SEC));
+
+    start = clock();
+    fiobj_free(hash);
+    end = clock();
+    fprintf(stderr, "* Destroy hash with %d items in %lu.%lus\n",
+            HASH_TEST_SIZE, (end - start) / CLOCKS_PER_SEC,
+            (end - start) - ((end - start) / CLOCKS_PER_SEC));
+
+    /******* Repeat Testing ends here *******/
+  }
+
+  /** cleanup **/
+
+  start = clock();
+  fiobj_free(syms);
+  fiobj_free(strings);
+  end = clock();
+  fprintf(stderr,
+          "Deallocated 2 arrays with %d symbols and strings "
+          "in %lu.%lus\n\n",
+          HASH_TEST_SIZE << 1, (end - start) / CLOCKS_PER_SEC,
+          (end - start) - ((end - start) / CLOCKS_PER_SEC));
+}
+
+/* *****************************************************************************
+Basic tests fiobj types
+***************************************************************************** */
+static char num_buffer[148];
+
+/* test were written for OSX (fprintf types) with clang (%s for NULL is okay)
+ */
+void fiobj_test(void) {
+  /* test hash+array for memory leaks and performance*/
+  fiobj_hash_test();
+  /* test JSON (I know... it assumes everything else works...) */
+  for (int i = 0; i < 1; ++i) {
+    fiobj_test_hash_json();
+  }
+  /* start simple tests */
+
+  fiobj_s *obj;
+  size_t i;
+  fprintf(stderr, "\n===\nStarting fiobj basic testing:\n");
+
+  obj = fiobj_null();
+  if (obj->type != FIOBJ_T_NULL)
+    fprintf(stderr, "* FAILED null object test.\n");
+  fiobj_free(obj);
+
+  obj = fiobj_false();
+  if (obj->type != FIOBJ_T_FALSE)
+    fprintf(stderr, "* FAILED false object test.\n");
+  fiobj_free(obj);
+
+  obj = fiobj_true();
+  if (obj->type != FIOBJ_T_TRUE)
+    fprintf(stderr, "* FAILED true object test.\n");
+  fiobj_free(obj);
+
+  obj = fiobj_num_new(255);
+  if (obj->type != FIOBJ_T_NUMBER || fiobj_obj2num(obj) != 255)
+    fprintf(stderr, "* FAILED 255 object test i == %llu with type %d.\n",
+            fiobj_obj2num(obj), obj->type);
+  if (strcmp(fiobj_obj2cstr(obj).data, "255"))
+    fprintf(stderr, "* FAILED base 10 fiobj_obj2cstr test with %s.\n",
+            fiobj_obj2cstr(obj).data);
+  i = fio_ltoa(num_buffer, fiobj_obj2num(obj), 16);
+  if (strcmp(num_buffer, "00FF"))
+    fprintf(stderr, "* FAILED base 16 fiobj_obj2cstr test with (%lu): %s.\n", i,
+            num_buffer);
+  i = fio_ltoa(num_buffer, fiobj_obj2num(obj), 2);
+  if (strcmp(num_buffer, "011111111"))
+    fprintf(stderr, "* FAILED base 2 fiobj_obj2cstr test with (%lu): %s.\n", i,
+            num_buffer);
+  fiobj_free(obj);
+
+  obj = fiobj_float_new(77.777);
+  if (obj->type != FIOBJ_T_FLOAT || fiobj_obj2num(obj) != 77 ||
+      fiobj_obj2float(obj) != 77.777)
+    fprintf(stderr, "* FAILED 77.777 object test.\n");
+  if (strcmp(fiobj_obj2cstr(obj).data, "77.777"))
+    fprintf(stderr, "* FAILED float2str test with %s.\n",
+            fiobj_obj2cstr(obj).data);
+  fiobj_free(obj);
+
+  obj = fiobj_str_new("0x7F", 4);
+  if (obj->type != FIOBJ_T_STRING || fiobj_obj2num(obj) != 127)
+    fprintf(stderr, "* FAILED 0x7F object test.\n");
+  fiobj_free(obj);
+
+  obj = fiobj_str_new("0b01111111", 10);
+  if (obj->type != FIOBJ_T_STRING || fiobj_obj2num(obj) != 127)
+    fprintf(stderr, "* FAILED 0b01111111 object test.\n");
+  fiobj_free(obj);
+
+  obj = fiobj_str_new("232.79", 6);
+  if (obj->type != FIOBJ_T_STRING || fiobj_obj2num(obj) != 232)
+    fprintf(stderr, "* FAILED 232 object test. %llu\n", fiobj_obj2num(obj));
+  if (fiobj_obj2float(obj) != 232.79)
+    fprintf(stderr, "* FAILED fiobj_obj2float test with %f.\n",
+            fiobj_obj2float(obj));
+  fiobj_free(obj);
+
+  /* test array */
+  obj = fiobj_ary_new();
+  if (obj->type == FIOBJ_T_ARRAY) {
+    fprintf(stderr, "* testing Array. \n");
+    for (size_t i = 0; i < 128; i++) {
+      fiobj_ary_unshift(obj, fiobj_num_new(i));
+      if (fiobj_ary_count(obj) != i + 1)
+        fprintf(stderr, "* FAILED Array count. %lu/%llu != %lu\n",
+                fiobj_ary_count(obj), obj2ary(obj)->capa, i + 1);
+    }
+    fiobj_s *tmp = fiobj_obj2json(obj, 0);
+    fprintf(stderr, "Array test printout:\n%s\n",
+            tmp ? obj2str(tmp)->str : "ERROR");
+    fiobj_free(tmp);
+    fiobj_free(obj);
+  } else {
+    fprintf(stderr, "* FAILED to initialize Array test!\n");
+    fiobj_free(obj);
+  }
+
+/* test cyclic protection */
+#if FIOBJ_NESTING_PROTECTION == 1
+  {
+    fprintf(stderr, "* testing cyclic protection. \n");
+    fiobj_s *a1 = fiobj_ary_new();
+    fiobj_s *a2 = fiobj_ary_new();
+    for (size_t i = 0; i < 129; i++) {
+      obj = fiobj_num_new(1024 + i);
+      fiobj_ary_push(a1, fiobj_num_new(i));
+      fiobj_ary_unshift(a2, fiobj_num_new(i));
+      fiobj_ary_push(a1, fiobj_dup(obj));
+      fiobj_ary_unshift(a2, obj);
+    }
+    fiobj_ary_push(a1, a2); /* the intentionally offending code */
+    fiobj_ary_push(a2, a1);
+    fprintf(stderr,
+            "* Printing cyclic array references with "
+            "a1, pos %llu  == a2 and a2, pos %llu == a1\n",
+            obj2ary(a1)->end, obj2ary(a2)->end);
+    {
+      fiobj_s *tmp = fiobj_obj2json(a1, 0);
+      fprintf(stderr, "%s\n", tmp ? obj2str(tmp)->str : "ERROR");
+      fiobj_free(tmp);
+    }
+
+    obj = fiobj_dup(fiobj_ary_entry(a2, -3));
+    if (!obj || obj->type != FIOBJ_T_NUMBER)
+      fprintf(stderr, "* FAILED unexpected object %p with type %d\n",
+              (void *)obj, obj ? obj->type : 0);
+    if (OBJ2HEAD(obj).ref < 2)
+      fprintf(stderr, "* FAILED object reference counting test (%llu)\n",
+              OBJ2HEAD(obj).ref);
+    fiobj_free(a1); /* frees both... */
+    // fiobj_free(a2);
+    if (OBJ2HEAD(obj).ref != 1)
+      fprintf(stderr,
+              "* FAILED to free cyclic nested "
+              "array members (%llu)\n ",
+              OBJ2HEAD(obj).ref);
+    fiobj_free(obj);
+  }
+#endif
+
+  /* test deep nesting */
+  {
+    fprintf(stderr, "* testing deep array nesting. \n");
+    fiobj_s *top = fiobj_ary_new();
+    fiobj_s *pos = top;
+    for (size_t i = 0; i < 128; i++) {
+      for (size_t j = 0; j < 128; j++) {
+        fiobj_ary_push(pos, fiobj_num_new(j));
+      }
+      fiobj_ary_push(pos, fiobj_ary_new());
+      pos = fiobj_ary_entry(pos, -1);
+      if (!pos || pos->type != FIOBJ_T_ARRAY) {
+        fprintf(stderr, "* FAILED Couldn't retrive position -1 (%d)\n",
+                pos ? pos->type : 0);
+        break;
+      }
+    }
+    fiobj_free(top); /* frees both... */
+  }
+  fprintf(stderr, "* finished fiobj testing.\n");
+}
+#endif