1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3 *
4 * Copyright 2026 Olaf Wintermann. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "pblock.h"
30
31 #include "../util/pblock.h"
32
33 #include <cx/hash_map.h>
34
35 CX_TEST(test_pblock_iterator) {
36 pool_handle_t *pool = pool_create();
37
38 CX_TEST_DO {
39 pblock *pb_empty_1 = pblock_create_pool(pool, 1);
40 pblock *pb_empty_2 = pblock_create_pool(pool, 2);
41 pblock *pb_empty_4 = pblock_create_pool(pool, 4);
42
43 pblock *pb_one_1 = pblock_create_pool(pool, 1);
44 pblock *pb_one_2 = pblock_create_pool(pool, 2);
45 pblock *pb_one_4 = pblock_create_pool(pool, 4);
46
47 pblock *pb_many_1 = pblock_create_pool(pool, 1);
48 pblock *pb_many_4 = pblock_create_pool(pool, 4);
49 pblock *pb_many_16 = pblock_create_pool(pool, 16);
50 pblock *pb_many_64 = pblock_create_pool(pool, 64);
51
52 pblock_nvinsert("mykey", "pb_one", pb_one_1);
53 pblock_nvinsert("mykey", "pb_one", pb_one_2);
54 pblock_nvinsert("mykey", "pb_one", pb_one_4);
55
56 pblock *pbs[4] = { pb_many_1, pb_many_4, pb_many_16, pb_many_64 };
57
58 for(int n=0;n<4;n++) {
59 pblock *p = pbs[n];
60 pblock_nvinsert("key1", "many1", p);
61 pblock_nvinsert("key2", "many2", p);
62 pblock_nvinsert("key3", "many3", p);
63 pblock_nvinsert("key4", "many4", p);
64 pblock_nvinsert("b_key5__long_key_X1", "many5", p);
65 pblock_nvinsert("c_key6__long_key_X2", "many6", p);
66 pblock_nvinsert("d_key7__long_key_X3", "many7", p);
67 pblock_nvinsert("e_key8__long_key_X4", "many8", p);
68 pblock_nvinsert("01_key9__very_long_key_test_X1", "many9", p);
69 pblock_nvinsert("12_keya__very_long_key_test_X20", "manya", p);
70 pblock_nvinsert("34_keyb__very_long_key_test_X300", "manyb", p);
71 pblock_nvinsert("56_keyc__very_long_key_test_X4000", "manyc", p);
72 pblock_nvinsert("78_keyd__very_long_key_test_X50000", "manyd", p);
73 }
74
75 int count;
76 CxIterator i;
77
78 // check empty pblocks
79 count = 0;
80 i = pblock_iterator(pb_empty_1);
81 cx_foreach(pb_entry*, entry, i) {
82 count++;
83 }
84 CX_TEST_ASSERT(count == 0);
85
86 count = 0;
87 i = pblock_iterator(pb_empty_2);
88 cx_foreach(pb_entry*, entry, i) {
89 count++;
90 }
91 CX_TEST_ASSERT(count == 0);
92
93 count = 0;
94 i = pblock_iterator(pb_empty_4);
95 cx_foreach(pb_entry*, entry, i) {
96 count++;
97 }
98 CX_TEST_ASSERT(count == 0);
99
100 // check pblocks with one element
101 pblock *pbs_one[3] = { pb_one_1, pb_one_2, pb_one_4 };
102 for(int n=0;n<3;n++) {
103 count = 0;
104 i = pblock_iterator(pbs_one[n]);
105 cx_foreach(pb_entry*, entry, i) {
106 count++;
107 CX_TEST_ASSERT(entry);
108 CX_TEST_ASSERT(entry->param);
109 CX_TEST_ASSERT(entry->param->name);
110 CX_TEST_ASSERT(entry->param->value);
111 CX_TEST_ASSERT(!strcmp(entry->param->name, "mykey"));
112 CX_TEST_ASSERT(!strcmp(entry->param->value, "pb_one"));
113 }
114 CX_TEST_ASSERT(count == 1);
115 }
116
117 // check pblocks with many elements
118 for(int n=0;n<4;n++) {
119 CxMap *map = cxHashMapCreate(NULL, CX_STORE_POINTERS, 64);
120
121 i = pblock_iterator(pbs[n]);
122 cx_foreach(pb_entry*, entry, i) {
123 CX_TEST_ASSERT(entry);
124 CX_TEST_ASSERT(entry->param);
125 CX_TEST_ASSERT(entry->param->name);
126 CX_TEST_ASSERT(entry->param->value);
127 cxMapPut(map, entry->param->name, entry->param->value);
128 }
129 CX_TEST_ASSERT(cxMapSize(map) == 13);
130
131 CxMapIterator mi = cxMapIterator(map);
132 cx_foreach(CxMapEntry*, entry, mi) {
133 cxmutstr key = cx_strdup(cx_strn(entry->key->data, entry->key->len));
134 char *pb_val = pblock_findval(key.ptr, pbs[n]);
135 free(key.ptr);
136 char *map_value = entry->value;
137 CX_TEST_ASSERT(!cx_strcmp(pb_val, map_value));
138 }
139 cxMapFree(map);
140 }
141 }
142
143 pool_destroy(pool);
144 }
145