1: #include <string.h>
2: #include <libxml/parser.h>
3: #include <libxml/dict.h>
4:
5: /* #define WITH_PRINT */
6:
7: static const char *seeds1[] = {
8: "a", "b", "c",
9: "d", "e", "f",
10: "g", "h", "i",
11: "j", "k", "l",
12:
13: NULL
14: };
15:
16: static const char *seeds2[] = {
17: "m", "n", "o",
18: "p", "q", "r",
19: "s", "t", "u",
20: "v", "w", "x",
21:
22: NULL
23: };
24:
25: #define NB_STRINGS_NS 100
26: #define NB_STRINGS_MAX 10000
27: #define NB_STRINGS_MIN 10
28:
29: static xmlChar *strings1[NB_STRINGS_MAX];
30: static xmlChar *strings2[NB_STRINGS_MAX];
31: static const xmlChar *test1[NB_STRINGS_MAX];
32: static const xmlChar *test2[NB_STRINGS_MAX];
33: static int nbErrors = 0;
34:
35: static void fill_strings(void) {
36: int i, j, k;
37:
38: /*
39: * That's a bit nasty but the output is fine and it doesn't take hours
40: * there is a small but sufficient number of duplicates, and we have
41: * ":xxx" and full QNames in the last NB_STRINGS_NS values
42: */
43: for (i = 0; seeds1[i] != NULL; i++) {
44: strings1[i] = xmlStrdup((const xmlChar *) seeds1[i]);
45: if (strings1[i] == NULL) {
46: fprintf(stderr, "Out of memory while generating strings1\n");
47: exit(1);
48: }
49: }
50: for (j = 0, k = 0;i < NB_STRINGS_MAX - NB_STRINGS_NS;i++,j++) {
51: strings1[i] = xmlStrncatNew(strings1[j], strings1[k], -1);
52: if (strings1[i] == NULL) {
53: fprintf(stderr, "Out of memory while generating strings1\n");
54: exit(1);
55: }
56: if (j >= 50) {
57: j = 0;
58: k++;
59: }
60: }
61: for (j = 0; (j < 50) && (i < NB_STRINGS_MAX); i++, j+=2) {
62: strings1[i] = xmlStrncatNew(strings1[j], (const xmlChar *) ":", -1);
63: if (strings1[i] == NULL) {
64: fprintf(stderr, "Out of memory while generating strings1\n");
65: exit(1);
66: }
67: }
68: for (j = NB_STRINGS_MAX - NB_STRINGS_NS, k = 0;
69: i < NB_STRINGS_MAX;i++,j++) {
70: strings1[i] = xmlStrncatNew(strings1[j], strings1[k], -1);
71: if (strings1[i] == NULL) {
72: fprintf(stderr, "Out of memory while generating strings1\n");
73: exit(1);
74: }
75: k += 3;
76: if (k >= 50) k = 0;
77: }
78:
79: /*
80: * Now do the same with the second pool of strings
81: */
82: for (i = 0; seeds2[i] != NULL; i++) {
83: strings2[i] = xmlStrdup((const xmlChar *) seeds2[i]);
84: if (strings2[i] == NULL) {
85: fprintf(stderr, "Out of memory while generating strings2\n");
86: exit(1);
87: }
88: }
89: for (j = 0, k = 0;i < NB_STRINGS_MAX - NB_STRINGS_NS;i++,j++) {
90: strings2[i] = xmlStrncatNew(strings2[j], strings2[k], -1);
91: if (strings2[i] == NULL) {
92: fprintf(stderr, "Out of memory while generating strings2\n");
93: exit(1);
94: }
95: if (j >= 50) {
96: j = 0;
97: k++;
98: }
99: }
100: for (j = 0; (j < 50) && (i < NB_STRINGS_MAX); i++, j+=2) {
101: strings2[i] = xmlStrncatNew(strings2[j], (const xmlChar *) ":", -1);
102: if (strings2[i] == NULL) {
103: fprintf(stderr, "Out of memory while generating strings2\n");
104: exit(1);
105: }
106: }
107: for (j = NB_STRINGS_MAX - NB_STRINGS_NS, k = 0;
108: i < NB_STRINGS_MAX;i++,j++) {
109: strings2[i] = xmlStrncatNew(strings2[j], strings2[k], -1);
110: if (strings2[i] == NULL) {
111: fprintf(stderr, "Out of memory while generating strings2\n");
112: exit(1);
113: }
114: k += 3;
115: if (k >= 50) k = 0;
116: }
117:
118: }
119:
120: #ifdef WITH_PRINT
121: static void print_strings(void) {
122: int i;
123:
124: for (i = 0; i < NB_STRINGS_MAX;i++) {
125: printf("%s\n", strings1[i]);
126: }
127: for (i = 0; i < NB_STRINGS_MAX;i++) {
128: printf("%s\n", strings2[i]);
129: }
130: }
131: #endif
132:
133: static void clean_strings(void) {
134: int i;
135:
136: for (i = 0; i < NB_STRINGS_MAX; i++) {
137: if (strings1[i] != NULL) /* really should not happen */
138: xmlFree(strings1[i]);
139: }
140: for (i = 0; i < NB_STRINGS_MAX; i++) {
141: if (strings2[i] != NULL) /* really should not happen */
142: xmlFree(strings2[i]);
143: }
144: }
145:
146: /*
147: * This tests the sub-dictionary support
148: */
149: static int run_test2(xmlDictPtr parent) {
150: int i, j;
151: xmlDictPtr dict;
152: int ret = 0;
153: xmlChar prefix[40];
154: xmlChar *cur, *pref;
155: const xmlChar *tmp;
156:
157: dict = xmlDictCreateSub(parent);
158: if (dict == NULL) {
159: fprintf(stderr, "Out of memory while creating sub-dictionary\n");
160: exit(1);
161: }
162: memset(test2, 0, sizeof(test2));
163:
164: /*
165: * Fill in NB_STRINGS_MIN, at this point the dictionary should not grow
166: * and we allocate all those doing the fast key computations
167: * All the strings are based on a different seeds subset so we know
168: * they are allocated in the main dictionary, not coming from the parent
169: */
170: for (i = 0;i < NB_STRINGS_MIN;i++) {
171: test2[i] = xmlDictLookup(dict, strings2[i], -1);
172: if (test2[i] == NULL) {
173: fprintf(stderr, "Failed lookup for '%s'\n", strings2[i]);
174: ret = 1;
175: nbErrors++;
176: }
177: }
178: j = NB_STRINGS_MAX - NB_STRINGS_NS;
179: /* ":foo" like strings2 */
180: for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
181: test2[j] = xmlDictLookup(dict, strings2[j], xmlStrlen(strings2[j]));
182: if (test2[j] == NULL) {
183: fprintf(stderr, "Failed lookup for '%s'\n", strings2[j]);
184: ret = 1;
185: nbErrors++;
186: }
187: }
188: /* "a:foo" like strings2 */
189: j = NB_STRINGS_MAX - NB_STRINGS_MIN;
190: for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
191: test2[j] = xmlDictLookup(dict, strings2[j], xmlStrlen(strings2[j]));
192: if (test2[j] == NULL) {
193: fprintf(stderr, "Failed lookup for '%s'\n", strings2[j]);
194: ret = 1;
195: nbErrors++;
196: }
197: }
198:
199: /*
200: * At this point allocate all the strings
201: * the dictionary will grow in the process, reallocate more string tables
202: * and switch to the better key generator
203: */
204: for (i = 0;i < NB_STRINGS_MAX;i++) {
205: if (test2[i] != NULL)
206: continue;
207: test2[i] = xmlDictLookup(dict, strings2[i], -1);
208: if (test2[i] == NULL) {
209: fprintf(stderr, "Failed lookup for '%s'\n", strings2[i]);
210: ret = 1;
211: nbErrors++;
212: }
213: }
214:
215: /*
216: * Now we can start to test things, first that all strings2 belongs to
217: * the dict, and that none of them was actually allocated in the parent
218: */
219: for (i = 0;i < NB_STRINGS_MAX;i++) {
220: if (!xmlDictOwns(dict, test2[i])) {
221: fprintf(stderr, "Failed ownership failure for '%s'\n",
222: strings2[i]);
223: ret = 1;
224: nbErrors++;
225: }
226: if (xmlDictOwns(parent, test2[i])) {
227: fprintf(stderr, "Failed parent ownership failure for '%s'\n",
228: strings2[i]);
229: ret = 1;
230: nbErrors++;
231: }
232: }
233:
234: /*
235: * Also verify that all strings from the parent are seen from the subdict
236: */
237: for (i = 0;i < NB_STRINGS_MAX;i++) {
238: if (!xmlDictOwns(dict, test1[i])) {
239: fprintf(stderr, "Failed sub-ownership failure for '%s'\n",
240: strings1[i]);
241: ret = 1;
242: nbErrors++;
243: }
244: }
245:
246: /*
247: * Then that another lookup to the string in sub will return the same
248: */
249: for (i = 0;i < NB_STRINGS_MAX;i++) {
250: if (xmlDictLookup(dict, strings2[i], -1) != test2[i]) {
251: fprintf(stderr, "Failed re-lookup check for %d, '%s'\n",
252: i, strings2[i]);
253: ret = 1;
254: nbErrors++;
255: }
256: }
257: /*
258: * But also that any lookup for a string in the parent will be provided
259: * as in the parent
260: */
261: for (i = 0;i < NB_STRINGS_MAX;i++) {
262: if (xmlDictLookup(dict, strings1[i], -1) != test1[i]) {
263: fprintf(stderr, "Failed parent string lookup check for %d, '%s'\n",
264: i, strings1[i]);
265: ret = 1;
266: nbErrors++;
267: }
268: }
269:
270: /*
271: * check the QName lookups
272: */
273: for (i = NB_STRINGS_MAX - NB_STRINGS_NS;i < NB_STRINGS_MAX;i++) {
274: cur = strings2[i];
275: pref = &prefix[0];
276: while (*cur != ':') *pref++ = *cur++;
277: cur++;
278: *pref = 0;
279: tmp = xmlDictQLookup(dict, &prefix[0], cur);
280: if (xmlDictQLookup(dict, &prefix[0], cur) != test2[i]) {
281: fprintf(stderr, "Failed lookup check for '%s':'%s'\n",
282: &prefix[0], cur);
283: ret = 1;
284: nbErrors++;
285: }
286: }
287: /*
288: * check the QName lookups for strings from the parent
289: */
290: for (i = NB_STRINGS_MAX - NB_STRINGS_NS;i < NB_STRINGS_MAX;i++) {
291: cur = strings1[i];
292: pref = &prefix[0];
293: while (*cur != ':') *pref++ = *cur++;
294: cur++;
295: *pref = 0;
296: tmp = xmlDictQLookup(dict, &prefix[0], cur);
297: if (xmlDictQLookup(dict, &prefix[0], cur) != test1[i]) {
298: fprintf(stderr, "Failed parent lookup check for '%s':'%s'\n",
299: &prefix[0], cur);
300: ret = 1;
301: nbErrors++;
302: }
303: }
304:
305: xmlDictFree(dict);
306: return(ret);
307: }
308:
309: /*
310: * Test a single dictionary
311: */
312: static int run_test1(void) {
313: int i, j;
314: xmlDictPtr dict;
315: int ret = 0;
316: xmlChar prefix[40];
317: xmlChar *cur, *pref;
318: const xmlChar *tmp;
319:
320: dict = xmlDictCreate();
321: if (dict == NULL) {
322: fprintf(stderr, "Out of memory while creating dictionary\n");
323: exit(1);
324: }
325: memset(test1, 0, sizeof(test1));
326:
327: /*
328: * Fill in NB_STRINGS_MIN, at this point the dictionary should not grow
329: * and we allocate all those doing the fast key computations
330: */
331: for (i = 0;i < NB_STRINGS_MIN;i++) {
332: test1[i] = xmlDictLookup(dict, strings1[i], -1);
333: if (test1[i] == NULL) {
334: fprintf(stderr, "Failed lookup for '%s'\n", strings1[i]);
335: ret = 1;
336: nbErrors++;
337: }
338: }
339: j = NB_STRINGS_MAX - NB_STRINGS_NS;
340: /* ":foo" like strings1 */
341: for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
342: test1[j] = xmlDictLookup(dict, strings1[j], xmlStrlen(strings1[j]));
343: if (test1[j] == NULL) {
344: fprintf(stderr, "Failed lookup for '%s'\n", strings1[j]);
345: ret = 1;
346: nbErrors++;
347: }
348: }
349: /* "a:foo" like strings1 */
350: j = NB_STRINGS_MAX - NB_STRINGS_MIN;
351: for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
352: test1[j] = xmlDictLookup(dict, strings1[j], xmlStrlen(strings1[j]));
353: if (test1[j] == NULL) {
354: fprintf(stderr, "Failed lookup for '%s'\n", strings1[j]);
355: ret = 1;
356: nbErrors++;
357: }
358: }
359:
360: /*
361: * At this point allocate all the strings
362: * the dictionary will grow in the process, reallocate more string tables
363: * and switch to the better key generator
364: */
365: for (i = 0;i < NB_STRINGS_MAX;i++) {
366: if (test1[i] != NULL)
367: continue;
368: test1[i] = xmlDictLookup(dict, strings1[i], -1);
369: if (test1[i] == NULL) {
370: fprintf(stderr, "Failed lookup for '%s'\n", strings1[i]);
371: ret = 1;
372: nbErrors++;
373: }
374: }
375:
376: /*
377: * Now we can start to test things, first that all strings1 belongs to
378: * the dict
379: */
380: for (i = 0;i < NB_STRINGS_MAX;i++) {
381: if (!xmlDictOwns(dict, test1[i])) {
382: fprintf(stderr, "Failed ownership failure for '%s'\n",
383: strings1[i]);
384: ret = 1;
385: nbErrors++;
386: }
387: }
388:
389: /*
390: * Then that another lookup to the string will return the same
391: */
392: for (i = 0;i < NB_STRINGS_MAX;i++) {
393: if (xmlDictLookup(dict, strings1[i], -1) != test1[i]) {
394: fprintf(stderr, "Failed re-lookup check for %d, '%s'\n",
395: i, strings1[i]);
396: ret = 1;
397: nbErrors++;
398: }
399: }
400:
401: /*
402: * More complex, check the QName lookups
403: */
404: for (i = NB_STRINGS_MAX - NB_STRINGS_NS;i < NB_STRINGS_MAX;i++) {
405: cur = strings1[i];
406: pref = &prefix[0];
407: while (*cur != ':') *pref++ = *cur++;
408: cur++;
409: *pref = 0;
410: tmp = xmlDictQLookup(dict, &prefix[0], cur);
411: if (xmlDictQLookup(dict, &prefix[0], cur) != test1[i]) {
412: fprintf(stderr, "Failed lookup check for '%s':'%s'\n",
413: &prefix[0], cur);
414: ret = 1;
415: nbErrors++;
416: }
417: }
418:
419: run_test2(dict);
420:
421: xmlDictFree(dict);
422: return(ret);
423: }
424:
425: int main(void)
426: {
427: int ret;
428:
429: LIBXML_TEST_VERSION
430: fill_strings();
431: #ifdef WITH_PRINT
432: print_strings();
433: #endif
434: ret = run_test1();
435: if (ret == 0) {
436: printf("dictionary tests succeeded %d strings\n", 2 * NB_STRINGS_MAX);
437: } else {
438: printf("dictionary tests failed with %d errors\n", nbErrors);
439: }
440: clean_strings();
441: xmlCleanupParser();
442: xmlMemoryDump();
443: return(ret);
444: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testdict.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2