source: branches/samhain_3_1/src/cutest_zAVLTree.c@ 480

Last change on this file since 480 was 452, checked in by katerina, 10 years ago

Fix for ticket #353 (multiple exclusions for SUID check).
File size: 16.1 KB
Line 
1
2#include "config_xor.h"
3
4#include <string.h>
5#include "CuTest.h"
6#include "zAVLTree.h"
7
8struct ztest {
9 char name[32];
10 int iname;
11};
12
13static zAVLTree * ztest_tree = NULL;
14
15static zAVLKey ztest_key (void const * arg)
16{
17 const struct ztest * sa = (const struct ztest *) arg;
18 return (zAVLKey) sa->name;
19}
20
21static zAVLKey ztest_intkey(void const *item)
22{
23 return (&((struct ztest *)item)->iname);
24}
25
26
27static void free_node (void * inptr)
28{
29 struct ztest * ptr = (struct ztest *) inptr;
30 ptr->name[0] = '\0';
31 ptr->iname = 0;
32}
33
34void Test_zAVLTree(CuTest *tc) {
35 zAVLCursor cursor;
36
37 int result;
38 int counter = 0;
39
40 char * str;
41
42 struct ztest z1 = { "abc" , 1 };
43 struct ztest z2 = { "aac" , 2 };
44 struct ztest z3 = { "aaa1" , 3 };
45 struct ztest z4 = { "aaa3" , 4 };
46 struct ztest z5 = { "aaa2" , 5 };
47 struct ztest z6 = { "aaa6" , 6 };
48 struct ztest z7 = { "aaa5" , 7 };
49 struct ztest z8 = { "aaa4" , 8 };
50
51 struct ztest iz1 = { "aaa1" , 8 };
52 struct ztest iz2 = { "aaa2" , 7 };
53 struct ztest iz3 = { "aaa3" , 1 };
54 struct ztest iz4 = { "aaa4" , 3 };
55 struct ztest iz5 = { "aaa5" , 2 };
56 struct ztest iz6 = { "aaa5" , 6 };
57 struct ztest iz7 = { "aaa7" , 5 };
58 struct ztest iz8 = { "aaa8" , 4 };
59
60 struct ztest * ptr;
61
62 ptr = zAVLFirst(&cursor, ztest_tree);
63 CuAssertTrue(tc, NULL == ptr);
64
65 ztest_tree = zAVLAllocTree (ztest_key, zAVL_KEY_STRING);
66 CuAssertPtrNotNull(tc, ztest_tree);
67
68 do {
69
70 ++counter;
71
72 result = zAVLInsert(ztest_tree, &z1);
73 CuAssertTrue(tc, 0 == result);
74 result = zAVLInsert(ztest_tree, &z2);
75 CuAssertTrue(tc, 0 == result);
76 result = zAVLInsert(ztest_tree, &z3);
77 CuAssertTrue(tc, 0 == result);
78 result = zAVLInsert(ztest_tree, &z4);
79 CuAssertTrue(tc, 0 == result);
80 result = zAVLInsert(ztest_tree, &z5);
81 CuAssertTrue(tc, 0 == result);
82 result = zAVLInsert(ztest_tree, &z6);
83 CuAssertTrue(tc, 0 == result);
84 result = zAVLInsert(ztest_tree, &z7);
85 CuAssertTrue(tc, 0 == result);
86 result = zAVLInsert(ztest_tree, &z8);
87 CuAssertTrue(tc, 0 == result);
88
89 ptr = zAVLFirst(&cursor, ztest_tree);
90 CuAssertStrEquals(tc, ptr->name, z3.name);
91 ptr = zAVLNext(&cursor);
92 CuAssertStrEquals(tc, ptr->name, z5.name);
93 ptr = zAVLNext(&cursor);
94 CuAssertStrEquals(tc, ptr->name, z4.name);
95 ptr = zAVLNext(&cursor);
96 CuAssertStrEquals(tc, ptr->name, z8.name);
97 ptr = zAVLNext(&cursor);
98 CuAssertStrEquals(tc, ptr->name, z7.name);
99 ptr = zAVLNext(&cursor);
100 CuAssertStrEquals(tc, ptr->name, z6.name);
101 ptr = zAVLNext(&cursor);
102 CuAssertStrEquals(tc, ptr->name, z2.name);
103 ptr = zAVLNext(&cursor);
104 CuAssertStrEquals(tc, ptr->name, z1.name);
105 ptr = zAVLNext(&cursor);
106 CuAssertTrue(tc, NULL == ptr);
107
108 result = zAVLInsert(ztest_tree, &z8);
109 CuAssertTrue(tc, 0 != result);
110 result = zAVLInsert(ztest_tree, &z7);
111 CuAssertTrue(tc, 0 != result);
112 result = zAVLInsert(ztest_tree, &z6);
113 CuAssertTrue(tc, 0 != result);
114 result = zAVLInsert(ztest_tree, &z5);
115 CuAssertTrue(tc, 0 != result);
116
117 ptr = zAVLSearch(ztest_tree, z1.name);
118 CuAssertStrEquals(tc, ptr->name, z1.name);
119 ptr = zAVLSearch(ztest_tree, z2.name);
120 CuAssertStrEquals(tc, ptr->name, z2.name);
121 ptr = zAVLSearch(ztest_tree, z3.name);
122 CuAssertStrEquals(tc, ptr->name, z3.name);
123 ptr = zAVLSearch(ztest_tree, z4.name);
124 CuAssertStrEquals(tc, ptr->name, z4.name);
125
126 ptr = zAVLFirst(&cursor, ztest_tree);
127 CuAssertStrEquals(tc, ptr->name, z3.name);
128 ptr = zAVLNext(&cursor);
129 CuAssertStrEquals(tc, ptr->name, z5.name);
130 ptr = zAVLNext(&cursor);
131 CuAssertStrEquals(tc, ptr->name, z4.name);
132 ptr = zAVLNext(&cursor);
133 CuAssertStrEquals(tc, ptr->name, z8.name);
134 ptr = zAVLNext(&cursor);
135 CuAssertStrEquals(tc, ptr->name, z7.name);
136 ptr = zAVLNext(&cursor);
137 CuAssertStrEquals(tc, ptr->name, z6.name);
138 ptr = zAVLNext(&cursor);
139 CuAssertStrEquals(tc, ptr->name, z2.name);
140 ptr = zAVLNext(&cursor);
141 CuAssertStrEquals(tc, ptr->name, z1.name);
142 ptr = zAVLNext(&cursor);
143 CuAssertTrue(tc, NULL == ptr);
144
145
146 ptr = zAVLSearch(ztest_tree, z5.name);
147 CuAssertStrEquals(tc, ptr->name, z5.name);
148 ptr = zAVLSearch(ztest_tree, z6.name);
149 CuAssertStrEquals(tc, ptr->name, z6.name);
150 ptr = zAVLSearch(ztest_tree, z7.name);
151 CuAssertStrEquals(tc, ptr->name, z7.name);
152 ptr = zAVLSearch(ztest_tree, z8.name);
153 CuAssertStrEquals(tc, ptr->name, z8.name);
154 ptr = zAVLSearch(ztest_tree, "foobar");
155 CuAssertTrue(tc, NULL == ptr);
156
157 result = zAVLDelete(ztest_tree, z8.name);
158 CuAssertTrue(tc, 0 == result);
159 ptr = zAVLSearch(ztest_tree, z8.name);
160 CuAssertTrue(tc, NULL == ptr);
161
162 result = zAVLDelete(ztest_tree, z3.name);
163 CuAssertTrue(tc, 0 == result);
164 ptr = zAVLSearch(ztest_tree, z3.name);
165 CuAssertTrue(tc, NULL == ptr);
166
167 result = zAVLDelete(ztest_tree, z1.name);
168 CuAssertTrue(tc, 0 == result);
169 ptr = zAVLSearch(ztest_tree, z1.name);
170 CuAssertTrue(tc, NULL == ptr);
171
172 result = zAVLInsert(ztest_tree, &z1);
173 CuAssertTrue(tc, 0 == result);
174 result = zAVLInsert(ztest_tree, &z8);
175 CuAssertTrue(tc, 0 == result);
176 result = zAVLInsert(ztest_tree, &z3);
177 CuAssertTrue(tc, 0 == result);
178
179 ptr = zAVLFirst(&cursor, ztest_tree);
180 CuAssertStrEquals(tc, ptr->name, z3.name);
181 ptr = zAVLNext(&cursor);
182 CuAssertStrEquals(tc, ptr->name, z5.name);
183 ptr = zAVLNext(&cursor);
184 CuAssertStrEquals(tc, ptr->name, z4.name);
185 ptr = zAVLNext(&cursor);
186 CuAssertStrEquals(tc, ptr->name, z8.name);
187 ptr = zAVLNext(&cursor);
188 CuAssertStrEquals(tc, ptr->name, z7.name);
189 ptr = zAVLNext(&cursor);
190 CuAssertStrEquals(tc, ptr->name, z6.name);
191 ptr = zAVLNext(&cursor);
192 CuAssertStrEquals(tc, ptr->name, z2.name);
193 ptr = zAVLNext(&cursor);
194 CuAssertStrEquals(tc, ptr->name, z1.name);
195 ptr = zAVLNext(&cursor);
196 CuAssertTrue(tc, NULL == ptr);
197
198 result = zAVLDelete(ztest_tree, z1.name);
199 CuAssertTrue(tc, 0 == result);
200 ptr = zAVLSearch(ztest_tree, z1.name);
201 CuAssertTrue(tc, NULL == ptr);
202
203 result = zAVLDelete(ztest_tree, z2.name);
204 CuAssertTrue(tc, 0 == result);
205 ptr = zAVLSearch(ztest_tree, z2.name);
206 CuAssertTrue(tc, NULL == ptr);
207
208 result = zAVLDelete(ztest_tree, z3.name);
209 CuAssertTrue(tc, 0 == result);
210 ptr = zAVLSearch(ztest_tree, z3.name);
211 CuAssertTrue(tc, NULL == ptr);
212
213 result = zAVLDelete(ztest_tree, z4.name);
214 CuAssertTrue(tc, 0 == result);
215 ptr = zAVLSearch(ztest_tree, z4.name);
216 CuAssertTrue(tc, NULL == ptr);
217
218 result = zAVLDelete(ztest_tree, z5.name);
219 CuAssertTrue(tc, 0 == result);
220 ptr = zAVLSearch(ztest_tree, z5.name);
221 CuAssertTrue(tc, NULL == ptr);
222
223 result = zAVLDelete(ztest_tree, z6.name);
224 CuAssertTrue(tc, 0 == result);
225 ptr = zAVLSearch(ztest_tree, z6.name);
226 CuAssertTrue(tc, NULL == ptr);
227
228 result = zAVLDelete(ztest_tree, z7.name);
229 CuAssertTrue(tc, 0 == result);
230 ptr = zAVLSearch(ztest_tree, z7.name);
231 CuAssertTrue(tc, NULL == ptr);
232
233 result = zAVLDelete(ztest_tree, z8.name);
234 CuAssertTrue(tc, 0 == result);
235 ptr = zAVLSearch(ztest_tree, z8.name);
236 CuAssertTrue(tc, NULL == ptr);
237
238} while (counter < 100);
239
240 result = zAVLInsert(ztest_tree, &z1);
241 CuAssertTrue(tc, 0 == result);
242 result = zAVLInsert(ztest_tree, &z2);
243 CuAssertTrue(tc, 0 == result);
244 result = zAVLInsert(ztest_tree, &z3);
245 CuAssertTrue(tc, 0 == result);
246 result = zAVLInsert(ztest_tree, &z4);
247 CuAssertTrue(tc, 0 == result);
248 result = zAVLInsert(ztest_tree, &z5);
249 CuAssertTrue(tc, 0 == result);
250 result = zAVLInsert(ztest_tree, &z6);
251 CuAssertTrue(tc, 0 == result);
252 result = zAVLInsert(ztest_tree, &z7);
253 CuAssertTrue(tc, 0 == result);
254 result = zAVLInsert(ztest_tree, &z8);
255 CuAssertTrue(tc, 0 == result);
256
257 zAVLFreeTree (ztest_tree, free_node);
258 CuAssertTrue (tc, z1.name[0] == '\0');
259 CuAssertTrue (tc, z2.name[0] == '\0');
260 CuAssertTrue (tc, z3.name[0] == '\0');
261 CuAssertTrue (tc, z4.name[0] == '\0');
262 CuAssertTrue (tc, z5.name[0] == '\0');
263 CuAssertTrue (tc, z6.name[0] == '\0');
264 CuAssertTrue (tc, z7.name[0] == '\0');
265 CuAssertTrue (tc, z8.name[0] == '\0');
266
267
268 /* Numeric key here */
269
270 counter = 0;
271 ztest_tree = NULL;
272
273 ptr = zAVLFirst(&cursor, ztest_tree);
274 CuAssertTrue(tc, NULL == ptr);
275
276 ztest_tree = zAVLAllocTree (ztest_intkey, zAVL_KEY_INT);
277 CuAssertPtrNotNull(tc, ztest_tree);
278
279 do {
280
281 ++counter;
282
283 result = zAVLInsert(ztest_tree, &iz1);
284 CuAssertTrue(tc, 0 == result);
285 result = zAVLInsert(ztest_tree, &iz2);
286 CuAssertTrue(tc, 0 == result);
287 result = zAVLInsert(ztest_tree, &iz3);
288 CuAssertTrue(tc, 0 == result);
289 result = zAVLInsert(ztest_tree, &iz4);
290 CuAssertTrue(tc, 0 == result);
291 result = zAVLInsert(ztest_tree, &iz5);
292 CuAssertTrue(tc, 0 == result);
293 result = zAVLInsert(ztest_tree, &iz6);
294 CuAssertTrue(tc, 0 == result);
295 result = zAVLInsert(ztest_tree, &iz7);
296 CuAssertTrue(tc, 0 == result);
297 result = zAVLInsert(ztest_tree, &iz8);
298 CuAssertTrue(tc, 0 == result);
299
300 ptr = zAVLFirst(&cursor, ztest_tree);
301 CuAssertStrEquals(tc, ptr->name, iz3.name);
302 ptr = zAVLNext(&cursor);
303 CuAssertStrEquals(tc, ptr->name, iz5.name);
304 ptr = zAVLNext(&cursor);
305 CuAssertStrEquals(tc, ptr->name, iz4.name);
306 ptr = zAVLNext(&cursor);
307 CuAssertStrEquals(tc, ptr->name, iz8.name);
308 ptr = zAVLNext(&cursor);
309 CuAssertStrEquals(tc, ptr->name, iz7.name);
310 ptr = zAVLNext(&cursor);
311 CuAssertStrEquals(tc, ptr->name, iz6.name);
312 ptr = zAVLNext(&cursor);
313 CuAssertStrEquals(tc, ptr->name, iz2.name);
314 ptr = zAVLNext(&cursor);
315 CuAssertStrEquals(tc, ptr->name, iz1.name);
316 ptr = zAVLNext(&cursor);
317 CuAssertTrue(tc, NULL == ptr);
318
319 result = zAVLInsert(ztest_tree, &iz8);
320 CuAssertTrue(tc, 0 != result);
321 result = zAVLInsert(ztest_tree, &iz7);
322 CuAssertTrue(tc, 0 != result);
323 result = zAVLInsert(ztest_tree, &iz6);
324 CuAssertTrue(tc, 0 != result);
325 result = zAVLInsert(ztest_tree, &iz5);
326 CuAssertTrue(tc, 0 != result);
327
328 ptr = zAVLSearch(ztest_tree, &(iz1.iname));
329 CuAssertIntEquals(tc, ptr->iname, iz1.iname);
330 ptr = zAVLSearch(ztest_tree, &(iz2.iname));
331 CuAssertIntEquals(tc, ptr->iname, iz2.iname);
332 ptr = zAVLSearch(ztest_tree, &(iz3.iname));
333 CuAssertIntEquals(tc, ptr->iname, iz3.iname);
334 ptr = zAVLSearch(ztest_tree, &(iz6.iname));
335 CuAssertIntEquals(tc, ptr->iname, iz6.iname);
336 ptr = zAVLSearch(ztest_tree, &(iz4.iname));
337 CuAssertIntEquals(tc, ptr->iname, iz4.iname);
338
339 ptr = zAVLSearch(ztest_tree, &(iz2.iname));
340 CuAssertIntEquals(tc, ptr->iname, iz2.iname);
341 ptr = zAVLSearch(ztest_tree, &(iz3.iname));
342 CuAssertIntEquals(tc, ptr->iname, iz3.iname);
343 ptr = zAVLSearch(ztest_tree, &(iz7.iname));
344 CuAssertIntEquals(tc, ptr->iname, iz7.iname);
345
346 ptr = zAVLFirst(&cursor, ztest_tree);
347 CuAssertStrEquals(tc, ptr->name, iz3.name);
348 ptr = zAVLNext(&cursor);
349 CuAssertStrEquals(tc, ptr->name, iz5.name);
350 ptr = zAVLNext(&cursor);
351 CuAssertStrEquals(tc, ptr->name, iz4.name);
352 ptr = zAVLNext(&cursor);
353 CuAssertStrEquals(tc, ptr->name, iz8.name);
354 ptr = zAVLNext(&cursor);
355 CuAssertStrEquals(tc, ptr->name, iz7.name);
356 ptr = zAVLNext(&cursor);
357 CuAssertStrEquals(tc, ptr->name, iz6.name);
358 ptr = zAVLNext(&cursor);
359 CuAssertStrEquals(tc, ptr->name, iz2.name);
360 ptr = zAVLNext(&cursor);
361 CuAssertStrEquals(tc, ptr->name, iz1.name);
362 ptr = zAVLNext(&cursor);
363 CuAssertTrue(tc, NULL == ptr);
364
365
366 ptr = zAVLSearch(ztest_tree, &(iz5.iname));
367 CuAssertStrEquals(tc, ptr->name, iz5.name);
368 ptr = zAVLSearch(ztest_tree, &(iz6.iname));
369 CuAssertStrEquals(tc, ptr->name, iz6.name);
370 ptr = zAVLSearch(ztest_tree, &(iz7.iname));
371 CuAssertStrEquals(tc, ptr->name, iz7.name);
372 ptr = zAVLSearch(ztest_tree, &(iz8.iname));
373 CuAssertStrEquals(tc, ptr->name, iz8.name);
374 ptr = zAVLSearch(ztest_tree, &(z1.iname)); /* been set to 0 */
375 CuAssertTrue(tc, NULL == ptr);
376
377 result = zAVLDelete(ztest_tree, &(iz8.iname));
378 CuAssertTrue(tc, 0 == result);
379 ptr = zAVLSearch(ztest_tree, &(iz8.iname));
380 CuAssertTrue(tc, NULL == ptr);
381
382 result = zAVLDelete(ztest_tree, &(iz3.iname));
383 CuAssertTrue(tc, 0 == result);
384 ptr = zAVLSearch(ztest_tree, &(iz3.iname));
385 CuAssertTrue(tc, NULL == ptr);
386
387 result = zAVLDelete(ztest_tree, &(iz1.iname));
388 CuAssertTrue(tc, 0 == result);
389 ptr = zAVLSearch(ztest_tree, &(iz1.iname));
390 CuAssertTrue(tc, NULL == ptr);
391
392 result = zAVLInsert(ztest_tree, &iz1);
393 CuAssertTrue(tc, 0 == result);
394 result = zAVLInsert(ztest_tree, &iz8);
395 CuAssertTrue(tc, 0 == result);
396 result = zAVLInsert(ztest_tree, &iz3);
397 CuAssertTrue(tc, 0 == result);
398
399 ptr = zAVLFirst(&cursor, ztest_tree);
400 CuAssertIntEquals(tc, ptr->iname, iz3.iname);
401 ptr = zAVLNext(&cursor);
402 CuAssertStrEquals(tc, ptr->name, iz5.name);
403 ptr = zAVLNext(&cursor);
404 CuAssertStrEquals(tc, ptr->name, iz4.name);
405 ptr = zAVLNext(&cursor);
406 CuAssertIntEquals(tc, ptr->iname, iz8.iname);
407 ptr = zAVLNext(&cursor);
408 CuAssertStrEquals(tc, ptr->name, iz7.name);
409 ptr = zAVLNext(&cursor);
410 CuAssertStrEquals(tc, ptr->name, iz6.name);
411 ptr = zAVLNext(&cursor);
412 CuAssertIntEquals(tc, ptr->iname, iz2.iname);
413 ptr = zAVLNext(&cursor);
414 CuAssertStrEquals(tc, ptr->name, iz1.name);
415 ptr = zAVLNext(&cursor);
416 CuAssertTrue(tc, NULL == ptr);
417
418 result = zAVLDelete(ztest_tree, &(iz1.iname));
419 CuAssertTrue(tc, 0 == result);
420 ptr = zAVLSearch(ztest_tree, &(iz1.iname));
421 CuAssertTrue(tc, NULL == ptr);
422
423 result = zAVLDelete(ztest_tree, &(iz2.iname));
424 CuAssertTrue(tc, 0 == result);
425 ptr = zAVLSearch(ztest_tree, &(iz2.iname));
426 CuAssertTrue(tc, NULL == ptr);
427
428 result = zAVLDelete(ztest_tree, &(iz3.iname));
429 CuAssertTrue(tc, 0 == result);
430 ptr = zAVLSearch(ztest_tree, &(iz3.iname));
431 CuAssertTrue(tc, NULL == ptr);
432
433 result = zAVLDelete(ztest_tree, &(iz4.iname));
434 CuAssertTrue(tc, 0 == result);
435 ptr = zAVLSearch(ztest_tree, &(iz4.iname));
436 CuAssertTrue(tc, NULL == ptr);
437
438 result = zAVLDelete(ztest_tree, &(iz5.iname));
439 CuAssertTrue(tc, 0 == result);
440 ptr = zAVLSearch(ztest_tree, &(iz5.iname));
441 CuAssertTrue(tc, NULL == ptr);
442
443 result = zAVLDelete(ztest_tree, &(iz6.iname));
444 CuAssertTrue(tc, 0 == result);
445 ptr = zAVLSearch(ztest_tree, &(iz6.iname));
446 CuAssertTrue(tc, NULL == ptr);
447
448 result = zAVLDelete(ztest_tree, &(iz7.iname));
449 CuAssertTrue(tc, 0 == result);
450 ptr = zAVLSearch(ztest_tree, &(iz7.iname));
451 CuAssertTrue(tc, NULL == ptr);
452
453 result = zAVLDelete(ztest_tree, &(iz8.iname));
454 CuAssertTrue(tc, 0 == result);
455 ptr = zAVLSearch(ztest_tree, &(iz8.iname));
456 CuAssertTrue(tc, NULL == ptr);
457
458} while (counter < 100);
459
460 result = zAVLInsert(ztest_tree, &iz1);
461 CuAssertTrue(tc, 0 == result);
462 result = zAVLInsert(ztest_tree, &iz2);
463 CuAssertTrue(tc, 0 == result);
464 result = zAVLInsert(ztest_tree, &iz3);
465 CuAssertTrue(tc, 0 == result);
466 result = zAVLInsert(ztest_tree, &iz4);
467 CuAssertTrue(tc, 0 == result);
468 result = zAVLInsert(ztest_tree, &iz5);
469 CuAssertTrue(tc, 0 == result);
470 result = zAVLInsert(ztest_tree, &iz6);
471 CuAssertTrue(tc, 0 == result);
472 result = zAVLInsert(ztest_tree, &iz7);
473 CuAssertTrue(tc, 0 == result);
474 result = zAVLInsert(ztest_tree, &iz8);
475 CuAssertTrue(tc, 0 == result);
476
477 zAVLFreeTree (ztest_tree, free_node);
478 CuAssertTrue (tc, iz1.iname == 0);
479 CuAssertTrue (tc, iz2.iname == 0);
480 CuAssertTrue (tc, iz3.iname == 0);
481 CuAssertTrue (tc, iz4.iname == 0);
482 CuAssertTrue (tc, iz5.iname == 0);
483 CuAssertTrue (tc, iz6.iname == 0);
484 CuAssertTrue (tc, iz7.iname == 0);
485 CuAssertTrue (tc, iz8.iname == 0);
486
487 ztest_tree = NULL;
488 str = strdup("foo");
489 result = zAVL_string_set(&ztest_tree, str);
490 CuAssertTrue(tc, 0 == result);
491 CuAssertPtrNotNull(tc, ztest_tree);
492 CuAssertStrEquals(tc, "foo", zAVL_string_get(ztest_tree, "foo"));
493
494 str = strdup("bar");
495 result = zAVL_string_set(&ztest_tree, str);
496 CuAssertTrue(tc, 0 == result);
497 CuAssertStrEquals(tc, "foo", zAVL_string_get(ztest_tree, "foo"));
498 CuAssertStrEquals(tc, "bar", zAVL_string_get(ztest_tree, "bar"));
499
500 str = strdup("balloon");
501 result = zAVL_string_set(&ztest_tree, str);
502 CuAssertTrue(tc, 0 == result);
503 CuAssertStrEquals(tc, "foo", zAVL_string_get(ztest_tree, "foo"));
504 CuAssertStrEquals(tc, "bar", zAVL_string_get(ztest_tree, "bar"));
505 CuAssertStrEquals(tc, "balloon", zAVL_string_get(ztest_tree, "balloon"));
506
507 str = zAVL_string_get(ztest_tree, "foobar");
508 CuAssertTrue(tc, str == NULL);
509 str = zAVL_string_get(ztest_tree, "");
510 CuAssertTrue(tc, str == NULL);
511 str = zAVL_string_get(ztest_tree, NULL);
512 CuAssertTrue(tc, str == NULL);
513
514 zAVL_string_reset(ztest_tree);
515 str = zAVL_string_get(ztest_tree, "foo");
516 CuAssertTrue(tc, str == NULL);
517 str = zAVL_string_get(ztest_tree, "bar");
518 CuAssertTrue(tc, str == NULL);
519 str = zAVL_string_get(ztest_tree, "balloon");
520 CuAssertTrue(tc, str == NULL);
521
522}
Note: See TracBrowser for help on using the repository browser.