lib/3rdparty/libxml2/testdict.c

   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 }