| 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 (tmp != 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 (tmp != 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 | }
|
|---|
