api: remember insertion order in hashtables

2026-07-07 18:23:13 +02:00 · 2021-06-26 21:37:02 +02:00
parent 5a59482cc8
commit a48a615613
10 changed files with 554 additions and 106 deletions
@@ -25,6 +25,8 @@ extern "C"
 {
 #include <string.h>
 #include "src/core/wee-hashtable.h"
+#include "src/core/wee-infolist.h"
+#include "src/core/wee-list.h"
 #include "src/plugins/plugin.h"
 }

@@ -34,8 +36,27 @@ extern "C"
 #define HASHTABLE_TEST_KEY_LONG_HASH 11232856562070989738ULL
 #define HASHTABLE_TEST_VALUE         "this is a value"

+char *test_map_string = NULL;
+
 TEST_GROUP(CoreHashtable)
 {
+    struct t_hashtable *get_weechat_hashtable ()
+    {
+        struct t_hashtable *hashtable;
+
+        hashtable = hashtable_new (8,
+                                   WEECHAT_HASHTABLE_STRING,
+                                   WEECHAT_HASHTABLE_STRING,
+                                   NULL,
+                                   NULL);
+        hashtable_set (hashtable, "weechat", "the first item");
+        hashtable_set (hashtable, "light", "item2");
+        hashtable_set (hashtable, "fast", "item3");
+        hashtable_set (hashtable, "extensible", "item4");
+        hashtable_set (hashtable, "chat", "item5");
+        hashtable_set (hashtable, "client", "last item");
+        return hashtable;
+    }
 };

 /*
@@ -121,6 +142,8 @@ TEST(CoreHashtable, New)
    LONGS_EQUAL(32, hashtable->size);
    CHECK(hashtable->htable);
    LONGS_EQUAL(0, hashtable->items_count);
+    POINTERS_EQUAL(NULL, hashtable->oldest_item);
+    POINTERS_EQUAL(NULL, hashtable->newest_item);
    LONGS_EQUAL(HASHTABLE_STRING, hashtable->type_keys);
    LONGS_EQUAL(HASHTABLE_INTEGER, hashtable->type_values);
    POINTERS_EQUAL(&test_hashtable_hash_key_cb, hashtable->callback_hash_key);
@@ -169,23 +192,31 @@ TEST(CoreHashtable, SetGetRemove)
    item = hashtable_set (hashtable, str_key, NULL);
    CHECK(item);
    LONGS_EQUAL(1, hashtable->items_count);
+    CHECK(hashtable->oldest_item);
+    CHECK(hashtable->newest_item);
    STRCMP_EQUAL(str_key, (const char *)item->key);
    LONGS_EQUAL(strlen (str_key) + 1, item->key_size);
    POINTERS_EQUAL(NULL, item->value);
    LONGS_EQUAL(0, item->value_size);
    POINTERS_EQUAL(NULL, item->prev_item);
    POINTERS_EQUAL(NULL, item->next_item);
+    POINTERS_EQUAL(NULL, item->prev_created_item);
+    POINTERS_EQUAL(NULL, item->next_created_item);

    /* set a string value for the same key */
    item = hashtable_set (hashtable, str_key, str_value);
    CHECK(item);
    LONGS_EQUAL(1, hashtable->items_count);
+    CHECK(hashtable->oldest_item);
+    CHECK(hashtable->newest_item);
    STRCMP_EQUAL(str_key, (const char *)item->key);
    LONGS_EQUAL(strlen (str_key) + 1, item->key_size);
    STRCMP_EQUAL(str_value, (const char *)item->value);
    LONGS_EQUAL(strlen (str_value) + 1, item->value_size);
    POINTERS_EQUAL(NULL, item->prev_item);
    POINTERS_EQUAL(NULL, item->next_item);
+    POINTERS_EQUAL(NULL, item->prev_created_item);
+    POINTERS_EQUAL(NULL, item->next_created_item);

    /* get item */
    item = hashtable_get_item (hashtable, str_key, &hash);
@@ -208,6 +239,8 @@ TEST(CoreHashtable, SetGetRemove)
    /* delete an item */
    hashtable_remove (hashtable, str_key);
    LONGS_EQUAL(0, hashtable->items_count);
+    POINTERS_EQUAL(NULL, hashtable->oldest_item);
+    POINTERS_EQUAL(NULL, hashtable->newest_item);

    /* add an item with size in hashtable */
    item = hashtable_set_with_size (hashtable,
@@ -215,6 +248,8 @@ TEST(CoreHashtable, SetGetRemove)
                                    str_value, strlen (str_value) + 1);
    CHECK(item);
    LONGS_EQUAL(1, hashtable->items_count);
