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	sysadm	1.12	/* SPDX-License-Identifier: GPL-3.0-or-later */
2			/*
3			* test_trie_dict
4			* - tester for trie-tree based dict feature
5			*
6	sysadm	1.13	* Copyright (C) 2004-2025 Leaflet <leaflet@leafok.com>
7	sysadm	1.12	*/
8	sysadm	1.1
9	sysadm	1.10	#include "log.h"
10	sysadm	1.1	#include "trie_dict.h"
11	sysadm	1.10	#include <errno.h>
12	sysadm	1.1	#include <stdio.h>
13	sysadm	1.3	#include <string.h>
14	sysadm	1.7	#include <unistd.h>
15	sysadm	1.1
16	sysadm	1.14	static const int64_t TEST_VAL = ((int64_t)(0xcb429a63a017661f)); // int64_t
17			static const char TRIE_DICT_SHM_FILE[] = "~trie_dict_shm.dat";
18	sysadm	1.1
19			const char *keys[] = {
20			"ABCDEFG",
21			"abcdefg",
22	sysadm	1.3	"../$@^",
23	sysadm	1.1	"1234567890",
24	sysadm	1.3	"1234657890",
25	sysadm	1.11	"HZ测试汉字HZ",
26	sysadm	1.1	"P3p4P3z4P_",
27			"_bbBBz_Z_",
28			""};
29
30	sysadm	1.7	int keys_cnt = 8; // + 1 to trigger error handling of blank key
31	sysadm	1.1
32	sysadm	1.4	void test_traverse_cb(const char *key, int64_t value)
33	sysadm	1.2	{
34	sysadm	1.3	printf("Traverse key: %s Len=%ld\n", key, strlen(key));
35	sysadm	1.2	}
36
37	sysadm	1.1	int main(int argc, char *argv[])
38			{
39			TRIE_NODE *p_dict;
40			int ret;
41			int64_t value;
42	sysadm	1.7	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	sysadm	1.9	log_common_redir(STDOUT_FILENO);
51			log_error_redir(STDERR_FILENO);
52	sysadm	1.7
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	sysadm	1.1
60	sysadm	1.3	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	sysadm	1.8	if (trie_dict_init(TRIE_DICT_SHM_FILE, TRIE_NODE_PER_POOL) < 0)
66	sysadm	1.7	{
67			printf("trie_dict_init failed\n");
68			return -1;
69			}
70
71			printf("Testing #1 ...\n");
72
73	sysadm	1.1	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	sysadm	1.2	trie_dict_traverse(p_dict, test_traverse_cb);
116
117	sysadm	1.1	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	sysadm	1.2	trie_dict_traverse(p_dict, test_traverse_cb);
182
183	sysadm	1.1	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	sysadm	1.8	printf("Total nodes used = %d\n", trie_dict_used_nodes());
208
209	sysadm	1.1	trie_dict_destroy(p_dict);
210	sysadm	1.6	p_dict = NULL;
211	sysadm	1.1
212	sysadm	1.8	printf("Total nodes used = %d\n", trie_dict_used_nodes());
213
214	sysadm	1.7	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	sysadm	1.8	printf("Total nodes used = %d, after set_shm_readonly\n", trie_dict_used_nodes());
243
244	sysadm	1.7	trie_dict_cleanup();
245
246	sysadm	1.8	printf("Total nodes used = %d, after cleanup\n", trie_dict_used_nodes());
247
248	sysadm	1.1	printf("Done\n");
249
250	sysadm	1.7	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	sysadm	1.1	return 0;
259			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1