mirror of
https://github.com/reactos/reactos.git
synced 2024-11-10 00:34:39 +00:00
444 lines
11 KiB
C
444 lines
11 KiB
C
#include <string.h>
|
|
#include <libxml/parser.h>
|
|
#include <libxml/dict.h>
|
|
|
|
/* #define WITH_PRINT */
|
|
|
|
static const char *seeds1[] = {
|
|
"a", "b", "c",
|
|
"d", "e", "f",
|
|
"g", "h", "i",
|
|
"j", "k", "l",
|
|
|
|
NULL
|
|
};
|
|
|
|
static const char *seeds2[] = {
|
|
"m", "n", "o",
|
|
"p", "q", "r",
|
|
"s", "t", "u",
|
|
"v", "w", "x",
|
|
|
|
NULL
|
|
};
|
|
|
|
#define NB_STRINGS_NS 100
|
|
#define NB_STRINGS_MAX 10000
|
|
#define NB_STRINGS_MIN 10
|
|
|
|
static xmlChar *strings1[NB_STRINGS_MAX];
|
|
static xmlChar *strings2[NB_STRINGS_MAX];
|
|
static const xmlChar *test1[NB_STRINGS_MAX];
|
|
static const xmlChar *test2[NB_STRINGS_MAX];
|
|
static int nbErrors = 0;
|
|
|
|
static void fill_strings(void) {
|
|
int i, j, k;
|
|
|
|
/*
|
|
* That's a bit nasty but the output is fine and it doesn't take hours
|
|
* there is a small but sufficient number of duplicates, and we have
|
|
* ":xxx" and full QNames in the last NB_STRINGS_NS values
|
|
*/
|
|
for (i = 0; seeds1[i] != NULL; i++) {
|
|
strings1[i] = xmlStrdup((const xmlChar *) seeds1[i]);
|
|
if (strings1[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings1\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
for (j = 0, k = 0;i < NB_STRINGS_MAX - NB_STRINGS_NS;i++,j++) {
|
|
strings1[i] = xmlStrncatNew(strings1[j], strings1[k], -1);
|
|
if (strings1[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings1\n");
|
|
exit(1);
|
|
}
|
|
if (j >= 50) {
|
|
j = 0;
|
|
k++;
|
|
}
|
|
}
|
|
for (j = 0; (j < 50) && (i < NB_STRINGS_MAX); i++, j+=2) {
|
|
strings1[i] = xmlStrncatNew(strings1[j], (const xmlChar *) ":", -1);
|
|
if (strings1[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings1\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
for (j = NB_STRINGS_MAX - NB_STRINGS_NS, k = 0;
|
|
i < NB_STRINGS_MAX;i++,j++) {
|
|
strings1[i] = xmlStrncatNew(strings1[j], strings1[k], -1);
|
|
if (strings1[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings1\n");
|
|
exit(1);
|
|
}
|
|
k += 3;
|
|
if (k >= 50) k = 0;
|
|
}
|
|
|
|
/*
|
|
* Now do the same with the second pool of strings
|
|
*/
|
|
for (i = 0; seeds2[i] != NULL; i++) {
|
|
strings2[i] = xmlStrdup((const xmlChar *) seeds2[i]);
|
|
if (strings2[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings2\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
for (j = 0, k = 0;i < NB_STRINGS_MAX - NB_STRINGS_NS;i++,j++) {
|
|
strings2[i] = xmlStrncatNew(strings2[j], strings2[k], -1);
|
|
if (strings2[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings2\n");
|
|
exit(1);
|
|
}
|
|
if (j >= 50) {
|
|
j = 0;
|
|
k++;
|
|
}
|
|
}
|
|
for (j = 0; (j < 50) && (i < NB_STRINGS_MAX); i++, j+=2) {
|
|
strings2[i] = xmlStrncatNew(strings2[j], (const xmlChar *) ":", -1);
|
|
if (strings2[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings2\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
for (j = NB_STRINGS_MAX - NB_STRINGS_NS, k = 0;
|
|
i < NB_STRINGS_MAX;i++,j++) {
|
|
strings2[i] = xmlStrncatNew(strings2[j], strings2[k], -1);
|
|
if (strings2[i] == NULL) {
|
|
fprintf(stderr, "Out of memory while generating strings2\n");
|
|
exit(1);
|
|
}
|
|
k += 3;
|
|
if (k >= 50) k = 0;
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef WITH_PRINT
|
|
static void print_strings(void) {
|
|
int i;
|
|
|
|
for (i = 0; i < NB_STRINGS_MAX;i++) {
|
|
printf("%s\n", strings1[i]);
|
|
}
|
|
for (i = 0; i < NB_STRINGS_MAX;i++) {
|
|
printf("%s\n", strings2[i]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void clean_strings(void) {
|
|
int i;
|
|
|
|
for (i = 0; i < NB_STRINGS_MAX; i++) {
|
|
if (strings1[i] != NULL) /* really should not happen */
|
|
xmlFree(strings1[i]);
|
|
}
|
|
for (i = 0; i < NB_STRINGS_MAX; i++) {
|
|
if (strings2[i] != NULL) /* really should not happen */
|
|
xmlFree(strings2[i]);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This tests the sub-dictionary support
|
|
*/
|
|
static int run_test2(xmlDictPtr parent) {
|
|
int i, j;
|
|
xmlDictPtr dict;
|
|
int ret = 0;
|
|
xmlChar prefix[40];
|
|
xmlChar *cur, *pref;
|
|
const xmlChar *tmp;
|
|
|
|
dict = xmlDictCreateSub(parent);
|
|
if (dict == NULL) {
|
|
fprintf(stderr, "Out of memory while creating sub-dictionary\n");
|
|
exit(1);
|
|
}
|
|
memset(test2, 0, sizeof(test2));
|
|
|
|
/*
|
|
* Fill in NB_STRINGS_MIN, at this point the dictionary should not grow
|
|
* and we allocate all those doing the fast key computations
|
|
* All the strings are based on a different seeds subset so we know
|
|
* they are allocated in the main dictionary, not coming from the parent
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MIN;i++) {
|
|
test2[i] = xmlDictLookup(dict, strings2[i], -1);
|
|
if (test2[i] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings2[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
j = NB_STRINGS_MAX - NB_STRINGS_NS;
|
|
/* ":foo" like strings2 */
|
|
for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
|
|
test2[j] = xmlDictLookup(dict, strings2[j], xmlStrlen(strings2[j]));
|
|
if (test2[j] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings2[j]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
/* "a:foo" like strings2 */
|
|
j = NB_STRINGS_MAX - NB_STRINGS_MIN;
|
|
for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
|
|
test2[j] = xmlDictLookup(dict, strings2[j], xmlStrlen(strings2[j]));
|
|
if (test2[j] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings2[j]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* At this point allocate all the strings
|
|
* the dictionary will grow in the process, reallocate more string tables
|
|
* and switch to the better key generator
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (test2[i] != NULL)
|
|
continue;
|
|
test2[i] = xmlDictLookup(dict, strings2[i], -1);
|
|
if (test2[i] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings2[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now we can start to test things, first that all strings2 belongs to
|
|
* the dict, and that none of them was actually allocated in the parent
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (!xmlDictOwns(dict, test2[i])) {
|
|
fprintf(stderr, "Failed ownership failure for '%s'\n",
|
|
strings2[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
if (xmlDictOwns(parent, test2[i])) {
|
|
fprintf(stderr, "Failed parent ownership failure for '%s'\n",
|
|
strings2[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Also verify that all strings from the parent are seen from the subdict
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (!xmlDictOwns(dict, test1[i])) {
|
|
fprintf(stderr, "Failed sub-ownership failure for '%s'\n",
|
|
strings1[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Then that another lookup to the string in sub will return the same
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (xmlDictLookup(dict, strings2[i], -1) != test2[i]) {
|
|
fprintf(stderr, "Failed re-lookup check for %d, '%s'\n",
|
|
i, strings2[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
/*
|
|
* But also that any lookup for a string in the parent will be provided
|
|
* as in the parent
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (xmlDictLookup(dict, strings1[i], -1) != test1[i]) {
|
|
fprintf(stderr, "Failed parent string lookup check for %d, '%s'\n",
|
|
i, strings1[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* check the QName lookups
|
|
*/
|
|
for (i = NB_STRINGS_MAX - NB_STRINGS_NS;i < NB_STRINGS_MAX;i++) {
|
|
cur = strings2[i];
|
|
pref = &prefix[0];
|
|
while (*cur != ':') *pref++ = *cur++;
|
|
cur++;
|
|
*pref = 0;
|
|
tmp = xmlDictQLookup(dict, &prefix[0], cur);
|
|
if (xmlDictQLookup(dict, &prefix[0], cur) != test2[i]) {
|
|
fprintf(stderr, "Failed lookup check for '%s':'%s'\n",
|
|
&prefix[0], cur);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
/*
|
|
* check the QName lookups for strings from the parent
|
|
*/
|
|
for (i = NB_STRINGS_MAX - NB_STRINGS_NS;i < NB_STRINGS_MAX;i++) {
|
|
cur = strings1[i];
|
|
pref = &prefix[0];
|
|
while (*cur != ':') *pref++ = *cur++;
|
|
cur++;
|
|
*pref = 0;
|
|
tmp = xmlDictQLookup(dict, &prefix[0], cur);
|
|
if (xmlDictQLookup(dict, &prefix[0], cur) != test1[i]) {
|
|
fprintf(stderr, "Failed parent lookup check for '%s':'%s'\n",
|
|
&prefix[0], cur);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
xmlDictFree(dict);
|
|
return(ret);
|
|
}
|
|
|
|
/*
|
|
* Test a single dictionary
|
|
*/
|
|
static int run_test1(void) {
|
|
int i, j;
|
|
xmlDictPtr dict;
|
|
int ret = 0;
|
|
xmlChar prefix[40];
|
|
xmlChar *cur, *pref;
|
|
const xmlChar *tmp;
|
|
|
|
dict = xmlDictCreate();
|
|
if (dict == NULL) {
|
|
fprintf(stderr, "Out of memory while creating dictionary\n");
|
|
exit(1);
|
|
}
|
|
memset(test1, 0, sizeof(test1));
|
|
|
|
/*
|
|
* Fill in NB_STRINGS_MIN, at this point the dictionary should not grow
|
|
* and we allocate all those doing the fast key computations
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MIN;i++) {
|
|
test1[i] = xmlDictLookup(dict, strings1[i], -1);
|
|
if (test1[i] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings1[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
j = NB_STRINGS_MAX - NB_STRINGS_NS;
|
|
/* ":foo" like strings1 */
|
|
for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
|
|
test1[j] = xmlDictLookup(dict, strings1[j], xmlStrlen(strings1[j]));
|
|
if (test1[j] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings1[j]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
/* "a:foo" like strings1 */
|
|
j = NB_STRINGS_MAX - NB_STRINGS_MIN;
|
|
for (i = 0;i < NB_STRINGS_MIN;i++, j++) {
|
|
test1[j] = xmlDictLookup(dict, strings1[j], xmlStrlen(strings1[j]));
|
|
if (test1[j] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings1[j]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* At this point allocate all the strings
|
|
* the dictionary will grow in the process, reallocate more string tables
|
|
* and switch to the better key generator
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (test1[i] != NULL)
|
|
continue;
|
|
test1[i] = xmlDictLookup(dict, strings1[i], -1);
|
|
if (test1[i] == NULL) {
|
|
fprintf(stderr, "Failed lookup for '%s'\n", strings1[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Now we can start to test things, first that all strings1 belongs to
|
|
* the dict
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (!xmlDictOwns(dict, test1[i])) {
|
|
fprintf(stderr, "Failed ownership failure for '%s'\n",
|
|
strings1[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Then that another lookup to the string will return the same
|
|
*/
|
|
for (i = 0;i < NB_STRINGS_MAX;i++) {
|
|
if (xmlDictLookup(dict, strings1[i], -1) != test1[i]) {
|
|
fprintf(stderr, "Failed re-lookup check for %d, '%s'\n",
|
|
i, strings1[i]);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* More complex, check the QName lookups
|
|
*/
|
|
for (i = NB_STRINGS_MAX - NB_STRINGS_NS;i < NB_STRINGS_MAX;i++) {
|
|
cur = strings1[i];
|
|
pref = &prefix[0];
|
|
while (*cur != ':') *pref++ = *cur++;
|
|
cur++;
|
|
*pref = 0;
|
|
tmp = xmlDictQLookup(dict, &prefix[0], cur);
|
|
if (xmlDictQLookup(dict, &prefix[0], cur) != test1[i]) {
|
|
fprintf(stderr, "Failed lookup check for '%s':'%s'\n",
|
|
&prefix[0], cur);
|
|
ret = 1;
|
|
nbErrors++;
|
|
}
|
|
}
|
|
|
|
run_test2(dict);
|
|
|
|
xmlDictFree(dict);
|
|
return(ret);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
int ret;
|
|
|
|
LIBXML_TEST_VERSION
|
|
fill_strings();
|
|
#ifdef WITH_PRINT
|
|
print_strings();
|
|
#endif
|
|
ret = run_test1();
|
|
if (ret == 0) {
|
|
printf("dictionary tests succeeded %d strings\n", 2 * NB_STRINGS_MAX);
|
|
} else {
|
|
printf("dictionary tests failed with %d errors\n", nbErrors);
|
|
}
|
|
clean_strings();
|
|
xmlCleanupParser();
|
|
xmlMemoryDump();
|
|
return(ret);
|
|
}
|