+    CHECK(hashtable->oldest_item);
+    CHECK(hashtable->newest_item);
    STRCMP_EQUAL(str_key, (const char *)item->key);
    LONGS_EQUAL(strlen (str_key) + 1, item->key_size);
    STRCMP_EQUAL(str_value, (const char *)item->value);
@@ -223,6 +258,15 @@ TEST(CoreHashtable, SetGetRemove)
    /* add another item */
    hashtable_set (hashtable, "xxx", "zzz");
    LONGS_EQUAL(2, hashtable->items_count);
+    CHECK(hashtable->oldest_item);
+    CHECK(hashtable->newest_item);
+    CHECK(hashtable->oldest_item != hashtable->newest_item);
+    CHECK(hashtable->oldest_item->next_created_item == hashtable->newest_item);
+    STRCMP_EQUAL(str_key, (const char *)hashtable->oldest_item->key);
+    STRCMP_EQUAL("xxx",
+                 (const char *)hashtable->oldest_item->next_created_item->key);
+    STRCMP_EQUAL("xxx",
+                 (const char *)hashtable->newest_item->key);

    /*
     * test duplication of hashtable and check that duplicated content is
@@ -273,7 +317,17 @@ TEST(CoreHashtable, SetGetRemove)

    /* remove all items */
    hashtable_remove_all (hashtable);
+    POINTERS_EQUAL(NULL, hashtable->htable[0]);
+    POINTERS_EQUAL(NULL, hashtable->htable[1]);
+    POINTERS_EQUAL(NULL, hashtable->htable[2]);
+    POINTERS_EQUAL(NULL, hashtable->htable[3]);
+    POINTERS_EQUAL(NULL, hashtable->htable[4]);
+    POINTERS_EQUAL(NULL, hashtable->htable[5]);
+    POINTERS_EQUAL(NULL, hashtable->htable[6]);
+    POINTERS_EQUAL(NULL, hashtable->htable[7]);
    LONGS_EQUAL(0, hashtable->items_count);
+    POINTERS_EQUAL(NULL, hashtable->oldest_item);
+    POINTERS_EQUAL(NULL, hashtable->newest_item);

    /* free hashtables */
    hashtable_free (hashtable);
@@ -313,13 +367,13 @@ TEST(CoreHashtable, SetGetRemove)
    CHECK(item);
    POINTERS_EQUAL(item, hashtable->htable[7]);

-    item = hashtable_set (hashtable, "fast", NULL);
+    item = hashtable_set (hashtable, "light", NULL);
    CHECK(item);
    POINTERS_EQUAL(item, hashtable->htable[3]);

-    item = hashtable_set (hashtable, "light", NULL);
+    item = hashtable_set (hashtable, "fast", NULL);
    CHECK(item);
-    POINTERS_EQUAL(item, hashtable->htable[3]->next_item);
+    POINTERS_EQUAL(item, hashtable->htable[3]);

    item = hashtable_set (hashtable, "extensible", NULL);
    CHECK(item);
@@ -333,32 +387,335 @@ TEST(CoreHashtable, SetGetRemove)
    CHECK(item);
    POINTERS_EQUAL(item, hashtable->htable[6]);

