1 
2 #include "config_xor.h"
3 
4 #include <string.h>
5 #include "CuTest.h"
6 #include "zAVLTree.h"
7 
8 struct ztest {
9   char name[32];
10   int  iname;
11 };
12 
13 static zAVLTree * ztest_tree   = NULL;
14 
ztest_key(void const * arg)15 static zAVLKey ztest_key (void const * arg)
16 {
17   const struct ztest * sa = (const struct ztest *) arg;
18   return (zAVLKey) sa->name;
19 }
20 
ztest_intkey(void const * item)21 static zAVLKey ztest_intkey(void const *item)
22 {
23   return (&((const struct ztest *)item)->iname);
24 }
25 
26 
free_node(void * inptr)27 static void free_node (void * inptr)
28 {
29   struct ztest * ptr = (struct ztest *) inptr;
30   ptr->name[0] = '\0';
31   ptr->iname   = 0;
32 }
33 
Test_zAVLTree(CuTest * tc)34 void 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   ztest_tree = NULL;
516   str = zAVL_string_get(ztest_tree, "foo");
517   CuAssertTrue(tc, str == NULL);
518   str = zAVL_string_get(ztest_tree, "bar");
519   CuAssertTrue(tc, str == NULL);
520   str = zAVL_string_get(ztest_tree, "balloon");
521   CuAssertTrue(tc, str == NULL);
522 
523 }
524