text: #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 (tmp != 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 (tmp != 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);
  }
  