lbbs/src/test_trie_dict.c

/* SPDX-License-Identifier: GPL-3.0-or-later */
/*
 * test_trie_dict
 *   - tester for trie-tree based dict feature
 *
 * Copyright (C) 2004-2025  Leaflet <leaflet@leafok.com>
 */

#include "log.h"
#include "trie_dict.h"
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

static const int64_t TEST_VAL = ((int64_t)(0xcb429a63a017661f)); // int64_t
static const char TRIE_DICT_SHM_FILE[] = "~trie_dict_shm.dat";

const char *keys[] = {
        "ABCDEFG",
        "abcdefg",
        "../$@^",
        "1234567890",
        "1234657890",
        "HZ测试汉字HZ",
        "P3p4P3z4P_",
        "_bbBBz_Z_",
        ""};

int keys_cnt = 8; // + 1 to trigger error handling of blank key

void test_traverse_cb(const char *key, int64_t value)
{
        printf("Traverse key: %s Len=%ld\n", key, strlen(key));
}

int main(int argc, char *argv[])
{
        TRIE_NODE *p_dict;
        int ret;
        int64_t value;
        FILE *fp;

        if (log_begin("../log/bbsd.log", "../log/error.log") < 0)
        {
                printf("Open log error\n");
                return -1;
        }

        log_common_redir(STDOUT_FILENO);
        log_error_redir(STDERR_FILENO);

        if ((fp = fopen(TRIE_DICT_SHM_FILE, "w")) == NULL)
        {
                log_error("fopen(%s) error\n", TRIE_DICT_SHM_FILE);
                return -1;
        }
        fclose(fp);

        for (int i = 0; i < keys_cnt; i++)
        {
                printf("Check key %d [%s] len=%ld\n", i, keys[i], strlen(keys[i]));
        }

        if (trie_dict_init(TRIE_DICT_SHM_FILE, TRIE_NODE_PER_POOL) < 0)
        {
                printf("trie_dict_init failed\n");
                return -1;
        }

        printf("Testing #1 ...\n");

        p_dict = trie_dict_create();

        if (p_dict == NULL)
        {
                printf("OOM\n");
                return -1;
        }

        ret = trie_dict_set(p_dict, NULL, TEST_VAL);
        if (ret != -1)
        {
                printf("Set NULL key error (%d)\n", ret);
        }

        ret = trie_dict_del(p_dict, NULL);
        if (ret != -1)
        {
                printf("Del NULL key error (%d)\n", ret);
        }

        for (int i = 0; i < keys_cnt; i++)
        {
                ret = trie_dict_set(p_dict, keys[i], TEST_VAL >> i);
                if (ret != 1)
                {
                        printf("Set non-existing [%s] error (%d)\n", keys[i], ret);
                }
        }

        for (int i = 0; i < keys_cnt; i++)
        {
                ret = trie_dict_get(p_dict, keys[i], &value);
                if (ret != 1)
                {
                        printf("Get [%s] error (%d)\n", keys[i], ret);
                }
                else if (value != TEST_VAL >> i)
                {
                        printf("Value of [%s] is incorrect (%ld != %ld)\n", keys[i], value, TEST_VAL >> i);
                }
        }

        trie_dict_traverse(p_dict, test_traverse_cb);

        for (int i = 0; i < keys_cnt; i++)
        {
                if (i % 2 == 0)
                {
                        ret = trie_dict_del(p_dict, keys[i]);
                        if (ret != 1)
                        {
                                printf("Del existing [%s] error (%d)\n", keys[i], ret);
                        }
                }
                else
                {
                        ret = trie_dict_set(p_dict, keys[i], TEST_VAL >> i);
                        if (ret != 0)
                        {
                                printf("Set existing [%s] with the same value error (%d)\n", keys[i], ret);
                        }
                }
        }

        for (int i = 0; i < keys_cnt; i++)
        {
                if (i % 2 == 0)
                {
                        ret = trie_dict_get(p_dict, keys[i], &value);
                        if (ret != 0)
                        {
                                printf("Get non-existing [%s] error (%d)\n", keys[i], ret);
                        }
                }
                else
                {
                        ret = trie_dict_get(p_dict, keys[i], &value);
                        if (ret != 1)
                        {
                                printf("Get [%s] error (%d)\n", keys[i], ret);
                        }
                        else if (value != TEST_VAL >> i)
                        {
                                printf("Value of [%s] is incorrect (%ld != %ld)\n", keys[i], value, TEST_VAL >> i);
                        }
                }
        }

        for (int i = 0; i < keys_cnt; i++)
        {
                if (i % 2 == 0)
                {
                        ret = trie_dict_del(p_dict, keys[i]);
                        if (ret != 0)
                        {
                                printf("Del non-existing [%s] error (%d)\n", keys[i], ret);
                        }
                }
                else
                {
                        ret = trie_dict_set(p_dict, keys[i], TEST_VAL << i);
                        if (ret != 1)
                        {
                                printf("Set existing [%s] with different value error (%d)\n", keys[i], ret);
                        }
                }
        }

        trie_dict_traverse(p_dict, test_traverse_cb);

        for (int i = 0; i < keys_cnt; i++)
        {
                if (i % 2 == 0)
                {
                        ret = trie_dict_get(p_dict, keys[i], &value);
                        if (ret != 0)
                        {
                                printf("Get non-existing [%s] error (%d)\n", keys[i], ret);
                        }
                }
                else
                {
                        ret = trie_dict_get(p_dict, keys[i], &value);
                        if (ret != 1)
                        {
                                printf("Get [%s] error (%d)\n", keys[i], ret);
                        }
                        else if (value != TEST_VAL << i)
                        {
                                printf("Value of [%s] is incorrect (%ld != %ld)\n", keys[i], value, TEST_VAL << i);
                        }
                }
        }

        printf("Total nodes used = %d\n", trie_dict_used_nodes());

        trie_dict_destroy(p_dict);
        p_dict = NULL;

        printf("Total nodes used = %d\n", trie_dict_used_nodes());

        printf("Testing #2 ...\n");

        for (int i = 0; i < 100000; i++)
        {
                p_dict = trie_dict_create();

                if (p_dict == NULL)
                {
                        printf("OOM\n");
                        return -1;
                }

                trie_dict_destroy(p_dict);
                p_dict = NULL;
        }

        printf("Testing #3 ...\n");

        if (set_trie_dict_shm_readonly() < 0)
        {
                printf("load_trie_dict_shm_readonly() error\n");
        }

        // if (unload_trie_dict_shm() < 0)
        // {
        //      printf("unload_trie_dict_shm() error\n");
        // }

        printf("Total nodes used = %d, after set_shm_readonly\n", trie_dict_used_nodes());

        trie_dict_cleanup();

        printf("Total nodes used = %d, after cleanup\n", trie_dict_used_nodes());

        printf("Done\n");

        if (unlink(TRIE_DICT_SHM_FILE) < 0)
        {
                log_error("unlink(%s) error\n", TRIE_DICT_SHM_FILE);
                return -1;
        }

        log_end();

        return 0;
}
1	/* SPDX-License-Identifier: GPL-3.0-or-later */
2	/*
3	* test_trie_dict
4	* - tester for trie-tree based dict feature
5	*
6	* Copyright (C) 2004-2025 Leaflet <leaflet@leafok.com>
7	*/
8
9	#include "log.h"
10	#include "trie_dict.h"
11	#include <errno.h>
12	#include <stdio.h>
13	#include <string.h>
14	#include <unistd.h>
15
16	static const int64_t TEST_VAL = ((int64_t)(0xcb429a63a017661f)); // int64_t
17	static const char TRIE_DICT_SHM_FILE[] = "~trie_dict_shm.dat";
18
19	const char *keys[] = {
20	"ABCDEFG",
21	"abcdefg",
22	"../$@^",
23	"1234567890",
24	"1234657890",
25	"HZ测试汉字HZ",
26	"P3p4P3z4P_",
27	"_bbBBz_Z_",
28	""};
29
30	int keys_cnt = 8; // + 1 to trigger error handling of blank key
31
32	void test_traverse_cb(const char *key, int64_t value)
33	{
34	printf("Traverse key: %s Len=%ld\n", key, strlen(key));
35	}
36
37	int main(int argc, char *argv[])
38	{
39	TRIE_NODE *p_dict;
40	int ret;
41	int64_t value;
42	FILE *fp;
43
44	if (log_begin("../log/bbsd.log", "../log/error.log") < 0)
45	{
46	printf("Open log error\n");
47	return -1;
48	}
49
50	log_common_redir(STDOUT_FILENO);
51	log_error_redir(STDERR_FILENO);
52
53	if ((fp = fopen(TRIE_DICT_SHM_FILE, "w")) == NULL)
54	{
55	log_error("fopen(%s) error\n", TRIE_DICT_SHM_FILE);
56	return -1;
57	}
58	fclose(fp);
59
60	for (int i = 0; i < keys_cnt; i++)
61	{
62	printf("Check key %d [%s] len=%ld\n", i, keys[i], strlen(keys[i]));
63	}
64
65	if (trie_dict_init(TRIE_DICT_SHM_FILE, TRIE_NODE_PER_POOL) < 0)
66	{
67	printf("trie_dict_init failed\n");
68	return -1;
69	}
70
71	printf("Testing #1 ...\n");
72
73	p_dict = trie_dict_create();
74
75	if (p_dict == NULL)
76	{
77	printf("OOM\n");
78	return -1;
79	}
80
81	ret = trie_dict_set(p_dict, NULL, TEST_VAL);
82	if (ret != -1)
83	{
84	printf("Set NULL key error (%d)\n", ret);
85	}
86
87	ret = trie_dict_del(p_dict, NULL);
88	if (ret != -1)
89	{
90	printf("Del NULL key error (%d)\n", ret);
91	}
92
93	for (int i = 0; i < keys_cnt; i++)
94	{
95	ret = trie_dict_set(p_dict, keys[i], TEST_VAL >> i);
96	if (ret != 1)
97	{
98	printf("Set non-existing [%s] error (%d)\n", keys[i], ret);
99	}
100	}
101
102	for (int i = 0; i < keys_cnt; i++)
103	{
104	ret = trie_dict_get(p_dict, keys[i], &value);
105	if (ret != 1)
106	{
107	printf("Get [%s] error (%d)\n", keys[i], ret);
108	}
109	else if (value != TEST_VAL >> i)
110	{
111	printf("Value of [%s] is incorrect (%ld != %ld)\n", keys[i], value, TEST_VAL >> i);
112	}
113	}
114
115	trie_dict_traverse(p_dict, test_traverse_cb);
116
117	for (int i = 0; i < keys_cnt; i++)
118	{
119	if (i % 2 == 0)
120	{
121	ret = trie_dict_del(p_dict, keys[i]);
122	if (ret != 1)
123	{
124	printf("Del existing [%s] error (%d)\n", keys[i], ret);
125	}
126	}
127	else
128	{
129	ret = trie_dict_set(p_dict, keys[i], TEST_VAL >> i);
130	if (ret != 0)
131	{
132	printf("Set existing [%s] with the same value error (%d)\n", keys[i], ret);
133	}
134	}
135	}
136
137	for (int i = 0; i < keys_cnt; i++)
138	{
139	if (i % 2 == 0)
140	{
141	ret = trie_dict_get(p_dict, keys[i], &value);
142	if (ret != 0)
143	{
144	printf("Get non-existing [%s] error (%d)\n", keys[i], ret);
145	}
146	}
147	else
148	{
149	ret = trie_dict_get(p_dict, keys[i], &value);
150	if (ret != 1)
151	{
152	printf("Get [%s] error (%d)\n", keys[i], ret);
153	}
154	else if (value != TEST_VAL >> i)
155	{
156	printf("Value of [%s] is incorrect (%ld != %ld)\n", keys[i], value, TEST_VAL >> i);
157	}
158	}
159	}
160
161	for (int i = 0; i < keys_cnt; i++)
162	{
163	if (i % 2 == 0)
164	{
165	ret = trie_dict_del(p_dict, keys[i]);
166	if (ret != 0)
167	{
168	printf("Del non-existing [%s] error (%d)\n", keys[i], ret);
169	}
170	}
171	else
172	{
173	ret = trie_dict_set(p_dict, keys[i], TEST_VAL << i);
174	if (ret != 1)
175	{
176	printf("Set existing [%s] with different value error (%d)\n", keys[i], ret);
177	}
178	}
179	}
180
181	trie_dict_traverse(p_dict, test_traverse_cb);
182
183	for (int i = 0; i < keys_cnt; i++)
184	{
185	if (i % 2 == 0)
186	{
187	ret = trie_dict_get(p_dict, keys[i], &value);
188	if (ret != 0)
189	{
190	printf("Get non-existing [%s] error (%d)\n", keys[i], ret);
191	}
192	}
193	else
194	{
195	ret = trie_dict_get(p_dict, keys[i], &value);
196	if (ret != 1)
197	{
198	printf("Get [%s] error (%d)\n", keys[i], ret);
199	}
200	else if (value != TEST_VAL << i)
201	{
202	printf("Value of [%s] is incorrect (%ld != %ld)\n", keys[i], value, TEST_VAL << i);
203	}
204	}
205	}
206
207	printf("Total nodes used = %d\n", trie_dict_used_nodes());
208
209	trie_dict_destroy(p_dict);
210	p_dict = NULL;
211
212	printf("Total nodes used = %d\n", trie_dict_used_nodes());
213
214	printf("Testing #2 ...\n");
215
216	for (int i = 0; i < 100000; i++)
217	{
218	p_dict = trie_dict_create();
219
220	if (p_dict == NULL)
221	{
222	printf("OOM\n");
223	return -1;
224	}
225
226	trie_dict_destroy(p_dict);
227	p_dict = NULL;
228	}
229
230	printf("Testing #3 ...\n");
231
232	if (set_trie_dict_shm_readonly() < 0)
233	{
234	printf("load_trie_dict_shm_readonly() error\n");
235	}
236
237	// if (unload_trie_dict_shm() < 0)
238	// {
239	// printf("unload_trie_dict_shm() error\n");
240	// }
241
242	printf("Total nodes used = %d, after set_shm_readonly\n", trie_dict_used_nodes());
243
244	trie_dict_cleanup();
245
246	printf("Total nodes used = %d, after cleanup\n", trie_dict_used_nodes());
247
248	printf("Done\n");
249
250	if (unlink(TRIE_DICT_SHM_FILE) < 0)
251	{
252	log_error("unlink(%s) error\n", TRIE_DICT_SHM_FILE);
253	return -1;
254	}
255
256	log_end();
257
258	return 0;
259	}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1