+    /* check items by order of creation */
+    ptr_item = hashtable->oldest_item;
+    STRCMP_EQUAL("weechat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("light", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("fast", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("extensible", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("chat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("client", (const char *)ptr_item->key);
+    STRCMP_EQUAL("client", (const char *)hashtable->newest_item->key);
+    ptr_item = ptr_item->next_created_item;
+    POINTERS_EQUAL(NULL, ptr_item);
+
+    /* remove items and check again by order of creation */
+    hashtable_remove (hashtable, "fast");
+    LONGS_EQUAL(5, hashtable->items_count);
+    ptr_item = hashtable->oldest_item;
+    STRCMP_EQUAL("weechat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("light", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("extensible", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("chat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("client", (const char *)ptr_item->key);
+    STRCMP_EQUAL("client", (const char *)hashtable->newest_item->key);
+    ptr_item = ptr_item->next_created_item;
+    POINTERS_EQUAL(NULL, ptr_item);
+
+    hashtable_remove (hashtable, "light");
+    LONGS_EQUAL(4, hashtable->items_count);
+    ptr_item = hashtable->oldest_item;
+    STRCMP_EQUAL("weechat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("extensible", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("chat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("client", (const char *)ptr_item->key);
+    STRCMP_EQUAL("client", (const char *)hashtable->newest_item->key);
+    ptr_item = ptr_item->next_created_item;
+    POINTERS_EQUAL(NULL, ptr_item);
+
+    hashtable_remove (hashtable, "weechat");
+    LONGS_EQUAL(3, hashtable->items_count);
+    ptr_item = hashtable->oldest_item;
+    STRCMP_EQUAL("extensible", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("chat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("client", (const char *)ptr_item->key);
+    STRCMP_EQUAL("client", (const char *)hashtable->newest_item->key);
+    ptr_item = ptr_item->next_created_item;
+    POINTERS_EQUAL(NULL, ptr_item);
+
+    hashtable_remove (hashtable, "client");
+    LONGS_EQUAL(2, hashtable->items_count);
+    ptr_item = hashtable->oldest_item;
+    STRCMP_EQUAL("extensible", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("chat", (const char *)ptr_item->key);
+    STRCMP_EQUAL("chat", (const char *)hashtable->newest_item->key);
+    ptr_item = ptr_item->next_created_item;
+    POINTERS_EQUAL(NULL, ptr_item);
+
+    /* check current content of hashtable */
+    POINTERS_EQUAL(NULL, hashtable->htable[0]);
+    POINTERS_EQUAL(NULL, hashtable->htable[1]);
+    STRCMP_EQUAL("extensible", (const char *)hashtable->htable[2]->key);
+    POINTERS_EQUAL(NULL, hashtable->htable[3]);
+    POINTERS_EQUAL(NULL, hashtable->htable[4]);
+    STRCMP_EQUAL("chat", (const char *)hashtable->htable[5]->key);
+    POINTERS_EQUAL(NULL, hashtable->htable[6]);
+    POINTERS_EQUAL(NULL, hashtable->htable[7]);
+
    /* free hashtable */
    hashtable_free (hashtable);
 }

+void
+test_hashtable_map_string_cb (void *data,
+                              struct t_hashtable *hashtable,
+                              const char *key, const char *value)
+{
+    /* make C++ compiler happy */
+    (void) hashtable;
+    (void) data;
+
+    if (test_map_string[0])
+        strcat (test_map_string, ";");
+    strcat (test_map_string, key);
+    strcat (test_map_string, ":");
+    strcat (test_map_string, value);
+}
+
+/*
+ * Tests functions:
+ *   hashtable_map_string
+ */
+
+TEST(CoreHashtable, MapString)
+{
+    struct t_hashtable *hashtable;
+    int value_int;
+    void *value_ptr;
+    time_t value_time;
+    char result[1024], value_buffer[3] = { 0x01, 0x05, 0x09 };
+
+    test_map_string = (char *)malloc (1024);
+
+    /* string -> string */
+    test_map_string[0] = '\0';
+    hashtable = get_weechat_hashtable ();
+    hashtable_map_string (hashtable, &test_hashtable_map_string_cb, NULL);
+    STRCMP_EQUAL("weechat:the first item;light:item2;fast:item3;"
+                 "extensible:item4;chat:item5;client:last item",
+                 test_map_string);
+
+    /* integer -> pointer */
+    test_map_string[0] = '\0';
+    hashtable = hashtable_new (8,
+                               WEECHAT_HASHTABLE_INTEGER,
+                               WEECHAT_HASHTABLE_POINTER,
+                               NULL,
+                               NULL);
+    value_int = 123;
+    value_ptr = (void *)0x123abc;
+    hashtable_set (hashtable, &value_int, value_ptr);
+    value_int = 45678;
+    value_ptr = (void *)0xdef789;
+    hashtable_set (hashtable, &value_int, value_ptr);
+    hashtable_map_string (hashtable, &test_hashtable_map_string_cb, NULL);
+    STRCMP_EQUAL("123:0x123abc;45678:0xdef789", test_map_string);
+
+    /* time -> buffer */
+    test_map_string[0] = '\0';
+    hashtable = hashtable_new (8,
+                               WEECHAT_HASHTABLE_TIME,
+                               WEECHAT_HASHTABLE_BUFFER,
+                               NULL,
+                               NULL);
+    value_time = 1624693124;
+    hashtable_set_with_size (hashtable,
+                             &value_time, 0,
+                             value_buffer, sizeof (value_buffer));
+    hashtable_map_string (hashtable, &test_hashtable_map_string_cb, NULL);
+    snprintf (result, sizeof (result),
+              "1624693124:0x%lx",
+              (unsigned long)(hashtable->newest_item->value));
+    STRCMP_EQUAL(result, test_map_string);
+
+    free (test_map_string);
+}
+
 /*
 * Tests functions:
 *   hashtable_map
- *   hashtable_map_string
+ *   hashtable_dup
 */

-TEST(CoreHashtable, Map)
+TEST(CoreHashtable, Dup)
 {
-    /* TODO: write tests */
+    struct t_hashtable *hashtable, *hashtable2;
+    struct t_hashtable_item *ptr_item;
+
+    hashtable = get_weechat_hashtable ();
+
+    POINTERS_EQUAL(NULL, hashtable_dup (NULL));
+
+    hashtable2 = hashtable_dup (hashtable);
+
+    LONGS_EQUAL(6, hashtable2->items_count);
+    ptr_item = hashtable2->oldest_item;
+    STRCMP_EQUAL("weechat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("light", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("fast", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("extensible", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("chat", (const char *)ptr_item->key);
+    ptr_item = ptr_item->next_created_item;
+    STRCMP_EQUAL("client", (const char *)ptr_item->key);
+    STRCMP_EQUAL("client", (const char *)hashtable2->newest_item->key);
+    ptr_item = ptr_item->next_created_item;
+    POINTERS_EQUAL(NULL, ptr_item);
+
+    hashtable_free (hashtable);
+    hashtable_free (hashtable2);
 }

 /*
 * Tests functions:
 *   hashtable_get_list_keys
+ */
+
+TEST(CoreHashtable, GetListKeys)
+{
+    struct t_hashtable *hashtable;
+    struct t_weelist *list_keys;
+
+    hashtable = get_weechat_hashtable ();
+
+    POINTERS_EQUAL(NULL, hashtable_get_list_keys (NULL));
+
+    list_keys = hashtable_get_list_keys (hashtable);
+    CHECK(list_keys);
+    STRCMP_EQUAL("chat", weelist_string (weelist_get (list_keys, 0)));
+    STRCMP_EQUAL("client", weelist_string (weelist_get (list_keys, 1)));
+    STRCMP_EQUAL("extensible", weelist_string (weelist_get (list_keys, 2)));
+    STRCMP_EQUAL("fast", weelist_string (weelist_get (list_keys, 3)));
+    STRCMP_EQUAL("light", weelist_string (weelist_get (list_keys, 4)));
+    STRCMP_EQUAL("weechat", weelist_string (weelist_get (list_keys, 5)));
+
+    hashtable_free (hashtable);
+}
+
+/*
+ * Tests functions:
 *   hashtable_get_integer
+ */
+
+TEST(CoreHashtable, GetInteger)
+{
+    struct t_hashtable *hashtable;
+
+    hashtable = get_weechat_hashtable ();
+
+    LONGS_EQUAL(0, hashtable_get_integer (NULL, NULL));
+    LONGS_EQUAL(0, hashtable_get_integer (hashtable, NULL));
+    LONGS_EQUAL(0, hashtable_get_integer (hashtable, ""));
+    LONGS_EQUAL(0, hashtable_get_integer (hashtable, "unknown"));
+
+    LONGS_EQUAL(8, hashtable_get_integer (hashtable, "size"));
+    LONGS_EQUAL(6, hashtable_get_integer (hashtable, "items_count"));
+
+    hashtable_free (hashtable);
+}
+
+/*
+ * Tests functions:
 *   hashtable_get_string
+ */
+
+TEST(CoreHashtable, GetString)
+{
+    struct t_hashtable *hashtable;
+
+    hashtable = get_weechat_hashtable ();
+
+    POINTERS_EQUAL(NULL, hashtable_get_string (NULL, NULL));
+    POINTERS_EQUAL(NULL, hashtable_get_string (hashtable, NULL));
+    POINTERS_EQUAL(NULL, hashtable_get_string (hashtable, ""));
+    POINTERS_EQUAL(NULL, hashtable_get_string (hashtable, "unknown"));
+
+    STRCMP_EQUAL("string", hashtable_get_string (hashtable, "type_keys"));
+    STRCMP_EQUAL("string", hashtable_get_string (hashtable, "type_values"));
+    STRCMP_EQUAL("weechat,light,fast,extensible,chat,client",
+                 hashtable_get_string (hashtable, "keys"));
+    STRCMP_EQUAL("chat,client,extensible,fast,light,weechat",
+                 hashtable_get_string (hashtable, "keys_sorted"));
+    STRCMP_EQUAL("the first item,item2,item3,item4,item5,last item",
+                 hashtable_get_string (hashtable, "values"));
+    STRCMP_EQUAL("weechat:the first item,light:item2,fast:item3,"
+                 "extensible:item4,chat:item5,client:last item",
+                 hashtable_get_string (hashtable, "keys_values"));
+    STRCMP_EQUAL("chat:item5,client:last item,extensible:item4,fast:item3,"
+                 "light:item2,weechat:the first item",
+                 hashtable_get_string (hashtable, "keys_values_sorted"));
+
+    hashtable_free (hashtable);
+}
+
+/*
+ * Test callback freeing key (it does nothing).
+ */
+
+void
+test_hashtable_free_key (struct t_hashtable *hashtable, void *key)
+{
+    /* make C++ compiler happy */
+    (void) hashtable;
+    (void) key;
+}
+
+/*
+ * Test callback freeing value (it does nothing).
+ */
+
+void
+test_hashtable_free_value (struct t_hashtable *hashtable,
+                           const void *key, void *value)
+{
+    /* make C++ compiler happy */
+    (void) hashtable;
+    (void) key;
+    (void) value;
+}
+
+/*
+ * Tests functions:
 *   hashtable_set_pointer
 */

-TEST(CoreHashtable, Properties)
+TEST(CoreHashtable, SetPointer)
 {
-    /* TODO: write tests */
+    struct t_hashtable *hashtable;
+
+    hashtable = get_weechat_hashtable ();
+
+    hashtable_set_pointer (NULL, NULL, NULL);
+    hashtable_set_pointer (hashtable, NULL, NULL);
+    hashtable_set_pointer (hashtable, "", NULL);
+    hashtable_set_pointer (hashtable, "unknown", NULL);
+
+    hashtable_set_pointer (hashtable,
+                           "callback_free_key", (void *)&test_hashtable_free_key);
+    POINTERS_EQUAL(&test_hashtable_free_key, hashtable->callback_free_key);
+    hashtable_set_pointer (hashtable,
+                           "callback_free_value", (void *)&test_hashtable_free_value);
+    POINTERS_EQUAL(&test_hashtable_free_value, hashtable->callback_free_value);
+
+    hashtable_free (hashtable);
 }

 /*
@@ -369,7 +726,36 @@ TEST(CoreHashtable, Properties)

 TEST(CoreHashtable, Infolist)
 {
-    /* TODO: write tests */
+    struct t_hashtable *hashtable;
+    struct t_infolist *infolist;
+    struct t_infolist_item *infolist_item;
+
+    hashtable = get_weechat_hashtable ();
+
+    infolist = infolist_new (NULL);
+    infolist_item = infolist_new_item (infolist);
+
+    LONGS_EQUAL(0, hashtable_add_to_infolist (NULL, NULL, NULL));
+    LONGS_EQUAL(0, hashtable_add_to_infolist (hashtable, NULL, NULL));
+    LONGS_EQUAL(0, hashtable_add_to_infolist (hashtable, infolist_item, NULL));
+
+    LONGS_EQUAL(1, hashtable_add_to_infolist (hashtable, infolist_item, "test"));
+
+    infolist_reset_item_cursor (infolist);
+    infolist_next (infolist);
+
+    STRCMP_EQUAL("weechat", infolist_string (infolist, "test_name_00000"));
+    STRCMP_EQUAL("the first item", infolist_string (infolist, "test_value_00000"));
+    STRCMP_EQUAL("light", infolist_string (infolist, "test_name_00001"));
+    STRCMP_EQUAL("item2", infolist_string (infolist, "test_value_00001"));
+    STRCMP_EQUAL("fast", infolist_string (infolist, "test_name_00002"));
+    STRCMP_EQUAL("item3", infolist_string (infolist, "test_value_00002"));
+    STRCMP_EQUAL("extensible", infolist_string (infolist, "test_name_00003"));
+    STRCMP_EQUAL("item4", infolist_string (infolist, "test_value_00003"));
+    STRCMP_EQUAL("chat", infolist_string (infolist, "test_name_00004"));
+    STRCMP_EQUAL("item5", infolist_string (infolist, "test_value_00004"));
+    STRCMP_EQUAL("client", infolist_string (infolist, "test_name_00005"));
+    STRCMP_EQUAL("last item", infolist_string (infolist, "test_value_00005"));
 }

 /*