Home | History | Annotate | Download | only in libxml2 
      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 }
    445