Debian Codegraph @

check/internal-tests/coll_t.c

raw
1 /*
2 * FCML - Free Code Manipulation Library.
3 * Copyright (C) 2010-2020 Slawomir Wojtasiak
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 #include "coll_t.h"
21
22 #include <fcml_coll.h>
23
24 fcml_ptr last_free_key;
25 fcml_ptr last_free_value;
26
27 void fcml_itf_coll_map_entry_handler_test( fcml_ptr key, fcml_ptr value, fcml_ptr args ) {
28 last_free_key = key;
29 last_free_value = value;
30 }
31
32 fcml_bool fcml_tf_coll_suite_init(void) {
33 return FCML_TRUE;
34 }
35
36 fcml_bool fcml_tf_coll_suite_cleanup(void) {
37 return FCML_TRUE;
38 }
39
40 void fcml_tf_coll_test_put_the_same_key(void) {
41
42 fcml_int error = FCML_COLL_ERROR_NO_ERROR;
43
44 fcml_coll_map *map = fcml_fn_coll_map_alloc(&fcml_coll_map_descriptor_string, 10, &error );
45 if( map == NULL || error ) {
46 STF_FAIL( "Can not create hash map." );
47 } else {
48 fcml_fn_coll_map_put( map, "KEY_1", "VALUE_1", &error );
49 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_1" ), "VALUE_1" );
50 fcml_fn_coll_map_put( map, "KEY_1", "VALUE_2", &error );
51 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_1" ), "VALUE_2" );
52 fcml_fn_coll_map_put( map, "KEY_1", "VALUE_3", &error );
53 STF_ASSERT( fcml_fn_coll_map_size( map ) == 1 );
54 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_1" ), "VALUE_3" );
55 }
56
57 fcml_fn_coll_map_free( map );
58 }
59
60 void fcml_tf_coll_test_put_different_keys(void) {
61
62 fcml_int error = FCML_COLL_ERROR_NO_ERROR;
63
64 fcml_coll_map *map = fcml_fn_coll_map_alloc(&fcml_coll_map_descriptor_string, 10, &error );
65 if( map == NULL || error ) {
66 STF_FAIL( "Can not create hash map." );
67 } else {
68 /* index 1.*/
69 fcml_fn_coll_map_put( map, "KEY_A", "VALUE_A", &error );
70 /* Conflict, both of the following keys are conflicted, but take into account*/
71 /* that it depends on default built-in implementation of hashing function.*/
72 fcml_fn_coll_map_put( map, "KEY_B", "VALUE_B", &error );
73 fcml_fn_coll_map_put( map, "KEY_R", "VALUE_R", &error );
74 fcml_fn_coll_map_put( map, "KEY_C", "VALUE_C", &error );
75 fcml_fn_coll_map_put( map, "KEY_D", "VALUE_D", &error );
76 fcml_fn_coll_map_put( map, "KEY_E", "VALUE_E", &error );
77 fcml_fn_coll_map_put( map, "KEY_F", "VALUE_F", &error );
78 fcml_fn_coll_map_put( map, "KEY_G", "VALUE_G", &error );
79 fcml_fn_coll_map_put( map, "KEY_H", "VALUE_H", &error );
80 STF_ASSERT( fcml_fn_coll_map_size( map ) == 9 );
81 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_A" ), "VALUE_A" );
82 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_B" ), "VALUE_B" );
83 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_R" ), "VALUE_R" );
84 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_C" ), "VALUE_C" );
85 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_D" ), "VALUE_D" );
86 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_E" ), "VALUE_E" );
87 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_F" ), "VALUE_F" );
88 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_G" ), "VALUE_G" );
89 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_R" ), "VALUE_R" );
90 }
91
92 fcml_fn_coll_map_free( map );
93 }
94
95 void fcml_tf_coll_test_remove_keys(void) {
96
97 fcml_int error = FCML_COLL_ERROR_NO_ERROR;
98
99 fcml_st_coll_map_descriptor descriptor = fcml_coll_map_descriptor_string;
100 descriptor.entry_free_function = fcml_itf_coll_map_entry_handler_test;
101 fcml_coll_map *map = fcml_fn_coll_map_alloc(&descriptor, 10, &error );
102 if( map == NULL || error ) {
103 STF_FAIL( "Can not create hash map." );
104 } else {
105 /* index 1.*/
106 fcml_fn_coll_map_put( map, "KEY_A", "VALUE_A", &error );
107 /* Conflict, both of the following keys are conflicted, but take into account*/
108 /* that it depends on default builtin implementation of hashing function.*/
109 fcml_fn_coll_map_put( map, "KEY_B", "VALUE_B", &error );
110 fcml_fn_coll_map_put( map, "KEY_R", "VALUE_R", &error );
111 fcml_fn_coll_map_put( map, "KEY_C", "VALUE_C", &error );
112 fcml_fn_coll_map_put( map, "KEY_D", "VALUE_D", &error );
113 fcml_fn_coll_map_put( map, "KEY_E", "VALUE_E", &error );
114 fcml_fn_coll_map_put( map, "KEY_F", "VALUE_F", &error );
115 fcml_fn_coll_map_put( map, "KEY_G", "VALUE_G", &error );
116 fcml_fn_coll_map_put( map, "KEY_H", "VALUE_H", &error );
117 STF_ASSERT( fcml_fn_coll_map_size( map ) == 9 );
118 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_A" ), "VALUE_A" );
119 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_B" ), "VALUE_B" );
120 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_R" ), "VALUE_R" );
121 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_C" ), "VALUE_C" );
122 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_D" ), "VALUE_D" );
123 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_E" ), "VALUE_E" );
124 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_F" ), "VALUE_F" );
125 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_G" ), "VALUE_G" );
126 /* Remove KEY_A*/
127 fcml_fn_coll_map_remove( map, "KEY_A" );
128 /* Check if memory was freed.*/
129 STF_ASSERT_PTR_NOT_NULL( last_free_key );
130 STF_ASSERT_PTR_NOT_NULL( last_free_value );
131 if( last_free_key != NULL ) {
132 STF_ASSERT_STRING_EQUAL( last_free_key, "KEY_A" );
133 }
134 if( last_free_value != NULL ) {
135 STF_ASSERT_STRING_EQUAL( last_free_value, "VALUE_A" );
136 }
137 /* Check if KEY_A has been successfully removed.*/
138 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_A" ) );
139 STF_ASSERT( fcml_fn_coll_map_size( map ) == 8 );
140 /* Check if the rest of keys are still there.*/
141 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_B" ), "VALUE_B" );
142 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_R" ), "VALUE_R" );
143 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_C" ), "VALUE_C" );
144 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_D" ), "VALUE_D" );
145 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_E" ), "VALUE_E" );
146 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_F" ), "VALUE_F" );
147 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_G" ), "VALUE_G" );
148 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_H" ), "VALUE_H" );
149 /* Remove all keys.*/
150 fcml_fn_coll_map_remove( map, "KEY_B" );
151 fcml_fn_coll_map_remove( map, "KEY_R" );
152 fcml_fn_coll_map_remove( map, "KEY_C" );
153 fcml_fn_coll_map_remove( map, "KEY_D" );
154 fcml_fn_coll_map_remove( map, "KEY_E" );
155 fcml_fn_coll_map_remove( map, "KEY_F" );
156 fcml_fn_coll_map_remove( map, "KEY_G" );
157 fcml_fn_coll_map_remove( map, "KEY_H" );
158 /* And check if they have been removed as well.*/
159 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_B" ) );
160 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_R" ) );
161 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_C" ) );
162 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_D" ) );
163 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_E" ) );
164 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_F" ) );
165 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_G" ) );
166 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_H" ) );
167 STF_ASSERT( fcml_fn_coll_map_size( map ) == 0 );
168 }
169
170 fcml_fn_coll_map_free( map );
171 }
172
173
174 void fcml_tf_coll_test_clear(void) {
175
176 fcml_int error = FCML_COLL_ERROR_NO_ERROR;
177
178 fcml_st_coll_map_descriptor descriptor = fcml_coll_map_descriptor_string;
179 descriptor.entry_free_function = fcml_itf_coll_map_entry_handler_test;
180 fcml_coll_map *map = fcml_fn_coll_map_alloc(&descriptor, 10, &error );
181 if( map == NULL || error ) {
182 STF_FAIL( "Can not create hash map." );
183 } else {
184 /* index 1.*/
185 fcml_fn_coll_map_put( map, "KEY_A", "VALUE_A", &error );
186 /* Conflict, both of the following keys are conflicted, but take into account*/
187 /* that it depends on default builtin implementation of hashing function.*/
188 fcml_fn_coll_map_put( map, "KEY_B", "VALUE_B", &error );
189 fcml_fn_coll_map_put( map, "KEY_R", "VALUE_R", &error );
190 fcml_fn_coll_map_put( map, "KEY_C", "VALUE_C", &error );
191 fcml_fn_coll_map_put( map, "KEY_D", "VALUE_D", &error );
192 fcml_fn_coll_map_put( map, "KEY_E", "VALUE_E", &error );
193 fcml_fn_coll_map_put( map, "KEY_F", "VALUE_F", &error );
194 fcml_fn_coll_map_put( map, "KEY_G", "VALUE_G", &error );
195 fcml_fn_coll_map_put( map, "KEY_H", "VALUE_H", &error );
196 STF_ASSERT( fcml_fn_coll_map_size( map ) == 9 );
197 last_free_key = NULL;
198 last_free_value = NULL;
199 fcml_fn_coll_map_clear( map );
200 STF_ASSERT_PTR_NOT_NULL( last_free_key );
201 STF_ASSERT_PTR_NOT_NULL( last_free_value );
202 /* And check if they have been removed.*/
203 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_A" ) );
204 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_B" ) );
205 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_R" ) );
206 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_C" ) );
207 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_D" ) );
208 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_E" ) );
209 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_F" ) );
210 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_G" ) );
211 STF_ASSERT_PTR_NULL( fcml_fn_coll_map_get( map, "KEY_H" ) );
212 STF_ASSERT( fcml_fn_coll_map_size( map ) == 0 );
213 }
214
215 fcml_fn_coll_map_free( map );
216 }
217
218 int iterator_counter;
219
220 void fcml_itf_coll_test_iterate_handler( fcml_ptr key, fcml_ptr value, fcml_ptr args ) {
221 iterator_counter++;
222 }
223
224 void fcml_tf_coll_test_extend(void) {
225
226 iterator_counter = 0;
227
228 fcml_int error = FCML_COLL_ERROR_NO_ERROR;
229
230 fcml_coll_map *map = fcml_fn_coll_map_alloc(&fcml_coll_map_descriptor_string, 2, &error );
231 if( map == NULL || error ) {
232 STF_FAIL( "Can not create hash map." );
233 } else {
234 /* index 1.*/
235 fcml_fn_coll_map_put( map, "KEY_A", "VALUE_A", &error );
236 fcml_fn_coll_map_put( map, "KEY_B", "VALUE_B", &error );
237 fcml_fn_coll_map_put( map, "KEY_R", "VALUE_R", &error );
238 fcml_fn_coll_map_put( map, "KEY_C", "VALUE_C", &error );
239 fcml_fn_coll_map_put( map, "KEY_D", "VALUE_D", &error );
240 fcml_fn_coll_map_put( map, "KEY_E", "VALUE_E", &error );
241 fcml_fn_coll_map_put( map, "KEY_F", "VALUE_F", &error );
242 fcml_fn_coll_map_put( map, "KEY_G", "VALUE_G", &error );
243 fcml_fn_coll_map_put( map, "KEY_H", "VALUE_H", &error );
244 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_A" ), "VALUE_A" );
245 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_B" ), "VALUE_B" );
246 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_R" ), "VALUE_R" );
247 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_C" ), "VALUE_C" );
248 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_D" ), "VALUE_D" );
249 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_E" ), "VALUE_E" );
250 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_F" ), "VALUE_F" );
251 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_G" ), "VALUE_G" );
252 STF_ASSERT_STRING_EQUAL( fcml_fn_coll_map_get( map, "KEY_H" ), "VALUE_H" );
253 }
254
255 fcml_fn_coll_map_free( map );
256 }
257
258 fcml_stf_test_case fcml_ti_coll[] = {
259 { "fcml_tf_coll_test_put_the_same_key", fcml_tf_coll_test_put_the_same_key },
260 { "fcml_tf_coll_test_put_different_keys", fcml_tf_coll_test_put_different_keys },
261 { "fcml_tf_coll_test_remove_keys", fcml_tf_coll_test_remove_keys },
262 { "fcml_tf_coll_test_clear", fcml_tf_coll_test_clear },
263 { "fcml_tf_coll_test_extend", fcml_tf_coll_test_extend },
264 FCML_STF_NULL_TEST
265 };
266
267 fcml_stf_test_suite fcml_si_coll = {
268 "suite-fcml-coll", fcml_tf_coll_suite_init, fcml_tf_coll_suite_cleanup, fcml_ti_coll
269 };