pegasus/weechat
1
0
Fork 0
mirror of https://github.com/weechat/weechat.git synced 2026-06-12 14:14:48 +02:00
Code Activity
Files
106fe6ca7cb5ac9a1c4615119740dd1503a0b07d
weechat/tests/unit/core/test-core-hdata.cpp
T
Sébastien Helleu 106fe6ca7c core: update copyright dates
2026-03-08 10:37:15 +01:00

2680 lines
106 KiB
C++
Raw Blame History

/*
* SPDX-FileCopyrightText: 2014-2026 Sébastien Helleu <flashcode@flashtux.org>
*
* SPDX-License-Identifier: GPL-3.0-or-later
*
* This file is part of WeeChat, the extensible chat client.
*
* WeeChat is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* WeeChat is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with WeeChat. If not, see <https://www.gnu.org/licenses/>.
*/
/* Test hdata functions */
#include "CppUTest/TestHarness.h"
extern "C"
{
#include <string.h>
#include <time.h>
#include <sys/time.h>
#include "src/core/core-hdata.h"
#include "src/core/core-config.h"
#include "src/core/core-hashtable.h"
#include "src/core/core-hook.h"
#include "src/core/core-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;
/* long long */
long long test_longlong;
long long test_count_longlong;
long long test_array_2_longlong_fixed_size[2];
long long *test_ptr_2_longlong;
/* 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;
struct timeval test_time_tv;
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)
{
};
/*
* 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, NewList)
{
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;
/* long long */
item->test_longlong = 123456789123456L;
item->test_count_longlong = 2;
item->test_array_2_longlong_fixed_size[0] = 111L;
item->test_array_2_longlong_fixed_size[1] = 222L;
item->test_ptr_2_longlong = (long long *)malloc (
2 * sizeof (item->test_ptr_2_longlong[0]));
item->test_ptr_2_longlong[0] = 123456L;
item->test_ptr_2_longlong[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_time_tv.tv_sec = 1710485123;
item->test_time_tv.tv_usec = 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 (
2 * sizeof (item->test_ptr_1_hashtable_dyn[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;
/* long long */
item->test_longlong = 987654321987654L;
item->test_count_longlong = 2;
item->test_array_2_longlong_fixed_size[0] = 333L;
item->test_array_2_longlong_fixed_size[1] = 444L;
item->test_ptr_2_longlong = (long long *)malloc (
2 * sizeof (item->test_ptr_2_longlong[0]));
item->test_ptr_2_longlong[0] = 789123L;
item->test_ptr_2_longlong[1] = 891234L;
/* string */
item->test_string = strdup ("item2");
item->test_string2 = strdup ("string2");
item->test_string3 = NULL;
item->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_time_tv.tv_sec = 1710485456;
item->test_time_tv.tv_usec = 456789;
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 (
2 * sizeof (item->test_ptr_1_hashtable_dyn[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);
/* long long */
HDATA_VAR(struct t_test_item, test_longlong, LONGLONG, 1, NULL, NULL);
HDATA_VAR(struct t_test_item, test_count_longlong, LONGLONG, 0, NULL, NULL);
HDATA_VAR(struct t_test_item, test_array_2_longlong_fixed_size, LONGLONG, 0, "2", NULL);
HDATA_VAR(struct t_test_item, test_ptr_2_longlong, LONGLONG, 0, "*,test_count_longlong", 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_NAME(struct t_test_item, test_time_tv.tv_sec, "test_time_tv_sec", TIME, 1, NULL, NULL);
HDATA_VAR_NAME(struct t_test_item, test_time_tv.tv_usec, "test_time_tv_usec", LONG, 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);
/* long long */
free (item->test_ptr_2_longlong);
/* 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_LONGLONG,
hdata_get_var_type (ptr_hdata, "test_longlong"));
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_TIME,
hdata_get_var_type (ptr_hdata, "test_time_tv_sec"));
LONGS_EQUAL(WEECHAT_HDATA_LONG,
hdata_get_var_type (ptr_hdata, "test_time_tv_usec"));
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)
{
STRCMP_EQUAL(NULL, hdata_get_var_type_string (NULL, NULL));
STRCMP_EQUAL(NULL, hdata_get_var_type_string (ptr_hdata, NULL));
STRCMP_EQUAL(NULL, hdata_get_var_type_string (NULL, "test_char"));
STRCMP_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("longlong",
hdata_get_var_type_string (ptr_hdata, "test_longlong"));
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("time",
hdata_get_var_type_string (ptr_hdata, "test_time_tv_sec"));
STRCMP_EQUAL("long",
hdata_get_var_type_string (ptr_hdata, "test_time_tv_usec"));
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_longlong_fixed_size"));
LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item1,
"test_ptr_2_longlong"));
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_longlong_fixed_size"));
LONGS_EQUAL(2, hdata_get_var_array_size (ptr_hdata, ptr_item2,
"test_ptr_2_longlong"));
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)
{
STRCMP_EQUAL(NULL, hdata_get_var_array_size_string (NULL, NULL, NULL));
STRCMP_EQUAL(NULL, hdata_get_var_array_size_string (ptr_hdata, NULL, NULL));
STRCMP_EQUAL(NULL, hdata_get_var_array_size_string (NULL, NULL, "test_char"));
STRCMP_EQUAL(NULL, hdata_get_var_array_size_string (ptr_hdata, NULL, "zzz"));
STRCMP_EQUAL(NULL, hdata_get_var_array_size_string (ptr_hdata, ptr_item1, "zzz"));
/* not an array */
STRCMP_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_longlong_fixed_size"));
STRCMP_EQUAL("test_count_longlong",
hdata_get_var_array_size_string (ptr_hdata, ptr_item1,
"test_ptr_2_longlong"));
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_longlong_fixed_size"));
STRCMP_EQUAL("test_count_longlong",
hdata_get_var_array_size_string (ptr_hdata, ptr_item2,
"test_ptr_2_longlong"));
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)
{
STRCMP_EQUAL(NULL, hdata_get_var_hdata (NULL, NULL));
STRCMP_EQUAL(NULL, hdata_get_var_hdata (ptr_hdata, NULL));
STRCMP_EQUAL(NULL, hdata_get_var_hdata (NULL, "test_char"));
STRCMP_EQUAL(NULL, hdata_get_var_hdata (ptr_hdata, "zzz"));
/* no reference to hdata */
STRCMP_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(CoreHdataWithList, GetList)
{
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"));
}
/*
* Tests functions:
* hdata_check_pointer
*/
TEST(CoreHdataWithList, Check)
{
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(CoreHdataWithList, Search)
{
struct t_hashtable *pointers, *extra_vars;
pointers = hashtable_new (8,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_POINTER,
NULL,
NULL);
extra_vars = hashtable_new (8,
WEECHAT_HASHTABLE_STRING,
WEECHAT_HASHTABLE_STRING,
NULL,
NULL);
POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, NULL,
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, NULL,
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (NULL, items, NULL,
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, "${test_char} == A",
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, NULL,
NULL, NULL, NULL, 1));
POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, items, NULL,
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, "${test_char} == A",
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, NULL, NULL, NULL, NULL, 1));
POINTERS_EQUAL(NULL, hdata_search (NULL, items, "${test_char} == A",
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (NULL, items, NULL, NULL, NULL, NULL, 1));
POINTERS_EQUAL(NULL, hdata_search (NULL, NULL, "${test_char} == A",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, items, "${test_char} == A",
NULL, NULL, NULL, 0));
POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, items, NULL,
NULL, NULL, NULL, 1));
POINTERS_EQUAL(NULL, hdata_search (ptr_hdata, NULL, "${test_char} == A",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(NULL, hdata_search (NULL, items, "${test_char} == A",
NULL, NULL, NULL, 1));
/* search char */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_char} == Z",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_char} == X",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_char} == A",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_char} == a",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_char} == A",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "a");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_char} == ${value}",
NULL, extra_vars, NULL, 1));
/* search integer */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_int} == 999",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_int} == 456",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_int} == 123",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_int} == 456",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_int} == 123",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "456");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_int} == ${value}",
NULL, extra_vars, NULL, 1));
/* search long */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_long} == 999",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_long} == 987654321",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_long} == 123456789",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_long} == 987654321",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_long} == 123456789",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "987654321");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_long} == ${value}",
NULL, extra_vars, NULL, 1));
/* search long long */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_longlong} == 999",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_longlong} == 987654321987654",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_longlong} == 123456789123456",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_longlong} == 987654321987654",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_longlong} == 123456789123456",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "987654321987654");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_longlong} == ${value}",
NULL, extra_vars, NULL, 1));
/* search string */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_string} == zzz",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_string} == item2",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_string} == item1",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_string} == item2",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_string} == item1",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "item2");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_string} == item2",
NULL, extra_vars, NULL, 1));
/* search shared string */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_shared_string} == zzz",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_shared_string} == item2_shared",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_shared_string} == item1_shared",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_shared_string} == item2_shared",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_shared_string} == item1_shared",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "item2_shared");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_shared_string} == item2_shared",
NULL, NULL, NULL, 1));
/* search pointer */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_pointer} == 0x999",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_pointer} == 0x456",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_pointer} == 0x123",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_pointer} == 0x456",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_pointer} == 0x123",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "0x456");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_pointer} == ${value}",
NULL, extra_vars, NULL, 1));
hashtable_set (pointers, "value", (void *)0x456);
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_pointer} == ${value}",
pointers, NULL, NULL, 1));
/* search time */
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_time} == 999",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
NULL,
hdata_search (ptr_hdata, items,
"${test_item.test_time} == 789123",
NULL, NULL, NULL, 2));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_time} == 123456",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_time_tv_sec} == 1710485123",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, items,
"${test_item.test_time_tv_usec} == 123456",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_time} == 789123",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_time_tv_sec} == 1710485456",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_time_tv_usec} == 456789",
NULL, NULL, NULL, 1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_time} == 123456",
NULL, NULL, NULL, -1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_time_tv_sec} == 1710485123",
NULL, NULL, NULL, -1));
POINTERS_EQUAL(
ptr_item1,
hdata_search (ptr_hdata, last_item,
"${test_item.test_time_tv_usec} == 123456",
NULL, NULL, NULL, -1));
hashtable_set (extra_vars, "value", "789123");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_time} == ${value}",
NULL, extra_vars, NULL, 1));
hashtable_set (extra_vars, "value", "1710485456");
POINTERS_EQUAL(
ptr_item2,
hdata_search (ptr_hdata, items,
"${test_item.test_time_tv_sec} == ${value}",
NULL, extra_vars, NULL, 1));
hashtable_free (pointers);
hashtable_free (extra_vars);
}
/*
* Tests functions:
* hdata_count
*/
TEST(CoreHdataWithList, Count)
{
LONGS_EQUAL(0, hdata_count (NULL, NULL));
LONGS_EQUAL(0, hdata_count (ptr_hdata, NULL));
LONGS_EQUAL(0, hdata_count (NULL, items));
LONGS_EQUAL(2, hdata_count (ptr_hdata, items));
LONGS_EQUAL(1, hdata_count (ptr_hdata, ptr_item2));
}
/*
* 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);
STRCMP_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_longlong
*/
TEST(CoreHdataWithList, LongLong)
{
LONGS_EQUAL(0, hdata_longlong (NULL, NULL, NULL));
LONGS_EQUAL(0, hdata_longlong (ptr_hdata, NULL, NULL));
LONGS_EQUAL(0, hdata_longlong (NULL, ptr_item1, NULL));
LONGS_EQUAL(0, hdata_longlong (NULL, NULL, "test_longlong"));
LONGS_EQUAL(0, hdata_longlong (ptr_hdata, ptr_item1, NULL));
LONGS_EQUAL(0, hdata_longlong (ptr_hdata, NULL, "test_longlong"));
LONGS_EQUAL(0, hdata_longlong (NULL, ptr_item1, "test_longlong"));
/* variable not found */
LONGS_EQUAL(0, hdata_longlong (ptr_hdata, ptr_item1, "zzz"));
LONGS_EQUAL(0, hdata_longlong (ptr_hdata, ptr_item1, "1|zzz"));
/* item 1 */
LONGS_EQUAL(123456789123456L, hdata_longlong (ptr_hdata, ptr_item1, "test_longlong"));
LONGS_EQUAL(111L, hdata_longlong (ptr_hdata, ptr_item1,
"0|test_array_2_longlong_fixed_size"));
LONGS_EQUAL(222L, hdata_longlong (ptr_hdata, ptr_item1,
"1|test_array_2_longlong_fixed_size"));
LONGS_EQUAL(123456L, hdata_longlong (ptr_hdata, ptr_item1,
"0|test_ptr_2_longlong"));
LONGS_EQUAL(234567L, hdata_longlong (ptr_hdata, ptr_item1,
"1|test_ptr_2_longlong"));
/* item 2 */
LONGS_EQUAL(987654321987654L, hdata_longlong (ptr_hdata, ptr_item2, "test_longlong"));
LONGS_EQUAL(333L, hdata_longlong (ptr_hdata, ptr_item2,
"0|test_array_2_longlong_fixed_size"));
LONGS_EQUAL(444L, hdata_longlong (ptr_hdata, ptr_item2,
"1|test_array_2_longlong_fixed_size"));
LONGS_EQUAL(789123L, hdata_longlong (ptr_hdata, ptr_item2,
"0|test_ptr_2_longlong"));
LONGS_EQUAL(891234L, hdata_longlong (ptr_hdata, ptr_item2,
"1|test_ptr_2_longlong"));
}
/*
* Tests functions:
* hdata_string
*/
TEST(CoreHdataWithList, String)
{
STRCMP_EQUAL(NULL, hdata_string (NULL, NULL, NULL));
STRCMP_EQUAL(NULL, hdata_string (ptr_hdata, NULL, NULL));
STRCMP_EQUAL(NULL, hdata_string (NULL, ptr_item1, NULL));
STRCMP_EQUAL(NULL, hdata_string (NULL, NULL, "test_string"));
STRCMP_EQUAL(NULL, hdata_string (ptr_hdata, ptr_item1, NULL));
STRCMP_EQUAL(NULL, hdata_string (ptr_hdata, NULL, "test_string"));
STRCMP_EQUAL(NULL, hdata_string (NULL, ptr_item1, "test_string"));
/* variable not found */
STRCMP_EQUAL(NULL, hdata_string (ptr_hdata, ptr_item1, "zzz"));
STRCMP_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(CoreHdataWithList, Time)
{
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 (NULL, NULL, "test_time_tv_sec"));
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 (ptr_hdata, NULL, "test_time_tv_sec"));
LONGS_EQUAL(0, hdata_time (NULL, ptr_item1, "test_time"));
LONGS_EQUAL(0, hdata_time (NULL, ptr_item1, "test_time_tv_sec"));
/* 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(1710485123, hdata_time (ptr_hdata, ptr_item1, "test_time_tv_sec"));
LONGS_EQUAL(123456, hdata_time (ptr_hdata, ptr_item1, "test_time_tv_usec"));
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(1710485456, hdata_time (ptr_hdata, ptr_item2, "test_time_tv_sec"));
LONGS_EQUAL(456789, hdata_time (ptr_hdata, ptr_item2, "test_time_tv_usec"));
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)
{
struct t_gui_buffer *test_buffer;
struct t_hdata *ptr_hdata_buffer;
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 long long integers: 123456789123456ULL and 987654321987654ULL */
LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
"test_longlong", 0));
LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
"test_longlong", 0));
LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
"test_longlong", 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 times: 1710485123 and 1710485456 */
LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
"test_time_tv_sec", 0));
LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
"test_time_tv_sec", 0));
LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
"test_time_tv_sec", 0));
/* compare microseconds (long): 123456 and 456789 */
LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item1,
"test_time_tv_usec", 0));
LONGS_EQUAL(-1, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
"test_time_tv_usec", 0));
LONGS_EQUAL(1, hdata_compare (ptr_hdata, ptr_item2, ptr_item1,
"test_time_tv_usec", 0));
/* compare hashtables: pointer comparison */
CHECK(hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
"test_hashtable", 0) != 0);
/* compare "other" type: not possible */
LONGS_EQUAL(0, hdata_compare (ptr_hdata, ptr_item1, ptr_item2,
"test_other", 0));
/* create a test buffer */
test_buffer = gui_buffer_new (NULL, "test",
NULL, NULL, NULL,
NULL, NULL, NULL);
CHECK(test_buffer);
ptr_hdata_buffer = hook_hdata_get (NULL, "buffer");
/* compare two sub-fields of buffers: test recursive path traversal */
LONGS_EQUAL(1, hdata_compare (ptr_hdata_buffer, gui_buffers, test_buffer,
"own_lines.lines_count", 0));
gui_buffer_set (gui_buffers, "localvar_set_myvar", "def");
gui_buffer_set (test_buffer, "localvar_set_myvar", "abc");
CHECK(ptr_hdata_buffer);
LONGS_EQUAL(1, hdata_compare (ptr_hdata_buffer, gui_buffers, test_buffer,
"local_variables.myvar", 0));
gui_buffer_set (gui_buffers, "localvar_del_myvar", "");
gui_buffer_close (test_buffer);
}
/*
* 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));
STRCMP_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));
STRCMP_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 long long to invalid value */
hashtable_remove_all (hashtable);
hashtable_set (hashtable, "test_longlong", "abc");
LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
LONGS_EQUAL(123456789123456L, ptr_item1->test_longlong);
/* set long long to -55 */
hashtable_remove_all (hashtable);
hashtable_set (hashtable, "test_longlong", "-55");
LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
LONGS_EQUAL(-55, ptr_item1->test_longlong);
/* set long long to 777 */
hashtable_remove_all (hashtable);
hashtable_set (hashtable, "test_longlong", "777");
LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
LONGS_EQUAL(777, ptr_item1->test_longlong);
/* 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 invalid value */
hashtable_remove_all (hashtable);
hashtable_set (hashtable, "test_time_tv_sec", "-15");
LONGS_EQUAL(0, hdata_update (ptr_hdata, ptr_item1, hashtable));
LONGS_EQUAL(1710485123, ptr_item1->test_time_tv.tv_sec);
/* 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 time to 111222333 */
hashtable_remove_all (hashtable);
hashtable_set (hashtable, "test_time_tv_sec", "111222333");
LONGS_EQUAL(1, hdata_update (ptr_hdata, ptr_item1, hashtable));
LONGS_EQUAL(111222333, ptr_item1->test_time_tv.tv_sec);
/* 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;
STRCMP_EQUAL(NULL, hdata_get_string (NULL, NULL));
STRCMP_EQUAL(NULL, hdata_get_string (ptr_hdata, NULL));
STRCMP_EQUAL(NULL, hdata_get_string (NULL, "var_keys"));
STRCMP_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_longlong,"
"test_count_longlong,test_array_2_longlong_fixed_size,"
"test_ptr_2_longlong,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_time_tv_sec,test_time_tv_usec,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(51, 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(51, 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(CoreHdataWithList, Free)
{
/* TODO: write tests */
}
/*
* Tests functions:
* hdata_print_log
*/
TEST(CoreHdataWithList, PrintLog)
{
/* TODO: write tests */
}
View Git Blame Copy Permalink