lbbs/src/test_trie_dict.c

/***************************************************************************
                                          test_trie_dict.c  -  description
                                                         -------------------
        Copyright            : (C) 2004-2025 by Leaflet
        Email                : leaflet@leafok.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/

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

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