core: add unit tests on hdata

1 files changed, 2146 insertions, 12 deletions

diff --git a/tests/unit/core/test-core-hdata.cpp b/tests/unit/core/test-core-hdata.cpp
index 50b895181..008a5c4f0 100644
--- a/tests/unit/core/test-core-hdata.cpp
+++ b/tests/unit/core/test-core-hdata.cpp
@@ -24,6 +24,104 @@
 extern "C"
 {
 #include "src/core/wee-hdata.h"
+#include "src/core/wee-config.h"
+#include "src/core/wee-hashtable.h"
+#include "src/core/wee-hook.h"
+#include "src/core/wee-string.h"
+#include "src/gui/gui-buffer.h"
+#include "src/plugins/plugin.h"
+}
+
+struct t_test_item
+{
+    /* char */
+    char test_char;
+    char test_count_char;
+    char test_array_2_char_fixed_size[2];
+    char *test_ptr_2_char;
+
+    /* integer */
+    int test_int;
+    int test_count_int;
+    int test_array_2_int_fixed_size[2];
+    int *test_ptr_3_int;
+    int *test_ptr_1_int_fixed_size;
+
+    /* long */
+    long test_long;
+    long test_count_long;
+    long test_array_2_long_fixed_size[2];
+    long *test_ptr_2_long;
+
+    /* string */
+    char *test_string;
+    char *test_string2;
+    char *test_string3;
+    char *test_string_null;
+    const char *test_shared_string;
+    int test_count_words;
+    char test_array_2_words_fixed_size[2][32];
+    char **test_ptr_words;
+    char **test_ptr_words_dyn;
+    char **test_ptr_words_dyn_shared;
+
+    /* pointer */
+    void *test_pointer;
+    int test_count_pointer;
+    void *test_array_2_pointer_fixed_size[2];
+    void **test_ptr_3_pointer;
+    void **test_ptr_0_pointer_dyn;
+    void **test_ptr_1_pointer_dyn;
+
+    /* time */
+    time_t test_time;
+    int test_count_time;
+    time_t test_array_2_time_fixed_size[2];
+    time_t *test_ptr_2_time;
+
+    /* hashtable */
+    struct t_hashtable *test_hashtable;
+    int test_count_hashtable;
+    struct t_hashtable *test_array_2_hashtable_fixed_size[2];
+    struct t_hashtable **test_ptr_2_hashtable;
+    struct t_hashtable **test_ptr_1_hashtable_dyn;
+
+    /* other */
+    void *test_other;
+    int test_count_other;
+    void *test_ptr_3_other[3];
+
+    /* invalid */
+    char *test_count_invalid;
+    int *test_ptr_invalid;
+
+    struct t_test_item *prev_item;
+    struct t_test_item *next_item;
+};
+
+struct t_test_item *items = NULL;
+struct t_test_item *last_item = NULL;
+struct t_test_item *ptr_item1 = NULL;
+struct t_test_item *ptr_item2 = NULL;
+struct t_hdata *ptr_hdata = NULL;
+
+/*
+ * Test of update callback.
+ */
+
+int
+callback_update_dummy (void *data,
+                       struct t_hdata *hdata,
+                       void *pointer,
+                       struct t_hashtable *hashtable)
+{
+    /* make C++ compiler happy */
+    (void) data;
+    (void) hdata;
+    (void) pointer;
+    (void) hashtable;
+
+    return 0;
 }
 
 TEST_GROUP(CoreHdata)
@@ -33,31 +131,1114 @@ TEST_GROUP(CoreHdata)
 /*
  * Tests functions:
  *   hdata_new
+ */
+
+TEST(CoreHdata, New)
+{
+    struct t_hdata *hdata;
+
+    POINTERS_EQUAL(NULL, hdata_new (NULL, NULL, NULL, NULL, 0, 0, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_new (NULL, "", NULL, NULL, 0, 0, NULL, NULL));
+
+    hdata = hdata_new (NULL, "test_hdata", NULL, NULL, 1, 0, NULL, NULL);
+    CHECK(hdata);
+    POINTERS_EQUAL(hdata, hashtable_get (weechat_hdata, "test_hdata"));
+    STRCMP_EQUAL("test_hdata", hdata->name);
+    POINTERS_EQUAL(NULL, hdata->plugin);
+    POINTERS_EQUAL(NULL, hdata->var_prev);
+    POINTERS_EQUAL(NULL, hdata->var_next);
+    CHECK(hdata->hash_var);
+    LONGS_EQUAL(0, hdata->hash_var->items_count);
+    CHECK(hdata->hash_list);
+    LONGS_EQUAL(0, hdata->hash_list->items_count);
+    LONGS_EQUAL(1, hdata->create_allowed);
+    LONGS_EQUAL(0, hdata->delete_allowed);
+    POINTERS_EQUAL(NULL, hdata->callback_update);
+    POINTERS_EQUAL(NULL, hdata->callback_update_data);
+    LONGS_EQUAL(0, hdata->update_pending);
+    hashtable_remove (weechat_hdata, "test_hdata");
+    POINTERS_EQUAL(NULL, hashtable_get (weechat_hdata, "test_hdata"));
+
+    hdata = hdata_new (NULL, "test_hdata", "prev", "next", 1, 0,
+                       &callback_update_dummy, (void *)0x123);
+    CHECK(hdata);
+    POINTERS_EQUAL(hdata, hashtable_get (weechat_hdata, "test_hdata"));
+    STRCMP_EQUAL("test_hdata", hdata->name);
+    POINTERS_EQUAL(NULL, hdata->plugin);
+    STRCMP_EQUAL("prev", hdata->var_prev);
+    STRCMP_EQUAL("next", hdata->var_next);
+    CHECK(hdata->hash_var);
+    LONGS_EQUAL(0, hdata->hash_var->items_count);
+    CHECK(hdata->hash_list);
+    LONGS_EQUAL(0, hdata->hash_list->items_count);
+    LONGS_EQUAL(1, hdata->create_allowed);
+    LONGS_EQUAL(0, hdata->delete_allowed);
+    POINTERS_EQUAL(&callback_update_dummy, hdata->callback_update);
+    POINTERS_EQUAL(0x123, hdata->callback_update_data);
+    LONGS_EQUAL(0, hdata->update_pending);
+    hashtable_remove (weechat_hdata, "test_hdata");
+    POINTERS_EQUAL(NULL, hashtable_get (weechat_hdata, "test_hdata"));
+}
+
+/*
+ * Tests functions:
  *   hdata_new_var
+ */
+
+TEST(CoreHdata, NewVar)
+{
+    struct t_hdata *hdata;
+    struct t_hdata_var *var;
+
+    hdata = hdata_new (NULL, "test_hdata", "prev", "next", 1, 0,
+                       &callback_update_dummy, (void *)0x123);
+    CHECK(hdata);
+    CHECK(hdata->hash_var);
+    LONGS_EQUAL(0, hdata->hash_var->items_count);
+
+    hdata_new_var (NULL, NULL, 0, 0, 0, NULL, NULL);
+    hdata_new_var (hdata, NULL, 0, 0, 0, NULL, NULL);
+    hdata_new_var (NULL, "var", 0, 0, 0, NULL, NULL);
+
+    LONGS_EQUAL(0, hdata->hash_var->items_count);
+
+    /* simple variable */
+    hdata_new_var (hdata, "var1", 0, WEECHAT_HDATA_STRING, 0, NULL, NULL);
+    LONGS_EQUAL(1, hdata->hash_var->items_count);
+    var = (struct t_hdata_var *)hashtable_get (hdata->hash_var, "var1");
+    CHECK(var);
+    LONGS_EQUAL(0, var->offset);
+    LONGS_EQUAL(WEECHAT_HDATA_STRING, var->type);
+    LONGS_EQUAL(0, var->update_allowed);
+    POINTERS_EQUAL(NULL, var->array_size);
+    POINTERS_EQUAL(NULL, var->hdata_name);
+
+    /* variable with size as variable name */
+    hdata_new_var (hdata, "var2", 8, WEECHAT_HDATA_INTEGER, 1,
+                   "size", "other_hdata");
+    LONGS_EQUAL(2, hdata->hash_var->items_count);
+    var = (struct t_hdata_var *)hashtable_get (hdata->hash_var, "var2");
+    CHECK(var);
+    LONGS_EQUAL(8, var->offset);
+    LONGS_EQUAL(WEECHAT_HDATA_INTEGER, var->type);
+    LONGS_EQUAL(1, var->update_allowed);
+    STRCMP_EQUAL("size", var->array_size);
+    STRCMP_EQUAL("other_hdata", var->hdata_name);
+
+    /* variable with size as integer (fixed size) */
+    hdata_new_var (hdata, "var3", 16, WEECHAT_HDATA_INTEGER, 1,
+                   "8", "other_hdata");
+    LONGS_EQUAL(3, hdata->hash_var->items_count);
+    var = (struct t_hdata_var *)hashtable_get (hdata->hash_var, "var3");
+    CHECK(var);
+    LONGS_EQUAL(16, var->offset);
+    LONGS_EQUAL(WEECHAT_HDATA_INTEGER, var->type);
+    LONGS_EQUAL(1, var->update_allowed);
+    STRCMP_EQUAL("8", var->array_size);
+    STRCMP_EQUAL("other_hdata", var->hdata_name);
+
+    /* variable with size "*" (automatic) */
+    hdata_new_var (hdata, "var4", 24, WEECHAT_HDATA_INTEGER, 1,
+                   "*", "other_hdata");
+    LONGS_EQUAL(4, hdata->hash_var->items_count);
+    var = (struct t_hdata_var *)hashtable_get (hdata->hash_var, "var4");
+    CHECK(var);
+    LONGS_EQUAL(24, var->offset);
+    LONGS_EQUAL(WEECHAT_HDATA_INTEGER, var->type);
+    LONGS_EQUAL(1, var->update_allowed);
+    STRCMP_EQUAL("*", var->array_size);
+    STRCMP_EQUAL("other_hdata", var->hdata_name);
+
+    hashtable_remove (weechat_hdata, "test_hdata");
+}
+
+/*
+ * Tests functions:
  *   hdata_new_list
  */
 
-TEST(CoreHdata, New)
+TEST(CoreHdata, NewList)
 {
-    /* TODO: write tests */
+    struct t_hdata *hdata;
+    struct t_hdata_list *list;
+
+    hdata = hdata_new (NULL, "test_hdata", "prev", "next", 1, 0,
+                       &callback_update_dummy, (void *)0x123);
+    CHECK(hdata);
+    CHECK(hdata->hash_list);
+    LONGS_EQUAL(0, hdata->hash_list->items_count);
+
+    hdata_new_list (NULL, NULL, NULL, 0);
+    hdata_new_list (hdata, NULL, NULL, 0);
+    hdata_new_list (NULL, "list", NULL, 0);
+
+    LONGS_EQUAL(0, hdata->hash_list->items_count);
+
+    hdata_new_list (hdata, "list1", (void *)0x123, 0);
+    LONGS_EQUAL(1, hdata->hash_list->items_count);
+    list = (struct t_hdata_list *)hashtable_get (hdata->hash_list, "list1");
+    CHECK(list);
+    POINTERS_EQUAL(0x123, list->pointer);
+    LONGS_EQUAL(0, list->flags);
+
+    hdata_new_list (hdata, "list2", (void *)0x456,
+                    WEECHAT_HDATA_LIST_CHECK_POINTERS);
+    LONGS_EQUAL(2, hdata->hash_list->items_count);
+    list = (struct t_hdata_list *)hashtable_get (hdata->hash_list, "list2");
+    CHECK(list);
+    POINTERS_EQUAL(0x456, list->pointer);
+    LONGS_EQUAL(WEECHAT_HDATA_LIST_CHECK_POINTERS, list->flags);
+
+    hashtable_remove (weechat_hdata, "test_hdata");
 }
 
+TEST_GROUP(CoreHdataWithList)
+{
+    static int callback_update (void *data,
+                                struct t_hdata *hdata,
+                                void *pointer,
+                                struct t_hashtable *hashtable)
+    {
+        const char *ptr_keys;
+        char **keys;
+        int rc, i, num_keys;
+
+        /* make C++ compiler happy */
+        (void) data;
+        (void) hdata;
+        (void) pointer;
+
+        rc = 0;
+
+        ptr_keys = hashtable_get_string (hashtable, "keys");
+        if (!ptr_keys || !ptr_keys[0])
+            return rc;
+
+        keys = string_split (ptr_keys, ",", NULL, 0, 0, &num_keys);
+        if (!keys)
+            return rc;
+
+        for (i = 0; i < num_keys; i++)
+        {
+            if (hashtable_has_key (hashtable, keys[i]))
+            {
+                rc += hdata_set (
+                    hdata, pointer, keys[i],
+                    (const char *)hashtable_get (hashtable, keys[i]));
+            }
+        }
+
+        string_free_split (keys);
+
+        return rc;
+    }
+
+    struct t_test_item *get_item1 ()
+    {
+        struct t_test_item *item;
+
+        item = (struct t_test_item *)malloc (sizeof (*item));
+
+        /* char */
+        item->test_char = 'A';
+        item->test_count_char = 2;
+        item->test_array_2_char_fixed_size[0] = 'A';
+        item->test_array_2_char_fixed_size[1] = 'B';
+        item->test_ptr_2_char = (char *)malloc (
+            2 * sizeof (item->test_ptr_2_char[0]));
+        item->test_ptr_2_char[0] = 'B';
+        item->test_ptr_2_char[1] = 'C';
+
+        /* integer */
+        item->test_int = 123;
+        item->test_count_int = 3;
+        item->test_array_2_int_fixed_size[0] = 111;
+        item->test_array_2_int_fixed_size[1] = 222;
+        item->test_ptr_3_int = (int *)malloc (
+            3 * sizeof (item->test_ptr_3_int[0]));
+        item->test_ptr_3_int[0] = 1;
+        item->test_ptr_3_int[1] = 2;
+        item->test_ptr_3_int[2] = 3;
+        item->test_ptr_1_int_fixed_size = (int *)malloc (
+            1 * sizeof (item->test_ptr_1_int_fixed_size[0]));
+        item->test_ptr_1_int_fixed_size[0] = 111;
+
+        /* long */
+        item->test_long = 123456789L;
+        item->test_count_long = 2;
+        item->test_array_2_long_fixed_size[0] = 111L;
+        item->test_array_2_long_fixed_size[1] = 222L;
+        item->test_ptr_2_long = (long *)malloc (
+            2 * sizeof (item->test_ptr_2_long[0]));
+        item->test_ptr_2_long[0] = 123456L;
+        item->test_ptr_2_long[1] = 234567L;
+
+        /* string */
+        item->test_string = strdup ("item1");
+        item->test_string2 = strdup ("STRING2");
+        item->test_string3 = strdup ("test");
+        item->test_string_null = NULL;
+        item->test_shared_string = string_shared_get ("item1_shared");
+        strcpy (item->test_array_2_words_fixed_size[0], "item1-word1");
+        strcpy (item->test_array_2_words_fixed_size[1], "item1-word2");
+        item->test_ptr_words = string_split (
+            "a,b,c", ",", NULL, 0, 0, &(item->test_count_words));
+        item->test_ptr_words_dyn = string_split (
+            "aa,bb,cc", ",", NULL, 0, 0, NULL);
+        item->test_ptr_words_dyn_shared = string_split_shared (
+            "aaa,bbb,ccc", ",", NULL, 0, 0, NULL);
+
+        /* pointer */
+        item->test_pointer = (void *)0x123;
+        item->test_count_pointer = 3;
+        item->test_array_2_pointer_fixed_size[0] = (void *)0x112233;
+        item->test_array_2_pointer_fixed_size[1] = (void *)0x445566;
+        item->test_ptr_3_pointer = (void **)malloc (
+            3 * sizeof (item->test_ptr_3_pointer[0]));
+        item->test_ptr_3_pointer[0] = (void *)0x123;
+        item->test_ptr_3_pointer[1] = (void *)0x456;
+        item->test_ptr_3_pointer[2] = (void *)0x789;
+        item->test_ptr_0_pointer_dyn = NULL;
+        item->test_ptr_1_pointer_dyn = (void **)malloc (
+            2 * sizeof (item->test_ptr_1_pointer_dyn[0]));
+        item->test_ptr_1_pointer_dyn[0] = (void *)0x123;
+        item->test_ptr_1_pointer_dyn[1] = NULL;
+
+        /* time */
+        item->test_time = 123456;
+        item->test_count_time = 2;
+        item->test_array_2_time_fixed_size[0] = 112;
+        item->test_array_2_time_fixed_size[1] = 334;
+        item->test_ptr_2_time = (time_t *)malloc (
+            2 * sizeof (item->test_ptr_2_time[0]));
+        item->test_ptr_2_time[0] = 1234;
+        item->test_ptr_2_time[1] = 5678;
+
+        /* hashtable */
+        item->test_hashtable = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_hashtable, "key1", "value1");
+        item->test_count_hashtable = 2;
+        item->test_array_2_hashtable_fixed_size[0] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_array_2_hashtable_fixed_size[0],
+                       "key_array_1.1", "value_array_1.1");
+        item->test_array_2_hashtable_fixed_size[1] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_array_2_hashtable_fixed_size[1],
+                       "key_array_1.2", "value_array_1.2");
+        item->test_ptr_2_hashtable = (struct t_hashtable **)malloc (
+            2 * sizeof (item->test_ptr_2_hashtable[0]));
+        item->test_ptr_2_hashtable[0] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_ptr_2_hashtable[0],
+                       "key1.1", "value1.1");
+        item->test_ptr_2_hashtable[1] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_ptr_2_hashtable[1],
+                       "key1.2", "value1.2");
+        item->test_ptr_1_hashtable_dyn = (struct t_hashtable **)malloc (
+            1 * sizeof (item->test_ptr_2_hashtable[0]));
+        item->test_ptr_1_hashtable_dyn[0] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        item->test_ptr_1_hashtable_dyn[1] = NULL;
+
+        /* other */
+        item->test_other = (void *)0x123abc;
+        item->test_count_other = 3;
+        item->test_ptr_3_other[0] = (void *)0x1a;
+        item->test_ptr_3_other[1] = (void *)0x2b;
+        item->test_ptr_3_other[2] = (void *)0x3c;
+
+        /* invalid */
+        item->test_count_invalid = NULL;
+        item->test_ptr_invalid = NULL;
+
+        return item;
+    }
+
+    struct t_test_item *get_item2 ()
+    {
+        struct t_test_item *item;
+
+        item = (struct t_test_item *)malloc (sizeof (*item));
+
+        /* char */
+        item->test_char = 'a';
+        item->test_count_char = 2;
+        item->test_array_2_char_fixed_size[0] = 'a';
+        item->test_array_2_char_fixed_size[1] = 'b';
+        item->test_ptr_2_char = (char *)malloc (
+            2 * sizeof (item->test_ptr_2_char[0]));
+        item->test_ptr_2_char[0] = 'b';
+        item->test_ptr_2_char[1] = 'c';
+
+        /* integer */
+        item->test_int = 456;
+        item->test_count_int = 3;
+        item->test_array_2_int_fixed_size[0] = 444;
+        item->test_array_2_int_fixed_size[1] = 555;
+        item->test_ptr_3_int = (int *)malloc (
+            3 * sizeof (item->test_ptr_3_int[0]));
+        item->test_ptr_3_int[0] = 4;
+        item->test_ptr_3_int[1] = 5;
+        item->test_ptr_3_int[2] = 6;
+        item->test_ptr_1_int_fixed_size = (int *)malloc (
+            1 * sizeof (item->test_ptr_1_int_fixed_size[0]));
+        item->test_ptr_1_int_fixed_size[0] = 222;
+
+        /* long */
+        item->test_long = 987654321L;
+        item->test_count_long = 2;
+        item->test_array_2_long_fixed_size[0] = 333L;
+        item->test_array_2_long_fixed_size[1] = 444L;
+        item->test_ptr_2_long = (long *)malloc (
+            2 * sizeof (item->test_ptr_2_long[0]));
+        item->test_ptr_2_long[0] = 789123L;
+        item->test_ptr_2_long[1] = 891234L;
+
+        /* string */
+        item->test_string = strdup ("item2");
+        item->test_string2 = strdup ("string2");
+        item->test_string3 = NULL;
+        ptr_item1->test_string_null = NULL;
+        item->test_shared_string = string_shared_get ("item2_shared");
+        strcpy (item->test_array_2_words_fixed_size[0], "item2-word1");
+        strcpy (item->test_array_2_words_fixed_size[1], "item2-word2");
+        item->test_ptr_words = string_split (
+            "e,f,g,h", ",", NULL, 0, 0, &(item->test_count_words));
+        item->test_ptr_words_dyn = string_split (
+            "ee,ff,gg,hh", ",", NULL, 0, 0, NULL);
+        item->test_ptr_words_dyn_shared = string_split_shared (
+            "eee,fff,ggg,hhh", ",", NULL, 0, 0, NULL);
+
+        /* pointer */
+        item->test_pointer = (void *)0x456;
+        item->test_count_pointer = 3;
+        item->test_array_2_pointer_fixed_size[0] = (void *)0x778899;
+        item->test_array_2_pointer_fixed_size[1] = (void *)0xaabbcc;
+        item->test_ptr_3_pointer = (void **)malloc (
+            3 * sizeof (item->test_ptr_3_pointer[0]));
+        item->test_ptr_3_pointer[0] = (void *)0x123abc;
+        item->test_ptr_3_pointer[1] = (void *)0x456def;
+        item->test_ptr_3_pointer[2] = (void *)0x789abc;
+        item->test_ptr_0_pointer_dyn = NULL;
+        item->test_ptr_1_pointer_dyn = (void **)malloc (
+            2 * sizeof (item->test_ptr_1_pointer_dyn[0]));
+        item->test_ptr_1_pointer_dyn[0] = (void *)0x456;
+        item->test_ptr_1_pointer_dyn[1] = NULL;
+
+        /* time */
+        item->test_time = 789123;
+        item->test_count_time = 2;
+        item->test_array_2_time_fixed_size[0] = 556;
+        item->test_array_2_time_fixed_size[1] = 778;
+        item->test_ptr_2_time = (time_t *)malloc (
+            2 * sizeof (item->test_ptr_2_time[0]));
+        item->test_ptr_2_time[0] = 123456;
+        item->test_ptr_2_time[1] = 789123;
+
+        /* hashtable */
+        item->test_hashtable = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_hashtable, "key2", "value2");
+        item->test_count_hashtable = 2;
+        item->test_array_2_hashtable_fixed_size[0] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_array_2_hashtable_fixed_size[0],
+                       "key_array_2.1", "value_array_2.1");
+        item->test_array_2_hashtable_fixed_size[1] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_array_2_hashtable_fixed_size[1],
+                       "key_array_2.2", "value_array_2.2");
+        item->test_ptr_2_hashtable = (struct t_hashtable **)malloc (
+            2 * sizeof (item->test_ptr_2_hashtable[0]));
+        item->test_ptr_2_hashtable[0] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_ptr_2_hashtable[0],
+                       "key2.1", "value2.1");
+        item->test_ptr_2_hashtable[1] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        hashtable_set (item->test_ptr_2_hashtable[1],
+                       "key2.2", "value2.2");
+        item->test_ptr_1_hashtable_dyn = (struct t_hashtable **)malloc (
+            1 * sizeof (item->test_ptr_2_hashtable[0]));
+        item->test_ptr_1_hashtable_dyn[0] = hashtable_new (
+            8,
+            WEECHAT_HASHTABLE_STRING,
+            WEECHAT_HASHTABLE_STRING,
+            NULL,
+            NULL);
+        item->test_ptr_1_hashtable_dyn[1] = NULL;
+
+        /* other */
+        item->test_other = (void *)0x456def;
+        item->test_count_other = 3;
+        item->test_ptr_3_other[0] = (void *)0x4d;
+        item->test_ptr_3_other[1] = (void *)0x5e;
+        item->test_ptr_3_other[2] = (void *)0x6f;
+
+        /* invalid */
+        item->test_count_invalid = NULL;
+        item->test_ptr_invalid = NULL;
+
+        return item;
+    }
+
+    struct t_hdata *get_hdata ()
+    {
+        struct t_hdata *hdata;
+
+        hdata = hdata_new (NULL, "test_item", "prev_item", "next_item",
+                           1, 1,
+                           &callback_update, NULL);
+
+        /* char */
+        HDATA_VAR(struct t_test_item, test_char, CHAR, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_char, CHAR, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_array_2_char_fixed_size, CHAR, 0, "2", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_2_char, CHAR, 0, "*,test_count_char", NULL);
+
+        /* integer */
+        HDATA_VAR(struct t_test_item, test_int, INTEGER, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_int, INTEGER, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_array_2_int_fixed_size, INTEGER, 0, "2", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_3_int, INTEGER, 0, "*,test_count_int", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_1_int_fixed_size, INTEGER, 0, "*,1", NULL);
+
+        /* long */
+        HDATA_VAR(struct t_test_item, test_long, LONG, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_long, LONG, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_array_2_long_fixed_size, LONG, 0, "2", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_2_long, LONG, 0, "*,test_count_long", NULL);
+
+        /* string */
+        HDATA_VAR(struct t_test_item, test_string, STRING, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_string2, STRING, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_string3, STRING, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_string_null, STRING, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_shared_string, SHARED_STRING, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_words, INTEGER, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_array_2_words_fixed_size, STRING, 0, "2", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_words, STRING, 0, "*,test_count_words", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_words_dyn, STRING, 0, "*,*", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_words_dyn_shared, SHARED_STRING, 0, "*,*", NULL);
+
+        /* pointer */
+        HDATA_VAR(struct t_test_item, test_pointer, POINTER, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_pointer, INTEGER, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_array_2_pointer_fixed_size, POINTER, 0, "2", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_3_pointer, POINTER, 0, "*,test_count_pointer", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_0_pointer_dyn, POINTER, 0, "*,*", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_1_pointer_dyn, POINTER, 0, "*,*", NULL);
+
+        /* time */
+        HDATA_VAR(struct t_test_item, test_time, TIME, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_time, INTEGER, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_array_2_time_fixed_size, TIME, 0, "2", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_2_time, TIME, 0, "*,test_count_time", NULL);
+
+        /* hashtable */
+        HDATA_VAR(struct t_test_item, test_hashtable, HASHTABLE, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_hashtable, INTEGER, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_array_2_hashtable_fixed_size, HASHTABLE, 0, "2", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_2_hashtable, HASHTABLE, 0, "*,test_count_hashtable", NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_1_hashtable_dyn, HASHTABLE, 0, "*,*", NULL);
+
+        /* other */
+        HDATA_VAR(struct t_test_item, test_other, OTHER, 1, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_count_other, INTEGER, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_3_other, OTHER, 0, "test_count_other", NULL);
+
+        /* invalid */
+        HDATA_VAR(struct t_test_item, test_count_invalid, STRING, 0, NULL, NULL);
+        HDATA_VAR(struct t_test_item, test_ptr_invalid, STRING, 0, "test_count_invalid", NULL);
+
+        /* prev/next item */
+        HDATA_VAR(struct t_test_item, prev_item, POINTER, 0, NULL, "test_item");
+        HDATA_VAR(struct t_test_item, next_item, POINTER, 0, NULL, "test_item");
+
+        /* lists */
+        HDATA_LIST(items, WEECHAT_HDATA_LIST_CHECK_POINTERS);
+        HDATA_LIST(last_item, 0);
+
+        return hdata;
+    }
+
+    void setup ()
+    {
+        /* build items */
+        ptr_item1 = get_item1 ();
+        ptr_item2 = get_item2 ();
+
+        /* build a linked list: items: ptr_item1 -> ptr_item2 -> NULL */
+        ptr_item1->prev_item = NULL;
+        ptr_item1->next_item = ptr_item2;
+        ptr_item2->prev_item = ptr_item1;
+        ptr_item2->next_item = NULL;
+        items = ptr_item1;
+        last_item = ptr_item2;
+
+        /* build hdata */
+        ptr_hdata = get_hdata ();
+    }
+
+    void free_item (struct t_test_item *item)
+    {
+        /* char */
+        free (item->test_ptr_2_char);
+
+        /* integer */
+        free (item->test_ptr_3_int);
+        free (item->test_ptr_1_int_fixed_size);
+
+        /* long */
+        free (item->test_ptr_2_long);
+
+        /* string */
+        free (item->test_string);
+        free (item->test_string2);
+        free (item->test_string3);
+        string_shared_free (item->test_shared_string);
+        hashtable_free (item->test_hashtable);
+        string_free_split (item->test_ptr_words);
+        string_free_split (item->test_ptr_words_dyn);
+        string_free_split_shared (item->test_ptr_words_dyn_shared);
+
+        /* pointer */
+        free (item->test_ptr_3_pointer);
+
+        /* time */
+        free (item->test_ptr_2_time);
+
+        /* hashtable */
+        hashtable_free (item->test_array_2_hashtable_fixed_size[0]);
+        hashtable_free (item->test_array_2_hashtable_fixed_size[1]);
+        hashtable_free (item->test_ptr_2_hashtable[0]);
+        hashtable_free (item->test_ptr_2_hashtable[1]);
+        free (item->test_ptr_2_hashtable);
+        hashtable_free (item->test_ptr_1_hashtable_dyn[0]);
+        free (item->test_ptr_1_hashtable_dyn);
+
+        free (item);
+    }
+
+    void teardown ()
+    {
+        free_item (ptr_item1);
+        free_item (ptr_item2);
+
+        ptr_item1 = NULL;
+        ptr_item2 = NULL;
+
+        items = NULL;
+        last_item = NULL;
+
+        hashtable_remove (weechat_hdata, "test_item");
+    }
+};
+
 /*
  * Tests functions:
  *   hdata_get_var_offset
+ */
+
+TEST(CoreHdataWithList, GetVarOffset)
+{
+    LONGS_EQUAL(-1, hdata_get_var_offset (NULL, NULL));
+    LONGS_EQUAL(-1, hdata_get_var_offset (ptr_hdata, NULL));
+    LONGS_EQUAL(-1, hdata_get_var_offset (NULL, "test_char"));
+    LONGS_EQUAL(-1, hdata_get_var_offset (ptr_hdata, "zzz"));
+
+    LONGS_EQUAL(offsetof (struct t_test_item, test_char),
+                hdata_get_var_offset (ptr_hdata, "test_char"));
+    LONGS_EQUAL(offsetof (struct t_test_item, test_int),
+                hdata_get_var_offset (ptr_hdata, "test_int"));
+    LONGS_EQUAL(offsetof (struct t_test_item, test_string),
+                hdata_get_var_offset (ptr_hdata, "test_string"));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_var_type
+ */
+
+TEST(CoreHdataWithList, GetVarType)
+{
+    LONGS_EQUAL(-1, hdata_get_var_type (NULL, NULL));
+    LONGS_EQUAL(-1, hdata_get_var_type (ptr_hdata, NULL));
+    LONGS_EQUAL(-1, hdata_get_var_type (NULL, "test_char"));
+    LONGS_EQUAL(-1, hdata_get_var_type (ptr_hdata, "zzz"));
+
+    LONGS_EQUAL(WEECHAT_HDATA_CHAR,
+                hdata_get_var_type (ptr_hdata, "test_char"));
+    LONGS_EQUAL(WEECHAT_HDATA_INTEGER,
+                hdata_get_var_type (ptr_hdata, "test_int"));
+    LONGS_EQUAL(WEECHAT_HDATA_LONG,
+                hdata_get_var_type (ptr_hdata, "test_long"));
+    LONGS_EQUAL(WEECHAT_HDATA_STRING,
+                hdata_get_var_type (ptr_hdata, "test_string"));
+    LONGS_EQUAL(WEECHAT_HDATA_SHARED_STRING,
+                hdata_get_var_type (ptr_hdata, "test_shared_string"));
+    LONGS_EQUAL(WEECHAT_HDATA_POINTER,
+                hdata_get_var_type (ptr_hdata, "test_pointer"));
+    LONGS_EQUAL(WEECHAT_HDATA_TIME,
+                hdata_get_var_type (ptr_hdata, "test_time"));
+    LONGS_EQUAL(WEECHAT_HDATA_HASHTABLE,
+                hdata_get_var_type (ptr_hdata, "test_hashtable"));
+    LONGS_EQUAL(WEECHAT_HDATA_OTHER,
+                hdata_get_var_type (ptr_hdata, "test_other"));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_var_type_string
+ */
+
+TEST(CoreHdataWithList, GetVarTypeString)
+{
+    POINTERS_EQUAL(NULL, hdata_get_var_type_string (NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var_type_string (ptr_hdata, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var_type_string (NULL, "test_char"));
+    POINTERS_EQUAL(NULL, hdata_get_var_type_string (ptr_hdata, "zzz"));
+
+    STRCMP_EQUAL("char",
+                 hdata_get_var_type_string (ptr_hdata, "test_char"));
+    STRCMP_EQUAL("integer",
+                 hdata_get_var_type_string (ptr_hdata, "test_int"));
+    STRCMP_EQUAL("long",
+                 hdata_get_var_type_string (ptr_hdata, "test_long"));
+    STRCMP_EQUAL("string",
+                 hdata_get_var_type_string (ptr_hdata, "test_string"));
+    STRCMP_EQUAL("shared_string",
+                 hdata_get_var_type_string (ptr_hdata, "test_shared_string"));
+    STRCMP_EQUAL("pointer",
+                 hdata_get_var_type_string (ptr_hdata, "test_pointer"));
+    STRCMP_EQUAL("time",
+                 hdata_get_var_type_string (ptr_hdata, "test_time"));
+    STRCMP_EQUAL("hashtable",
+                 hdata_get_var_type_string (ptr_hdata, "test_hashtable"));
+    STRCMP_EQUAL("other",
+                 hdata_get_var_type_string (ptr_hdata, "test_other"));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_var_array_size
+ */
+
+TEST(CoreHdataWithList, GetVarArraySize)
+{
+    LONGS_EQUAL(-1, hdata_get_var_array_size (NULL, NULL, NULL));
+    LONGS_EQUAL(-1, hdata_get_var_array_size (ptr_hdata, NULL, NULL));
+    LONGS_EQUAL(-1, hdata_get_var_array_size (NULL, NULL, "test_char"));
+    LONGS_EQUAL(-1, hdata_get_var_array_size (ptr_hdata, NULL, "zzz"));
+    LONGS_EQUAL(-1, hdata_get_var_array_size (ptr_hdata, ptr_item1, "zzz"));
+
+    /* not an array */
+    LONGS_EQUAL(-1, hdata_get_var_array_size (ptr_hdata, ptr_item1, "test_char"));
+
+    /* item 1 */
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_array_2_char_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_2_char"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_array_2_int_fixed_size"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_3_int"));
+    LONGS_EQUAL(1, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_1_int_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_array_2_long_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_2_long"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_array_2_words_fixed_size"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_words"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_words_dyn"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_words_dyn_shared"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_array_2_pointer_fixed_size"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_3_pointer"));
+    LONGS_EQUAL(0, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_0_pointer_dyn"));
+    LONGS_EQUAL(1, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_1_pointer_dyn"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_array_2_time_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_2_time"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_array_2_hashtable_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_2_hashtable"));
+    LONGS_EQUAL(1, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_1_hashtable_dyn"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                             "test_ptr_3_other"));
+    LONGS_EQUAL(-1, hdata_get_var_array_size (ptr_hdata, ptr_item1,
+                                              "test_ptr_invalid"));
+
+    /* item 2 */
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_array_2_char_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_2_char"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_array_2_int_fixed_size"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_3_int"));
+    LONGS_EQUAL(1, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_1_int_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_array_2_long_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_2_long"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_array_2_words_fixed_size"));
+    LONGS_EQUAL(4, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_words"));
+    LONGS_EQUAL(4, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_words_dyn"));
+    LONGS_EQUAL(4, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_words_dyn_shared"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_array_2_pointer_fixed_size"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_3_pointer"));
+    LONGS_EQUAL(0, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_0_pointer_dyn"));
+    LONGS_EQUAL(1, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_1_pointer_dyn"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_array_2_time_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_2_time"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_array_2_hashtable_fixed_size"));
+    LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_2_hashtable"));
+    LONGS_EQUAL(1, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_1_hashtable_dyn"));
+    LONGS_EQUAL(3, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                             "test_ptr_3_other"));
+    LONGS_EQUAL(-1, hdata_get_var_array_size (ptr_hdata, ptr_item2,
+                                              "test_ptr_invalid"));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_var_array_size_string
+ */
+
+TEST(CoreHdataWithList, GetVarArraySizeString)
+{
+    POINTERS_EQUAL(NULL, hdata_get_var_array_size_string (NULL, NULL,
+                                                          NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var_array_size_string (ptr_hdata, NULL,
+                                                          NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var_array_size_string (NULL, NULL,
+                                                          "test_char"));
+    POINTERS_EQUAL(NULL, hdata_get_var_array_size_string (ptr_hdata, NULL,
+                                                          "zzz"));
+    POINTERS_EQUAL(NULL, hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                          "zzz"));
+
+    /* not an array */
+    POINTERS_EQUAL(NULL, hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                          "test_char"));
+
+    /* item 1 */
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_array_2_char_fixed_size"));
+    STRCMP_EQUAL("test_count_char",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_2_char"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_array_2_int_fixed_size"));
+    STRCMP_EQUAL("test_count_int",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_3_int"));
+    STRCMP_EQUAL("1",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_1_int_fixed_size"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_array_2_long_fixed_size"));
+    STRCMP_EQUAL("test_count_long",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_2_long"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_array_2_words_fixed_size"));
+    STRCMP_EQUAL("test_count_words",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_words"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                       "test_ptr_words_dyn"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                       "test_ptr_words_dyn_shared"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_array_2_pointer_fixed_size"));
+    STRCMP_EQUAL("test_count_pointer",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_3_pointer"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                       "test_ptr_0_pointer_dyn"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                       "test_ptr_1_pointer_dyn"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_array_2_time_fixed_size"));
+    STRCMP_EQUAL("test_count_time",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_2_time"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_array_2_hashtable_fixed_size"));
+    STRCMP_EQUAL("test_count_hashtable",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_2_hashtable"));
+    STRCMP_EQUAL("*",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_1_hashtable_dyn"));
+    STRCMP_EQUAL("test_count_other",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_3_other"));
+    STRCMP_EQUAL("test_count_invalid",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
+                                                  "test_ptr_invalid"));
+
+    /* item 2 */
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_array_2_char_fixed_size"));
+    STRCMP_EQUAL("test_count_char",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_2_char"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_array_2_int_fixed_size"));
+    STRCMP_EQUAL("test_count_int",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_3_int"));
+    STRCMP_EQUAL("1",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_1_int_fixed_size"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_array_2_long_fixed_size"));
+    STRCMP_EQUAL("test_count_long",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_2_long"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_array_2_words_fixed_size"));
+    STRCMP_EQUAL("test_count_words",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_words"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                       "test_ptr_words_dyn"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                       "test_ptr_words_dyn_shared"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_array_2_pointer_fixed_size"));
+    STRCMP_EQUAL("test_count_pointer",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_3_pointer"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                       "test_ptr_0_pointer_dyn"));
+    STRCMP_EQUAL("*", hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                       "test_ptr_1_pointer_dyn"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_array_2_time_fixed_size"));
+    STRCMP_EQUAL("test_count_time",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_2_time"));
+    STRCMP_EQUAL("2",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_array_2_hashtable_fixed_size"));
+    STRCMP_EQUAL("test_count_hashtable",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_2_hashtable"));
+    STRCMP_EQUAL("*",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_1_hashtable_dyn"));
+    STRCMP_EQUAL("test_count_other",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_3_other"));
+    STRCMP_EQUAL("test_count_invalid",
+                 hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
+                                                  "test_ptr_invalid"));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_var_hdata
+ */
+
+TEST(CoreHdataWithList, GetVarHdata)
+{
+    POINTERS_EQUAL(NULL, hdata_get_var_hdata (NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var_hdata (ptr_hdata, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var_hdata (NULL, "test_char"));
+    POINTERS_EQUAL(NULL, hdata_get_var_hdata (ptr_hdata, "zzz"));
+
+    /* no reference to hdata */
+    POINTERS_EQUAL(NULL, hdata_get_var_hdata (ptr_hdata, "test_char"));
+
+    /* check prev/next item variables */
+    STRCMP_EQUAL("test_item", hdata_get_var_hdata (ptr_hdata, "prev_item"));
+    STRCMP_EQUAL("test_item", hdata_get_var_hdata (ptr_hdata, "next_item"));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_var
+ */
+
+TEST(CoreHdataWithList, GetVar)
+{
+    POINTERS_EQUAL(NULL, hdata_get_var (NULL, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var (ptr_hdata, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var (NULL, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var (NULL, NULL, "test_char"));
+    POINTERS_EQUAL(NULL, hdata_get_var (ptr_hdata, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_var (NULL, ptr_item1, "test_char"));
+    POINTERS_EQUAL(NULL, hdata_get_var (ptr_hdata, NULL, "test_char"));
+    POINTERS_EQUAL(NULL, hdata_get_var (ptr_hdata, ptr_item1, "zzz"));
+
+    /* item 1 */
+    POINTERS_EQUAL(&(ptr_item1->test_char),
+                   hdata_get_var (ptr_hdata, ptr_item1, "test_char"));
+    POINTERS_EQUAL(&(ptr_item1->test_int),
+                   hdata_get_var (ptr_hdata, ptr_item1, "test_int"));
+    POINTERS_EQUAL(&(ptr_item1->test_string),
+                   hdata_get_var (ptr_hdata, ptr_item1, "test_string"));
+
+    /* item 2 */
+    POINTERS_EQUAL(&(ptr_item2->test_char),
+                   hdata_get_var (ptr_hdata, ptr_item2, "test_char"));
+    POINTERS_EQUAL(&(ptr_item2->test_int),
+                   hdata_get_var (ptr_hdata, ptr_item2, "test_int"));
+    POINTERS_EQUAL(&(ptr_item2->test_string),
+                   hdata_get_var (ptr_hdata, ptr_item2, "test_string"));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_var_at_offset
+ */
+
+TEST(CoreHdataWithList, GetVarAtOffset)
+{
+    POINTERS_EQUAL(NULL, hdata_get_var_at_offset (NULL, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_get_var_at_offset (ptr_hdata, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_get_var_at_offset (NULL, ptr_item1, 0));
+
+    /* item 1 */
+    POINTERS_EQUAL(&(ptr_item1->test_char),
+                   hdata_get_var_at_offset (
+                       ptr_hdata,
+                       ptr_item1,
+                       offsetof (struct t_test_item, test_char)));
+    POINTERS_EQUAL(&(ptr_item1->test_int),
+                   hdata_get_var_at_offset (
+                       ptr_hdata,
+                       ptr_item1,
+                       offsetof (struct t_test_item, test_int)));
+    POINTERS_EQUAL(&(ptr_item1->test_string),
+                   hdata_get_var_at_offset (
+                       ptr_hdata,
+                       ptr_item1,
+                       offsetof (struct t_test_item, test_string)));
+
+    /* item 2 */
+    POINTERS_EQUAL(&(ptr_item2->test_char),
+                   hdata_get_var_at_offset (
+                       ptr_hdata,
+                       ptr_item2,
+                       offsetof (struct t_test_item, test_char)));
+    POINTERS_EQUAL(&(ptr_item2->test_int),
+                   hdata_get_var_at_offset (
+                       ptr_hdata,
+                       ptr_item2,
+                       offsetof (struct t_test_item, test_int)));
+    POINTERS_EQUAL(&(ptr_item2->test_string),
+                   hdata_get_var_at_offset (
+                       ptr_hdata,
+                       ptr_item2,
+                       offsetof (struct t_test_item, test_string)));
+}
+
+/*
+ * Tests functions:
  *   hdata_get_list
  */
 
-TEST(CoreHdata, Get)
+TEST(CoreHdataWithList, GetList)
 {
-    /* TODO: write tests */
+    POINTERS_EQUAL(NULL, hdata_get_list (NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_list (ptr_hdata, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_list (NULL, "items"));
+    POINTERS_EQUAL(NULL, hdata_get_list (ptr_hdata, "zzz"));
+
+    POINTERS_EQUAL(ptr_item1, hdata_get_list (ptr_hdata, "items"));
+    POINTERS_EQUAL(ptr_item2, hdata_get_list (ptr_hdata, "last_item"));
 }
 
 /*
@@ -65,44 +1246,997 @@ TEST(CoreHdata, Get)
  *   hdata_check_pointer
  */
 
-TEST(CoreHdata, Check)
+TEST(CoreHdataWithList, Check)
 {
-    /* TODO: write tests */
+    LONGS_EQUAL(0, hdata_check_pointer (NULL, NULL, NULL));
+    LONGS_EQUAL(0, hdata_check_pointer (ptr_hdata, NULL, NULL));
+    LONGS_EQUAL(0, hdata_check_pointer (NULL, NULL, ptr_item1));
+
+    /* pointer not found */
+    LONGS_EQUAL(0, hdata_check_pointer (ptr_hdata, NULL, (void *)0x1));
+    LONGS_EQUAL(0, hdata_check_pointer (ptr_hdata, items, (void *)0x1));
+
+    /* valid pointer */
+    LONGS_EQUAL(1, hdata_check_pointer (ptr_hdata, NULL, ptr_item1));
+    LONGS_EQUAL(1, hdata_check_pointer (ptr_hdata, NULL, ptr_item2));
+    LONGS_EQUAL(1, hdata_check_pointer (ptr_hdata, items, ptr_item1));
+    LONGS_EQUAL(1, hdata_check_pointer (ptr_hdata, items, ptr_item2));
 }
 
 /*
  * Tests functions:
  *   hdata_move
+ */
+
+TEST(CoreHdataWithList, Move)
+{
+    POINTERS_EQUAL(NULL, hdata_move (NULL, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_move (NULL, ptr_item1, 0));
+    POINTERS_EQUAL(NULL, hdata_move (NULL, NULL, 1));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, ptr_item1, 0));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, NULL, 1));
+    POINTERS_EQUAL(NULL, hdata_move (NULL, ptr_item1, 1));
+
+    /* move from item1 */
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, ptr_item1, -1));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, ptr_item1, -42));
+    POINTERS_EQUAL(ptr_item2, hdata_move (ptr_hdata, ptr_item1, 1));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, ptr_item1, 42));
+
+    /* move from item2 */
+    POINTERS_EQUAL(ptr_item1, hdata_move (ptr_hdata, ptr_item2, -1));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, ptr_item2, -42));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, ptr_item2, 1));
+    POINTERS_EQUAL(NULL, hdata_move (ptr_hdata, ptr_item2, 42));
+}
+
+/*
+ * Tests functions:
  *   hdata_search
  */
 
-TEST(CoreHdata, Move)
+TEST(CoreHdataWithList, Search)
 {
-    /* TODO: write tests */
+    POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_search (NULL, items, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, "${test_char} == A", 0));
+    POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, NULL, 1));
+    POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, items, NULL, 0));
+    POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, "${test_char} == A", 0));
+    POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, NULL, 1));
+    POINTERS_EQUAL(NULL, hdata_search (NULL, items, "${test_char} == A", 0));
+    POINTERS_EQUAL(NULL, hdata_search (NULL, items, NULL, 1));
+    POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, "${test_char} == A", 1));
+    POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, items, "${test_char} == A", 0));
+    POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, items, NULL, 1));
+    POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, "${test_char} == A", 1));
+    POINTERS_EQUAL(NULL, hdata_search (NULL, items, "${test_char} == A", 1));
+
+    /* search char */
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_char} == Z", 1));
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_char} == X", 2));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_char} == A", 1));
+    POINTERS_EQUAL(ptr_item2,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_char} == a", 1));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, last_item,
+                                 "${test_item.test_char} == A", -1));
+
+    /* search integer */
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_int} == 999", 1));
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_int} == 456", 2));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_int} == 123", 1));
+    POINTERS_EQUAL(ptr_item2,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_int} == 456", 1));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, last_item,
+                                 "${test_item.test_int} == 123", -1));
+
+    /* search long */
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_long} == 999", 1));
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_long} == 987654321", 2));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_long} == 123456789", 1));
+    POINTERS_EQUAL(ptr_item2,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_long} == 987654321", 1));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, last_item,
+                                 "${test_item.test_long} == 123456789", -1));
+
+    /* search string */
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_string} == zzz", 1));
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_string} == item2", 2));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_string} == item1", 1));
+    POINTERS_EQUAL(ptr_item2,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_string} == item2", 1));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, last_item,
+                                 "${test_item.test_string} == item1", -1));
+
+    /* search shared string */
+    POINTERS_EQUAL(
+        NULL,
+        hdata_search (ptr_hdata, items,
+                      "${test_item.test_shared_string} == zzz", 1));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_search (ptr_hdata, items,
+                      "${test_item.test_shared_string} == item2_shared", 2));
+    POINTERS_EQUAL(
+        ptr_item1,
+        hdata_search (ptr_hdata, items,
+                      "${test_item.test_shared_string} == item1_shared", 1));
+    POINTERS_EQUAL(
+        ptr_item2,
+        hdata_search (ptr_hdata, items,
+                      "${test_item.test_shared_string} == item2_shared", 1));
+    POINTERS_EQUAL(
+        ptr_item1,
+        hdata_search (ptr_hdata, last_item,
+                      "${test_item.test_shared_string} == item1_shared", -1));
+
+    /* search pointer */
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_pointer} == 0x999", 1));
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_pointer} == 0x456", 2));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_pointer} == 0x123", 1));
+    POINTERS_EQUAL(ptr_item2,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_pointer} == 0x456", 1));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, last_item,
+                                 "${test_item.test_pointer} == 0x123", -1));
+
+    /* search time */
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_time} == 999", 1));
+    POINTERS_EQUAL(NULL,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_time} == 789123", 2));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_time} == 123456", 1));
+    POINTERS_EQUAL(ptr_item2,
+                   hdata_search (ptr_hdata, items,
+                                 "${test_item.test_time} == 789123", 1));
+    POINTERS_EQUAL(ptr_item1,
+                   hdata_search (ptr_hdata, last_item,
+                                 "${test_item.test_time} == 123456", -1));
+}
+
+/*
+ * Tests functions:
+ *   hdata_get_index_and_name
+ */
+
+TEST(CoreHdataWithList, GetIndexAndName)
+{
+    int index;
+    const char *ptr_name;
+
+    hdata_get_index_and_name (NULL, NULL, NULL);
+    hdata_get_index_and_name ("test", NULL, NULL);
+    hdata_get_index_and_name ("123|test", NULL, NULL);
+
+    index = -999;
+    ptr_name = (const char *)0x1;
+    hdata_get_index_and_name (NULL, &index, &ptr_name);
+    LONGS_EQUAL(-1, index);
+    POINTERS_EQUAL(NULL, ptr_name);
+
+    index = -999;
+    ptr_name = (const char *)0x1;
+    hdata_get_index_and_name ("test", &index, &ptr_name);
+    LONGS_EQUAL(-1, index);
+    STRCMP_EQUAL("test", ptr_name);
+
+    index = -999;
+    ptr_name = (const char *)0x1;
+    hdata_get_index_and_name ("abc|test", &index, &ptr_name);
+    LONGS_EQUAL(-1, index);
+    STRCMP_EQUAL("abc|test", ptr_name);
+
+    index = -999;
+    ptr_name = (const char *)0x1;
+    hdata_get_index_and_name ("123|test", &index, &ptr_name);
+    LONGS_EQUAL(123, index);
+    STRCMP_EQUAL("test", ptr_name);
+
+    index = -999;
+    ptr_name = (const char *)0x1;
+    hdata_get_index_and_name ("123|", &index, &ptr_name);
+    LONGS_EQUAL(123, index);
+    STRCMP_EQUAL("", ptr_name);
 }
 
 /*
  * Tests functions:
  *   hdata_char
+ */
+
+TEST(CoreHdataWithList, Char)
+{
+    LONGS_EQUAL('\0', hdata_char (NULL, NULL, NULL));
+    LONGS_EQUAL('\0', hdata_char (ptr_hdata, NULL, NULL));
+    LONGS_EQUAL('\0', hdata_char (NULL, ptr_item1, NULL));
+    LONGS_EQUAL('\0', hdata_char (NULL, NULL, "test_char"));
+    LONGS_EQUAL('\0', hdata_char (ptr_hdata, ptr_item1, NULL));
+    LONGS_EQUAL('\0', hdata_char (ptr_hdata, NULL, "test_char"));
+    LONGS_EQUAL('\0', hdata_char (NULL, ptr_item1, "test_char"));
+
+    /* variable not found */
+    LONGS_EQUAL('\0', hdata_char (ptr_hdata, ptr_item1, "zzz"));
+    LONGS_EQUAL('\0', hdata_char (ptr_hdata, ptr_item1, "1|zzz"));
+
+    /* item 1 */
+    LONGS_EQUAL('A', hdata_char (ptr_hdata, ptr_item1, "test_char"));
+    LONGS_EQUAL('A', hdata_char (ptr_hdata, ptr_item1,
+                                 "0|test_array_2_char_fixed_size"));
+    LONGS_EQUAL('B', hdata_char (ptr_hdata, ptr_item1,
+                                 "1|test_array_2_char_fixed_size"));
+    LONGS_EQUAL('B', hdata_char (ptr_hdata, ptr_item1, "0|test_ptr_2_char"));
+    LONGS_EQUAL('C', hdata_char (ptr_hdata, ptr_item1, "1|test_ptr_2_char"));
+
+    /* item 2 */
+    LONGS_EQUAL('a', hdata_char (ptr_hdata, ptr_item2, "test_char"));
+    LONGS_EQUAL('b', hdata_char (ptr_hdata, ptr_item2, "0|test_ptr_2_char"));
+    LONGS_EQUAL('c', hdata_char (ptr_hdata, ptr_item2, "1|test_ptr_2_char"));
+}
+
+/*
+ * Tests functions:
  *   hdata_integer
+ */
+
+TEST(CoreHdataWithList, Integer)
+{
+    LONGS_EQUAL(0, hdata_integer (NULL, NULL, NULL));
+    LONGS_EQUAL(0, hdata_integer (ptr_hdata, NULL, NULL));
+    LONGS_EQUAL(0, hdata_integer (NULL, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_integer (NULL, NULL, "test_int"));
+    LONGS_EQUAL(0, hdata_integer (ptr_hdata, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_integer (ptr_hdata, NULL, "test_int"));
+    LONGS_EQUAL(0, hdata_integer (NULL, ptr_item1, "test_int"));
+
+    /* variable not found */
+    LONGS_EQUAL(0, hdata_integer (ptr_hdata, ptr_item1, "zzz"));
+    LONGS_EQUAL(0, hdata_integer (ptr_hdata, ptr_item1, "1|zzz"));
+
+    /* item 1 */
+    LONGS_EQUAL(123, hdata_integer (ptr_hdata, ptr_item1, "test_int"));
+    LONGS_EQUAL(111, hdata_integer (ptr_hdata, ptr_item1,
+                                    "0|test_array_2_int_fixed_size"));
+    LONGS_EQUAL(222, hdata_integer (ptr_hdata, ptr_item1,
+                                    "1|test_array_2_int_fixed_size"));
+    LONGS_EQUAL(1, hdata_integer (ptr_hdata, ptr_item1, "0|test_ptr_3_int"));
+    LONGS_EQUAL(2, hdata_integer (ptr_hdata, ptr_item1, "1|test_ptr_3_int"));
+    LONGS_EQUAL(3, hdata_integer (ptr_hdata, ptr_item1, "2|test_ptr_3_int"));
+    LONGS_EQUAL(111, hdata_integer (ptr_hdata, ptr_item1,
+                                    "0|test_ptr_1_int_fixed_size"));
+
+    /* item 2 */
+    LONGS_EQUAL(456, hdata_integer (ptr_hdata, ptr_item2, "test_int"));
+    LONGS_EQUAL(444, hdata_integer (ptr_hdata, ptr_item2,
+                                    "0|test_array_2_int_fixed_size"));
+    LONGS_EQUAL(555, hdata_integer (ptr_hdata, ptr_item2,
+                                    "1|test_array_2_int_fixed_size"));
+    LONGS_EQUAL(4, hdata_integer (ptr_hdata, ptr_item2, "0|test_ptr_3_int"));
+    LONGS_EQUAL(5, hdata_integer (ptr_hdata, ptr_item2, "1|test_ptr_3_int"));
+    LONGS_EQUAL(6, hdata_integer (ptr_hdata, ptr_item2, "2|test_ptr_3_int"));
+    LONGS_EQUAL(222, hdata_integer (ptr_hdata, ptr_item2,
+                                    "0|test_ptr_1_int_fixed_size"));
+}
+
+/*
+ * Tests functions:
  *   hdata_long
+ */
+
+TEST(CoreHdataWithList, Long)
+{
+    LONGS_EQUAL(0, hdata_long (NULL, NULL, NULL));
+    LONGS_EQUAL(0, hdata_long (ptr_hdata, NULL, NULL));
+    LONGS_EQUAL(0, hdata_long (NULL, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_long (NULL, NULL, "test_long"));
+    LONGS_EQUAL(0, hdata_long (ptr_hdata, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_long (ptr_hdata, NULL, "test_long"));
+    LONGS_EQUAL(0, hdata_long (NULL, ptr_item1, "test_long"));
+
+    /* variable not found */
+    LONGS_EQUAL(0, hdata_long (ptr_hdata, ptr_item1, "zzz"));
+    LONGS_EQUAL(0, hdata_long (ptr_hdata, ptr_item1, "1|zzz"));
+
+    /* item 1 */
+    LONGS_EQUAL(123456789L, hdata_long (ptr_hdata, ptr_item1, "test_long"));
+    LONGS_EQUAL(111L, hdata_long (ptr_hdata, ptr_item1,
+                                  "0|test_array_2_long_fixed_size"));
+    LONGS_EQUAL(222L, hdata_long (ptr_hdata, ptr_item1,
+                                  "1|test_array_2_long_fixed_size"));
+    LONGS_EQUAL(123456L, hdata_long (ptr_hdata, ptr_item1,
+                                     "0|test_ptr_2_long"));
+    LONGS_EQUAL(234567L, hdata_long (ptr_hdata, ptr_item1,
+                                     "1|test_ptr_2_long"));
+
+    /* item 2 */
+    LONGS_EQUAL(987654321L, hdata_long (ptr_hdata, ptr_item2, "test_long"));
+    LONGS_EQUAL(333L, hdata_long (ptr_hdata, ptr_item2,
+                                  "0|test_array_2_long_fixed_size"));
+    LONGS_EQUAL(444L, hdata_long (ptr_hdata, ptr_item2,
+                                  "1|test_array_2_long_fixed_size"));
+    LONGS_EQUAL(789123L, hdata_long (ptr_hdata, ptr_item2,
+                                     "0|test_ptr_2_long"));
+    LONGS_EQUAL(891234L, hdata_long (ptr_hdata, ptr_item2,
+                                     "1|test_ptr_2_long"));
+}
+
+/*
+ * Tests functions:
  *   hdata_string
+ */
+
+TEST(CoreHdataWithList, String)
+{
+    POINTERS_EQUAL(NULL, hdata_string (NULL, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_string (ptr_hdata, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_string (NULL, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_string (NULL, NULL, "test_string"));
+    POINTERS_EQUAL(NULL, hdata_string (ptr_hdata, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_string (ptr_hdata, NULL, "test_string"));
+    POINTERS_EQUAL(NULL, hdata_string (NULL, ptr_item1, "test_string"));
+
+    /* variable not found */
+    POINTERS_EQUAL(NULL, hdata_string (ptr_hdata, ptr_item1, "zzz"));
+    POINTERS_EQUAL(NULL, hdata_string (ptr_hdata, ptr_item1, "1|zzz"));
+
+    /* item 1 */
+    STRCMP_EQUAL("item1", hdata_string (ptr_hdata, ptr_item1, "test_string"));
+    STRCMP_EQUAL("item1_shared", hdata_string (ptr_hdata, ptr_item1,
+                                               "test_shared_string"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item1, "0|test_array_2_words_fixed_size"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item1, "1|test_array_2_words_fixed_size"));
+    STRCMP_EQUAL(
+        "a",
+        hdata_string (ptr_hdata, ptr_item1, "0|test_ptr_words"));
+    STRCMP_EQUAL(
+        "b",
+        hdata_string (ptr_hdata, ptr_item1, "1|test_ptr_words"));
+    STRCMP_EQUAL(
+        "c",
+        hdata_string (ptr_hdata, ptr_item1, "2|test_ptr_words"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item1, "3|test_ptr_words"));
+    STRCMP_EQUAL(
+        "aa",
+        hdata_string (ptr_hdata, ptr_item1, "0|test_ptr_words_dyn"));
+    STRCMP_EQUAL(
+        "bb",
+        hdata_string (ptr_hdata, ptr_item1, "1|test_ptr_words_dyn"));
+    STRCMP_EQUAL(
+        "cc",
+        hdata_string (ptr_hdata, ptr_item1, "2|test_ptr_words_dyn"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item1, "3|test_ptr_words_dyn"));
+    STRCMP_EQUAL(
+        "aaa",
+        hdata_string (ptr_hdata, ptr_item1, "0|test_ptr_words_dyn_shared"));
+    STRCMP_EQUAL(
+        "bbb",
+        hdata_string (ptr_hdata, ptr_item1, "1|test_ptr_words_dyn_shared"));
+    STRCMP_EQUAL(
+        "ccc",
+        hdata_string (ptr_hdata, ptr_item1, "2|test_ptr_words_dyn_shared"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item1, "3|test_ptr_words_dyn_shared"));
+
+    /* item 2 */
+    STRCMP_EQUAL("item2", hdata_string (ptr_hdata, ptr_item2, "test_string"));
+    STRCMP_EQUAL("item2_shared", hdata_string (ptr_hdata, ptr_item2,
+                                               "test_shared_string"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item2, "0|test_array_2_words_fixed_size"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item2, "1|test_array_2_words_fixed_size"));
+    STRCMP_EQUAL(
+        "e",
+        hdata_string (ptr_hdata, ptr_item2, "0|test_ptr_words"));
+    STRCMP_EQUAL(
+        "f",
+        hdata_string (ptr_hdata, ptr_item2, "1|test_ptr_words"));
+    STRCMP_EQUAL(
+        "g",
+        hdata_string (ptr_hdata, ptr_item2, "2|test_ptr_words"));
+    STRCMP_EQUAL(
+        "h",
+        hdata_string (ptr_hdata, ptr_item2, "3|test_ptr_words"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item2, "4|test_ptr_words"));
+    STRCMP_EQUAL(
+        "ee",
+        hdata_string (ptr_hdata, ptr_item2, "0|test_ptr_words_dyn"));
+    STRCMP_EQUAL(
+        "ff",
+        hdata_string (ptr_hdata, ptr_item2, "1|test_ptr_words_dyn"));
+    STRCMP_EQUAL(
+        "gg",
+        hdata_string (ptr_hdata, ptr_item2, "2|test_ptr_words_dyn"));
+    STRCMP_EQUAL(
+        "hh",
+        hdata_string (ptr_hdata, ptr_item2, "3|test_ptr_words_dyn"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item2, "4|test_ptr_words_dyn"));
+    STRCMP_EQUAL(
+        "eee",
+        hdata_string (ptr_hdata, ptr_item2, "0|test_ptr_words_dyn_shared"));
+    STRCMP_EQUAL(
+        "fff",
+        hdata_string (ptr_hdata, ptr_item2, "1|test_ptr_words_dyn_shared"));
+    STRCMP_EQUAL(
+        "ggg",
+        hdata_string (ptr_hdata, ptr_item2, "2|test_ptr_words_dyn_shared"));
+    STRCMP_EQUAL(
+        "hhh",
+        hdata_string (ptr_hdata, ptr_item2, "3|test_ptr_words_dyn_shared"));
+    POINTERS_EQUAL(
+        NULL,
+        hdata_string (ptr_hdata, ptr_item2, "4|test_ptr_words_dyn_shared"));
+}
+
+/*
+ * Tests functions:
  *   hdata_pointer
+ */
+
+TEST(CoreHdataWithList, Pointer)
+{
+    POINTERS_EQUAL(NULL, hdata_pointer (NULL, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_pointer (ptr_hdata, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_pointer (NULL, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_pointer (NULL, NULL, "test_pointer"));
+    POINTERS_EQUAL(NULL, hdata_pointer (ptr_hdata, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_pointer (ptr_hdata, NULL, "test_pointer"));
+    POINTERS_EQUAL(NULL, hdata_pointer (NULL, ptr_item1, "test_pointer"));
+
+    /* variable not found */
+    POINTERS_EQUAL(NULL, hdata_pointer (ptr_hdata, ptr_item1, "zzz"));
+    POINTERS_EQUAL(NULL, hdata_pointer (ptr_hdata, ptr_item1, "1|zzz"));
+
+    /* item 1 */
+    LONGS_EQUAL(0x123, hdata_pointer (ptr_hdata, ptr_item1, "test_pointer"));
+    LONGS_EQUAL(
+        0x112233,
+        hdata_pointer (ptr_hdata, ptr_item1, "0|test_array_2_pointer_fixed_size"));
+    LONGS_EQUAL(
+        0x445566,
+        hdata_pointer (ptr_hdata, ptr_item1, "1|test_array_2_pointer_fixed_size"));
+    LONGS_EQUAL(
+        0x123,
+        hdata_pointer (ptr_hdata, ptr_item1, "0|test_ptr_3_pointer"));
+    LONGS_EQUAL(
+        0x456,
+        hdata_pointer (ptr_hdata, ptr_item1, "1|test_ptr_3_pointer"));
+    LONGS_EQUAL(
+        0x789,
+        hdata_pointer (ptr_hdata, ptr_item1, "2|test_ptr_3_pointer"));
+
+    /* item 2 */
+    LONGS_EQUAL(0x456, hdata_pointer (ptr_hdata, ptr_item2, "test_pointer"));
+    LONGS_EQUAL(
+        0x778899,
+        hdata_pointer (ptr_hdata, ptr_item2, "0|test_array_2_pointer_fixed_size"));
+    LONGS_EQUAL(
+        0xaabbcc,
+        hdata_pointer (ptr_hdata, ptr_item2, "1|test_array_2_pointer_fixed_size"));
+    LONGS_EQUAL(
+        0x123abc,
+        hdata_pointer (ptr_hdata, ptr_item2, "0|test_ptr_3_pointer"));
+    LONGS_EQUAL(
+        0x456def,
+        hdata_pointer (ptr_hdata, ptr_item2, "1|test_ptr_3_pointer"));
+    LONGS_EQUAL(
+        0x789abc,
+        hdata_pointer (ptr_hdata, ptr_item2, "2|test_ptr_3_pointer"));
+}
+
+/*
+ * Tests functions:
  *   hdata_time
  */
 
-TEST(CoreHdata, Read)
+TEST(CoreHdataWithList, Time)
 {
-    /* TODO: write tests */
+    LONGS_EQUAL(0, hdata_time (NULL, NULL, NULL));
+    LONGS_EQUAL(0, hdata_time (ptr_hdata, NULL, NULL));
+    LONGS_EQUAL(0, hdata_time (NULL, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_time (NULL, NULL, "test_time"));
+    LONGS_EQUAL(0, hdata_time (ptr_hdata, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_time (ptr_hdata, NULL, "test_time"));
+    LONGS_EQUAL(0, hdata_time (NULL, ptr_item1, "test_time"));
+
+    /* variable not found */
+    LONGS_EQUAL(0, hdata_time (ptr_hdata, ptr_item1, "zzz"));
+    LONGS_EQUAL(0, hdata_time (ptr_hdata, ptr_item1, "1|zzz"));
+
+    /* item 1 */
+    LONGS_EQUAL(123456, hdata_time (ptr_hdata, ptr_item1, "test_time"));
+    LONGS_EQUAL(112,
+                hdata_time (ptr_hdata, ptr_item1, "0|test_array_2_time_fixed_size"));
+    LONGS_EQUAL(334,
+                hdata_time (ptr_hdata, ptr_item1, "1|test_array_2_time_fixed_size"));
+    LONGS_EQUAL(1234,
+                hdata_time (ptr_hdata, ptr_item1, "0|test_ptr_2_time"));
+    LONGS_EQUAL(5678,
+                hdata_time (ptr_hdata, ptr_item1, "1|test_ptr_2_time"));
+
+    /* item 2 */
+    LONGS_EQUAL(789123, hdata_time (ptr_hdata, ptr_item2, "test_time"));
+    LONGS_EQUAL(556,
+                hdata_time (ptr_hdata, ptr_item2, "0|test_array_2_time_fixed_size"));
+    LONGS_EQUAL(778,
+                hdata_time (ptr_hdata, ptr_item2, "1|test_array_2_time_fixed_size"));
+    LONGS_EQUAL(123456,
+                hdata_time (ptr_hdata, ptr_item2, "0|test_ptr_2_time"));
+    LONGS_EQUAL(789123,
+                hdata_time (ptr_hdata, ptr_item2, "1|test_ptr_2_time"));
+}
+
+/*
+ * Tests functions:
+ *   hdata_hashtable
+ */
+
+TEST(CoreHdataWithList, Hashtable)
+{
+    struct t_hashtable *ptr_hashtable;
+
+    POINTERS_EQUAL(NULL, hdata_hashtable (NULL, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_hashtable (ptr_hdata, NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_hashtable (NULL, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_hashtable (NULL, NULL, "test_hashtable"));
+    POINTERS_EQUAL(NULL, hdata_hashtable (ptr_hdata, ptr_item1, NULL));
+    POINTERS_EQUAL(NULL, hdata_hashtable (ptr_hdata, NULL, "test_hashtable"));
+    POINTERS_EQUAL(NULL, hdata_hashtable (NULL, ptr_item1, "test_hashtable"));
+
+    /* variable not found */
+    POINTERS_EQUAL(NULL, hdata_hashtable (ptr_hdata, ptr_item1, "zzz"));
+    POINTERS_EQUAL(NULL, hdata_hashtable (ptr_hdata, ptr_item1, "1|zzz"));
+
+    /* item 1 */
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item1, "test_hashtable");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value1", (const char *)hashtable_get (ptr_hashtable, "key1"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item1,
+                                     "0|test_array_2_hashtable_fixed_size");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value_array_1.1",
+                 (const char *)hashtable_get (ptr_hashtable, "key_array_1.1"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item1,
+                                     "1|test_array_2_hashtable_fixed_size");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value_array_1.2",
+                 (const char *)hashtable_get (ptr_hashtable, "key_array_1.2"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item1,
+                                     "0|test_ptr_2_hashtable");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value1.1",
+                 (const char *)hashtable_get (ptr_hashtable, "key1.1"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item1,
+                                     "1|test_ptr_2_hashtable");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value1.2",
+                 (const char *)hashtable_get (ptr_hashtable, "key1.2"));
+
+    /* item 2 */
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item2, "test_hashtable");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value2", (const char *)hashtable_get (ptr_hashtable, "key2"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item2,
+                                     "0|test_array_2_hashtable_fixed_size");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value_array_2.1",
+                 (const char *)hashtable_get (ptr_hashtable, "key_array_2.1"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item2,
+                                     "1|test_array_2_hashtable_fixed_size");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value_array_2.2",
+                 (const char *)hashtable_get (ptr_hashtable, "key_array_2.2"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item2,
+                                     "0|test_ptr_2_hashtable");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value2.1",
+                 (const char *)hashtable_get (ptr_hashtable, "key2.1"));
+    ptr_hashtable = hdata_hashtable (ptr_hdata, ptr_item2,
+                                     "1|test_ptr_2_hashtable");
+    CHECK(ptr_hashtable);
+    STRCMP_EQUAL("value2.2",
+                 (const char *)hashtable_get (ptr_hashtable, "key2.2"));
+}
+
+/*
+ * Tests functions:
+ *   hdata_compare
+ */
+
+TEST(CoreHdataWithList, Compare)
+{
+    LONGS_EQUAL(0, hdata_compare (NULL, NULL, NULL, NULL, 0));
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, NULL, NULL, NULL, 0));
+
+    /* one or two pointers are missing */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, NULL, NULL, "test_char", 0));
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item1, NULL, "test_char", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, NULL, ptr_item2, "test_char", 0));
+
+    /* compare chars: 'A' and 'a' */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
+                                  "test_char", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                   "test_char", 0));
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                  "test_char", 0));
+
+    /* compare strings: "STRING2" and "string2" */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                  "test_string2", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                   "test_string2", 1));
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                  "test_string2", 1));
+
+    /* compare strings: "test" and NULL */
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                  "test_string3", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                   "test_string3", 0));
+
+    /* compare strings: NULL and NULL */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                  "test_string_null", 0));
+
+    /* compare integers: 123 and 456 */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
+                                  "test_int", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                   "test_int", 0));
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                  "test_int", 0));
+
+    /* compare long integers: 123456789L and 987654321L */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
+                                  "test_long", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                   "test_long", 0));
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                  "test_long", 0));
+
+    /* compare pointers: 0x123 and 0x456 */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
+                                  "test_pointer", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                   "test_pointer", 0));
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                  "test_pointer", 0));
+
+    /* compare times: 123456 and 789123 */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
+                                  "test_time", 0));
+    LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                   "test_time", 0));
+    LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
+                                  "test_time", 0));
+
+    /* compare hashtables: not possible */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                  "test_hashtable", 0));
+
+    /* compare "other" type: not possible */
+    LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
+                                  "test_other", 0));
+}
+
+/*
+ * Tests functions:
+ *   hdata_set
+ *   hdata_update
+ */
+
+TEST(CoreHdataWithList, Update)
+{
+    struct t_hashtable *hashtable, *ptr_old_hashtable;
+    void *ptr_old_pointer;
+
+    hashtable = hashtable_new (8,
+                               WEECHAT_HASHTABLE_STRING,
+                               WEECHAT_HASHTABLE_STRING,
+                               NULL,
+                               NULL);
+
+    LONGS_EQUAL(0, hdata_update (NULL, NULL, NULL));
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, NULL, NULL));
+    LONGS_EQUAL(0, hdata_update (NULL, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_update (NULL, NULL, hashtable));
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, NULL));
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, NULL, hashtable));
+    LONGS_EQUAL(0, hdata_update (NULL, ptr_item1, hashtable));
+
+    /* check update without update callback */
+    hdata_new (NULL, "test_item2", "prev_item", "next_item", 1, 1, NULL, NULL);
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    hashtable_remove (weechat_hdata, "test_item2");
+
+    /* check if create is allowed */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "__create_allowed", "1");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+
+    /* check if delete is allowed */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "__delete_allowed", "1");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+
+    /* check if update is allowed on a variable */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "__update_allowed", "zzz");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "__update_allowed", "test_string");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "__update_allowed", "test_string2");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+
+    /* variable not found */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "zzz", "test");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+
+    /* update not allowed on the variable */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_string2", "test");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    STRCMP_EQUAL("STRING2", ptr_item1->test_string2);
+
+    /* set empty char */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_char", "");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL('\0', ptr_item1->test_char);
+
+    /* set char to 'M' */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_char", "M");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL('M', ptr_item1->test_char);
+
+    /* set string to NULL */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_string", NULL);
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    POINTERS_EQUAL(NULL, ptr_item1->test_string);
+
+    /* set string to empty string */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_string", "");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    STRCMP_EQUAL("", ptr_item1->test_string);
+
+    /* set string to "test" */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_string", "test");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    STRCMP_EQUAL("test", ptr_item1->test_string);
+
+    /* set shared string to NULL */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_shared_string", NULL);
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    POINTERS_EQUAL(NULL, ptr_item1->test_shared_string);
+
+    /* set shared string to empty string */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_shared_string", "");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    STRCMP_EQUAL("", ptr_item1->test_shared_string);
+
+    /* set shared string to "test_shared" */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_shared_string", "test_shared");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    STRCMP_EQUAL("test_shared", ptr_item1->test_shared_string);
+
+    /* set int to invalid value */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_int", "abc");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(123, ptr_item1->test_int);
+
+    /* set int to -5 */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_int", "-5");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(-5, ptr_item1->test_int);
+
+    /* set int to 77 */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_int", "77");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(77, ptr_item1->test_int);
+
+    /* set long to invalid value */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_long", "abc");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(123456789L, ptr_item1->test_long);
+
+    /* set long to -55 */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_long", "-55");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(-55, ptr_item1->test_long);
+
+    /* set long to 777 */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_long", "777");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(777, ptr_item1->test_long);
+
+    /* set pointer to invalid value */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_pointer", "zzz");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    POINTERS_EQUAL(0x123, ptr_item1->test_pointer);
+
+    /* set pointer to NULL */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_pointer", NULL);
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    POINTERS_EQUAL(NULL, ptr_item1->test_pointer);
+
+    /* set pointer to 0x1a2b3c */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_pointer", "0x1a2b3c");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    POINTERS_EQUAL(0x1a2b3c, ptr_item1->test_pointer);
+
+    /* set time to invalid value */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_time", "-10");
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(123456, ptr_item1->test_time);
+
+    /* set time to 112233 */
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_time", "112233");
+    LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    LONGS_EQUAL(112233, ptr_item1->test_time);
+
+    /* set hashtable to NULL (not possible) */
+    ptr_old_hashtable = ptr_item1->test_hashtable;
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_hashtable", NULL);
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    POINTERS_EQUAL(ptr_old_hashtable, ptr_item1->test_hashtable);
+
+    /* set other to NULL (not possible) */
+    ptr_old_pointer = ptr_item1->test_other;
+    hashtable_remove_all (hashtable);
+    hashtable_set (hashtable, "test_other", NULL);
+    LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
+    POINTERS_EQUAL(ptr_old_pointer, ptr_item1->test_other);
+}
+
+/*
+ * Tests functions:
+ *   hdata_get_string
+ */
+
+TEST(CoreHdataWithList, GetString)
+{
+    const char *prop;
+    char **items;
+    int num_items;
+
+    POINTERS_EQUAL(NULL, hdata_get_string (NULL, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_string (ptr_hdata, NULL));
+    POINTERS_EQUAL(NULL, hdata_get_string (NULL, "var_keys"));
+
+    POINTERS_EQUAL(NULL, hdata_get_string (ptr_hdata, "zzz"));
+
+    STRCMP_EQUAL(
+        "test_char,test_count_char,test_array_2_char_fixed_size,"
+        "test_ptr_2_char,test_int,test_count_int,test_array_2_int_fixed_size,"
+        "test_ptr_3_int,test_ptr_1_int_fixed_size,test_long,test_count_long,"
+        "test_array_2_long_fixed_size,test_ptr_2_long,test_string,"
+        "test_string2,test_string3,test_string_null,test_shared_string,"
+        "test_count_words,test_array_2_words_fixed_size,test_ptr_words,"
+        "test_ptr_words_dyn,test_ptr_words_dyn_shared,test_pointer,"
+        "test_count_pointer,test_array_2_pointer_fixed_size,"
+        "test_ptr_3_pointer,test_ptr_0_pointer_dyn,test_ptr_1_pointer_dyn,"
+        "test_time,test_count_time,test_array_2_time_fixed_size,"
+        "test_ptr_2_time,test_hashtable,test_count_hashtable,"
+        "test_array_2_hashtable_fixed_size,test_ptr_2_hashtable,"
+        "test_ptr_1_hashtable_dyn,test_other,test_count_other,"
+        "test_ptr_3_other,test_count_invalid,test_ptr_invalid,prev_item,"
+        "next_item",
+        hdata_get_string (ptr_hdata, "var_keys"));
+
+    prop = hdata_get_string (ptr_hdata, "var_values");
+    items = string_split (prop, ",", NULL, 0, 0, &num_items);
+    LONGS_EQUAL(45, num_items);
+    string_free_split (items);
+
+    prop = hdata_get_string (ptr_hdata, "var_keys_values");
+    items = string_split (prop, ",", NULL, 0, 0, &num_items);
+    LONGS_EQUAL(45, num_items);
+    string_free_split (items);
+
+    STRCMP_EQUAL("prev_item", hdata_get_string (ptr_hdata, "var_prev"));
+    STRCMP_EQUAL("next_item", hdata_get_string (ptr_hdata, "var_next"));
+
+    STRCMP_EQUAL("items,last_item", hdata_get_string (ptr_hdata, "list_keys"));
+    prop = hdata_get_string (ptr_hdata, "list_values");
+    items = string_split (prop, ",", NULL, 0, 0, &num_items);
+    LONGS_EQUAL(2, num_items);
+    string_free_split (items);
+    prop = hdata_get_string (ptr_hdata, "list_keys_values");
+    items = string_split (prop, ",", NULL, 0, 0, &num_items);
+    LONGS_EQUAL(2, num_items);
+    string_free_split (items);
 }
 
 /*
  * Tests functions:
+ *   hdata_free
  *   hdata_free_all_plugin
  *   hdata_free_all
  */
 
-TEST(CoreHdata, Free)
+TEST(CoreHdataWithList, Free)
 {
     /* TODO: write tests */
 }
@@ -112,7 +2246,7 @@ TEST(CoreHdata, Free)
  *   hdata_print_log
  */
 
-TEST(CoreHdata, PrintLog)
+TEST(CoreHdataWithList, PrintLog)
 {
     /* TODO: write tests */
 }