kc3-lang/libxml2/testrecurse.c

• Show log

  Commit

• Hash : 208f27f9
  Author :
  Date : 2024-06-15T19:13:08
  

  include: Don't define ATTRIBUTE_UNUSED in public header
  
  Stop polluting namespace with unprefixed names.
  

Download

• testrecurse.c

• /*
   * testrecurse.c: C program to run libxml2 regression tests checking entities
   *            recursions
   *
   * To compile on Unixes:
   * cc -o testrecurse `xml2-config --cflags` testrecurse.c `xml2-config --libs` -lpthread
   *
   * See Copyright for the status of this software.
   *
   * daniel@veillard.com
   */
  
  #define XML_DEPRECATED_MEMBER
  
  #include "libxml.h"
  #include <stdio.h>
  
  #include <stdlib.h>
  #include <string.h>
  #include <sys/stat.h>
  
  #include <libxml/catalog.h>
  #include <libxml/parser.h>
  #include <libxml/parserInternals.h>
  #include <libxml/tree.h>
  #include <libxml/uri.h>
  
  /*
   * O_BINARY is just for Windows compatibility - if it isn't defined
   * on this system, avoid any compilation error
   */
  #ifdef	O_BINARY
  #define RD_FLAGS	O_RDONLY | O_BINARY
  #else
  #define	RD_FLAGS	O_RDONLY
  #endif
  
  #define OPT_SAX         (1<<0)
  #define OPT_NO_SUBST    (1<<1)
  
  typedef int (*functest) (const char *filename, const char *result,
                           const char *error, int options);
  
  typedef struct testDesc testDesc;
  typedef testDesc *testDescPtr;
  struct testDesc {
      const char *desc; /* description of the test */
      functest    func; /* function implementing the test */
      const char *in;   /* glob to path for input files */
      const char *out;  /* output directory */
      const char *suffix;/* suffix for output files */
      const char *err;  /* suffix for error output files */
      int     options;  /* parser options for the test */
  };
  
  static int checkTestFile(const char *filename);
  
  
  #if defined(_WIN32)
  
  #include <windows.h>
  
  typedef struct
  {
        size_t gl_pathc;    /* Count of paths matched so far  */
        char **gl_pathv;    /* List of matched pathnames.  */
        size_t gl_offs;     /* Slots to reserve in 'gl_pathv'.  */
  } glob_t;
  
  #define GLOB_DOOFFS 0
  static int glob(const char *pattern, ATTRIBUTE_UNUSED int flags,
                  ATTRIBUTE_UNUSED int errfunc(const char *epath, int eerrno),
                  glob_t *pglob) {
      glob_t *ret;
      WIN32_FIND_DATA FindFileData;
      HANDLE hFind;
      unsigned int nb_paths = 0;
      char directory[500];
      int len;
  
      if ((pattern == NULL) || (pglob == NULL)) return(-1);
  
      strncpy(directory, pattern, 499);
      for (len = strlen(directory);len >= 0;len--) {
          if (directory[len] == '/') {
  	    len++;
  	    directory[len] = 0;
  	    break;
  	}
      }
      if (len <= 0)
          len = 0;
  
  
      ret = pglob;
      memset(ret, 0, sizeof(glob_t));
  
      hFind = FindFirstFileA(pattern, &FindFileData);
      if (hFind == INVALID_HANDLE_VALUE)
          return(0);
      nb_paths = 20;
      ret->gl_pathv = (char **) malloc(nb_paths * sizeof(char *));
      if (ret->gl_pathv == NULL) {
  	FindClose(hFind);
          return(-1);
      }
      strncpy(directory + len, FindFileData.cFileName, 499 - len);
      ret->gl_pathv[ret->gl_pathc] = strdup(directory);
      if (ret->gl_pathv[ret->gl_pathc] == NULL)
          goto done;
      ret->gl_pathc++;
      while(FindNextFileA(hFind, &FindFileData)) {
          if (FindFileData.cFileName[0] == '.')
  	    continue;
          if (ret->gl_pathc + 2 > nb_paths) {
              char **tmp = realloc(ret->gl_pathv, nb_paths * 2 * sizeof(char *));
              if (tmp == NULL)
                  break;
              ret->gl_pathv = tmp;
              nb_paths *= 2;
  	}
  	strncpy(directory + len, FindFileData.cFileName, 499 - len);
  	ret->gl_pathv[ret->gl_pathc] = strdup(directory);
          if (ret->gl_pathv[ret->gl_pathc] == NULL)
              break;
          ret->gl_pathc++;
      }
      ret->gl_pathv[ret->gl_pathc] = NULL;
  
  done:
      FindClose(hFind);
      return(0);
  }
  
  
  
  static void globfree(glob_t *pglob) {
      unsigned int i;
      if (pglob == NULL)
          return;
  
      for (i = 0;i < pglob->gl_pathc;i++) {
           if (pglob->gl_pathv[i] != NULL)
               free(pglob->gl_pathv[i]);
      }
  }
  
  #else
  #include <glob.h>
  #endif
  
  /************************************************************************
   *									*
   *		Huge document generator					*
   *									*
   ************************************************************************/
  
  #include <libxml/xmlIO.h>
  
  typedef struct {
      const char *URL;
      const char *start;
      const char *segment;
      const char *finish;
  } xmlHugeDocParts;
  
  static const xmlHugeDocParts hugeDocTable[] = {
      {
          "test/recurse/huge.xml",
  
          "<!DOCTYPE foo ["
          "<!ELEMENT foo (bar*)> "
          "<!ELEMENT bar (#PCDATA)> "
          "<!ATTLIST bar attr CDATA #IMPLIED> "
          "<!ENTITY a SYSTEM 'ga.ent'> "
          "<!ENTITY b SYSTEM 'gb.ent'> "
          "<!ENTITY c SYSTEM 'gc.ent'> "
          "<!ENTITY f 'some internal data'> "
          "<!ENTITY e '&f;&f;'> "
          "<!ENTITY d '&e;&e;'> "
          "]> "
          "<foo>",
  
          "  <bar attr='&e; &f; &d;'>&a; &b; &c; &e; &f; &d;</bar>\n"
          "  <bar>_123456789_123456789_123456789_123456789</bar>\n"
          "  <bar>_123456789_123456789_123456789_123456789</bar>\n"
          "  <bar>_123456789_123456789_123456789_123456789</bar>\n"
          "  <bar>_123456789_123456789_123456789_123456789</bar>\n",
  
          "</foo>"
      },
      {
          "test/recurse/huge_dtd.dtd",
  
          "<!ELEMENT foo (#PCDATA)>\n"
          "<!ENTITY ent 'success'>\n"
          "<!ENTITY % a SYSTEM 'pa.ent'>\n"
          "<!ENTITY % b SYSTEM 'pb.ent'>\n"
          "<!ENTITY % c SYSTEM 'pc.ent'>\n"
          "<!ENTITY % d '<!-- comment -->'>\n"
          "<!ENTITY % e '%d;%d;'>\n"
          "<!ENTITY % f '%e;%e;'>\n",
  
          "<!ENTITY ent '%a; %b; %c; %d; %e; %f;'>\n"
          "%a; %b; %c; %d; %e; %f;\n"
          "<!-- _123456789_123456789_123456789_123456789 -->\n"
          "<!-- _123456789_123456789_123456789_123456789 -->\n"
          "<!-- _123456789_123456789_123456789_123456789 -->\n",
  
          ""
      },
      { NULL, NULL, NULL, NULL }
  };
  
  static const xmlHugeDocParts *hugeDocParts;
  static int curseg = 0;
  static const char *current;
  static int rlen;
  
  /**
   * hugeMatch:
   * @URI: an URI to test
   *
   * Check for a huge query
   *
   * Returns 1 if yes and 0 if another Input module should be used
   */
  static int
  hugeMatch(const char * URI) {
      int i;
  
      if (URI == NULL)
          return(0);
  
      for (i = 0; hugeDocTable[i].URL; i++) {
          if (strcmp(URI, hugeDocTable[i].URL) == 0)
              return(1);
      }
  
      return(0);
  }
  
  /**
   * hugeOpen:
   * @URI: an URI to test
   *
   * Return a pointer to the huge query handler, in this example simply
   * the current pointer...
   *
   * Returns an Input context or NULL in case or error
   */
  static void *
  hugeOpen(const char * URI) {
      int i;
  
      if (URI == NULL)
          return(NULL);
  
      for (i = 0; hugeDocTable[i].URL; i++) {
          if (strcmp(URI, hugeDocTable[i].URL) == 0) {
              hugeDocParts = hugeDocTable + i;
              curseg = 0;
              current = hugeDocParts->start;
              rlen = strlen(current);
              return((void *) current);
          }
      }
  
      return(NULL);
  }
  
  /**
   * hugeClose:
   * @context: the read context
   *
   * Close the huge query handler
   *
   * Returns 0 or -1 in case of error
   */
  static int
  hugeClose(void * context) {
      if (context == NULL) return(-1);
      return(0);
  }
  
  #define MAX_NODES 1000
  
  /**
   * hugeRead:
   * @context: the read context
   * @buffer: where to store data
   * @len: number of bytes to read
   *
   * Implement an huge query read.
   *
   * Returns the number of bytes read or -1 in case of error
   */
  static int
  hugeRead(void *context, char *buffer, int len)
  {
      if ((context == NULL) || (buffer == NULL) || (len < 0))
          return (-1);
  
      if (len >= rlen) {
          if (curseg >= MAX_NODES + 1) {
              rlen = 0;
              return(0);
          }
          len = rlen;
          rlen = 0;
  	memcpy(buffer, current, len);
          curseg ++;
          if (curseg == MAX_NODES) {
              current = hugeDocParts->finish;
  	} else {
              current = hugeDocParts->segment;
  	}
          rlen = strlen(current);
      } else {
  	memcpy(buffer, current, len);
  	rlen -= len;
          current += len;
      }
      return (len);
  }
  
  /************************************************************************
   *									*
   *		Libxml2 specific routines				*
   *									*
   ************************************************************************/
  
  static int nb_tests = 0;
  static int nb_errors = 0;
  static int nb_leaks = 0;
  
  static int
  fatalError(void) {
      fprintf(stderr, "Exitting tests on fatal error\n");
      exit(1);
  }
  
  static void
  initializeLibxml2(void) {
      xmlMemSetup(xmlMemFree, xmlMemMalloc, xmlMemRealloc, xmlMemoryStrdup);
      xmlInitParser();
  #ifdef LIBXML_CATALOG_ENABLED
      xmlInitializeCatalog();
      xmlCatalogSetDefaults(XML_CATA_ALLOW_NONE);
  #endif
      /*
       * register the new I/O handlers
       */
      if (xmlRegisterInputCallbacks(hugeMatch, hugeOpen,
                                    hugeRead, hugeClose) < 0) {
          fprintf(stderr, "failed to register Huge handler\n");
  	exit(1);
      }
  }
  
  static void
  initSAX(xmlParserCtxtPtr ctxt) {
      ctxt->sax->startElementNs = NULL;
      ctxt->sax->endElementNs = NULL;
      ctxt->sax->startElement = NULL;
      ctxt->sax->endElement = NULL;
      ctxt->sax->characters = NULL;
      ctxt->sax->cdataBlock = NULL;
      ctxt->sax->ignorableWhitespace = NULL;
      ctxt->sax->processingInstruction = NULL;
      ctxt->sax->comment = NULL;
  }
  
  /************************************************************************
   *									*
   *		File name and path utilities				*
   *									*
   ************************************************************************/
  
  static const char *baseFilename(const char *filename) {
      const char *cur;
      if (filename == NULL)
          return(NULL);
      cur = &filename[strlen(filename)];
      while ((cur > filename) && (*cur != '/'))
          cur--;
      if (*cur == '/')
          return(cur + 1);
      return(cur);
  }
  
  static char *resultFilename(const char *filename, const char *out,
                              const char *suffix) {
      const char *base;
      char res[500];
      char suffixbuff[500];
  
  /*************
      if ((filename[0] == 't') && (filename[1] == 'e') &&
          (filename[2] == 's') && (filename[3] == 't') &&
  	(filename[4] == '/'))
  	filename = &filename[5];
   *************/
  
      base = baseFilename(filename);
      if (suffix == NULL)
          suffix = ".tmp";
      if (out == NULL)
          out = "";
  
      strncpy(suffixbuff,suffix,499);
  
      if (snprintf(res, 499, "%s%s%s", out, base, suffixbuff) >= 499)
          res[499] = 0;
      return(strdup(res));
  }
  
  static int checkTestFile(const char *filename) {
      struct stat buf;
  
      if (stat(filename, &buf) == -1)
          return(0);
  
  #if defined(_WIN32)
      if (!(buf.st_mode & _S_IFREG))
          return(0);
  #else
      if (!S_ISREG(buf.st_mode))
          return(0);
  #endif
  
      return(1);
  }
  
  
  
  /************************************************************************
   *									*
   *		Test to detect or not recursive entities		*
   *									*
   ************************************************************************/
  /**
   * recursiveDetectTest:
   * @filename: the file to parse
   * @result: the file with expected result
   * @err: the file with error messages: unused
   *
   * Parse a file loading DTD and replacing entities check it fails for
   * lol cases
   *
   * Returns 0 in case of success, an error code otherwise
   */
  static int
  recursiveDetectTest(const char *filename,
               const char *result ATTRIBUTE_UNUSED,
               const char *err ATTRIBUTE_UNUSED,
  	     int options) {
      xmlDocPtr doc;
      xmlParserCtxtPtr ctxt;
      int res = 0;
      /*
       * XML_PARSE_DTDVALID is the only way to load external entities
       * without XML_PARSE_NOENT. The validation result doesn't matter
       * anyway.
       */
      int parserOptions = XML_PARSE_DTDVALID | XML_PARSE_NOERROR;
  
      nb_tests++;
  
      ctxt = xmlNewParserCtxt();
      if (options & OPT_SAX)
          initSAX(ctxt);
      if ((options & OPT_NO_SUBST) == 0)
          parserOptions |= XML_PARSE_NOENT;
      /*
       * base of the test, parse with the old API
       */
      doc = xmlCtxtReadFile(ctxt, filename, NULL, parserOptions);
      if ((doc != NULL) || (ctxt->lastError.code != XML_ERR_RESOURCE_LIMIT)) {
          fprintf(stderr, "Failed to detect recursion in %s\n", filename);
  	xmlFreeParserCtxt(ctxt);
  	xmlFreeDoc(doc);
          return(1);
      }
      xmlFreeParserCtxt(ctxt);
  
      return(res);
  }
  
  /**
   * notRecursiveDetectTest:
   * @filename: the file to parse
   * @result: the file with expected result
   * @err: the file with error messages: unused
   *
   * Parse a file loading DTD and replacing entities check it works for
   * good cases
   *
   * Returns 0 in case of success, an error code otherwise
   */
  static int
  notRecursiveDetectTest(const char *filename,
               const char *result ATTRIBUTE_UNUSED,
               const char *err ATTRIBUTE_UNUSED,
  	     int options) {
      xmlDocPtr doc;
      xmlParserCtxtPtr ctxt;
      int res = 0;
      int parserOptions = XML_PARSE_DTDLOAD;
  
      nb_tests++;
  
      ctxt = xmlNewParserCtxt();
      if (options & OPT_SAX)
          initSAX(ctxt);
      if ((options & OPT_NO_SUBST) == 0)
          parserOptions |= XML_PARSE_NOENT;
      /*
       * base of the test, parse with the old API
       */
      doc = xmlCtxtReadFile(ctxt, filename, NULL, parserOptions);
      if (doc == NULL) {
          fprintf(stderr, "Failed to parse correct file %s\n", filename);
  	xmlFreeParserCtxt(ctxt);
          return(1);
      }
      xmlFreeDoc(doc);
      xmlFreeParserCtxt(ctxt);
  
      return(res);
  }
  
  /**
   * notRecursiveHugeTest:
   * @filename: the file to parse
   * @result: the file with expected result
   * @err: the file with error messages: unused
   *
   * Parse a memory generated file
   * good cases
   *
   * Returns 0 in case of success, an error code otherwise
   */
  static int
  notRecursiveHugeTest(const char *filename ATTRIBUTE_UNUSED,
               const char *result ATTRIBUTE_UNUSED,
               const char *err ATTRIBUTE_UNUSED,
  	     int options) {
      xmlParserCtxtPtr ctxt;
      xmlDocPtr doc;
      int res = 0;
      int parserOptions = XML_PARSE_DTDVALID;
  
      nb_tests++;
  
      ctxt = xmlNewParserCtxt();
      if (options & OPT_SAX)
          initSAX(ctxt);
      if ((options & OPT_NO_SUBST) == 0)
          parserOptions |= XML_PARSE_NOENT;
      doc = xmlCtxtReadFile(ctxt, "test/recurse/huge.xml", NULL, parserOptions);
      if (doc == NULL) {
          fprintf(stderr, "Failed to parse huge.xml\n");
  	res = 1;
      } else {
          xmlEntityPtr ent;
          unsigned long fixed_cost = 20;
          unsigned long allowed_expansion = 1000000;
          unsigned long f_size = xmlStrlen(BAD_CAST "some internal data");
          unsigned long e_size;
          unsigned long d_size;
          unsigned long total_size;
  
          ent = xmlGetDocEntity(doc, BAD_CAST "e");
          e_size = f_size * 2 +
                   xmlStrlen(BAD_CAST "&f;") * 2 +
                   fixed_cost * 2;
          if (ent->expandedSize != e_size) {
              fprintf(stderr, "Wrong size for entity e: %lu (expected %lu)\n",
                      ent->expandedSize, e_size);
              res = 1;
          }
  
          ent = xmlGetDocEntity(doc, BAD_CAST "b");
          if (ent->expandedSize != e_size) {
              fprintf(stderr, "Wrong size for entity b: %lu (expected %lu)\n",
                      ent->expandedSize, e_size);
              res = 1;
          }
  
          ent = xmlGetDocEntity(doc, BAD_CAST "d");
          d_size = e_size * 2 +
                   xmlStrlen(BAD_CAST "&e;") * 2 +
                   fixed_cost * 2;
          if (ent->expandedSize != d_size) {
              fprintf(stderr, "Wrong size for entity d: %lu (expected %lu)\n",
                      ent->expandedSize, d_size);
              res = 1;
          }
  
          ent = xmlGetDocEntity(doc, BAD_CAST "c");
          if (ent->expandedSize != d_size) {
              fprintf(stderr, "Wrong size for entity c: %lu (expected %lu)\n",
                      ent->expandedSize, d_size);
              res = 1;
          }
  
          if (ctxt->sizeentcopy < allowed_expansion) {
              fprintf(stderr, "Total entity size too small: %lu\n",
                      ctxt->sizeentcopy);
              res = 1;
          }
  
          total_size = (f_size + e_size + d_size + 3 * fixed_cost) *
                       (MAX_NODES - 1) * 3;
          if (ctxt->sizeentcopy != total_size) {
              fprintf(stderr, "Wrong total entity size: %lu (expected %lu)\n",
                      ctxt->sizeentcopy, total_size);
              res = 1;
          }
  
          if (ctxt->sizeentities != 30) {
              fprintf(stderr, "Wrong parsed entity size: %lu (expected %lu)\n",
                      ctxt->sizeentities, 30lu);
              res = 1;
          }
      }
  
      xmlFreeDoc(doc);
      xmlFreeParserCtxt(ctxt);
  
      return(res);
  }
  
  /**
   * notRecursiveHugeTest:
   * @filename: the file to parse
   * @result: the file with expected result
   * @err: the file with error messages: unused
   *
   * Parse a memory generated file
   * good cases
   *
   * Returns 0 in case of success, an error code otherwise
   */
  static int
  hugeDtdTest(const char *filename ATTRIBUTE_UNUSED,
              const char *result ATTRIBUTE_UNUSED,
              const char *err ATTRIBUTE_UNUSED,
              int options) {
      xmlParserCtxtPtr ctxt;
      xmlDocPtr doc;
      int res = 0;
      int parserOptions = XML_PARSE_DTDVALID;
  
      nb_tests++;
  
      ctxt = xmlNewParserCtxt();
      if (options & OPT_SAX)
          initSAX(ctxt);
      if ((options & OPT_NO_SUBST) == 0)
          parserOptions |= XML_PARSE_NOENT;
      doc = xmlCtxtReadFile(ctxt, "test/recurse/huge_dtd.xml", NULL,
                            parserOptions);
      if (doc == NULL) {
          fprintf(stderr, "Failed to parse huge_dtd.xml\n");
  	res = 1;
      } else {
          unsigned long fixed_cost = 20;
          unsigned long allowed_expansion = 1000000;
          unsigned long a_size = xmlStrlen(BAD_CAST "<!-- comment -->");
          unsigned long b_size;
          unsigned long c_size;
          unsigned long e_size;
          unsigned long f_size;
          unsigned long total_size;
  
          if (ctxt->sizeentcopy < allowed_expansion) {
              fprintf(stderr, "Total entity size too small: %lu\n",
                      ctxt->sizeentcopy);
              res = 1;
          }
  
          b_size = (a_size + strlen("&a;") + fixed_cost) * 2;
          c_size = (b_size + strlen("&b;") + fixed_cost) * 2;
          /*
           * Internal parameter entites are substitued eagerly and
           * need different accounting.
           */
          e_size = a_size * 2;
          f_size = e_size * 2;
          total_size = /* internal */
                       e_size + f_size + fixed_cost * 4 +
                       (a_size + e_size + f_size + fixed_cost * 3) *
                       (MAX_NODES - 1) * 2 +
                       /* external */
                       (a_size + b_size + c_size + fixed_cost * 3) *
                       (MAX_NODES - 1) * 2 +
                       /* final reference in main doc */
                       strlen("success") + fixed_cost;
          if (ctxt->sizeentcopy != total_size) {
              fprintf(stderr, "Wrong total entity size: %lu (expected %lu)\n",
                      ctxt->sizeentcopy, total_size);
              res = 1;
          }
  
          total_size = strlen(hugeDocParts->start) +
                       strlen(hugeDocParts->segment) * (MAX_NODES - 1) +
                       strlen(hugeDocParts->finish) +
                       /*
                        * Other external entities pa.ent, pb.ent, pc.ent.
                        * These are currently counted twice because they're
                        * used both in DTD and EntityValue.
                        */
                       (16 + 6 + 6) * 2;
          if (ctxt->sizeentities != total_size) {
              fprintf(stderr, "Wrong parsed entity size: %lu (expected %lu)\n",
                      ctxt->sizeentities, total_size);
              res = 1;
          }
      }
  
      xmlFreeDoc(doc);
      xmlFreeParserCtxt(ctxt);
  
      return(res);
  }
  
  /************************************************************************
   *									*
   *			Tests Descriptions				*
   *									*
   ************************************************************************/
  
  static
  testDesc testDescriptions[] = {
      { "Parsing recursive test cases" ,
        recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
        0 },
      { "Parsing recursive test cases (no substitution)" ,
        recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
        OPT_NO_SUBST },
      { "Parsing recursive test cases (SAX)" ,
        recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
        OPT_SAX },
      { "Parsing recursive test cases (SAX, no substitution)" ,
        recursiveDetectTest, "./test/recurse/lol*.xml", NULL, NULL, NULL,
        OPT_SAX | OPT_NO_SUBST },
      { "Parsing non-recursive test cases" ,
        notRecursiveDetectTest, "./test/recurse/good*.xml", NULL, NULL, NULL,
        0 },
      { "Parsing non-recursive test cases (SAX)" ,
        notRecursiveDetectTest, "./test/recurse/good*.xml", NULL, NULL, NULL,
        OPT_SAX },
      { "Parsing non-recursive huge case" ,
        notRecursiveHugeTest, NULL, NULL, NULL, NULL,
        0 },
      { "Parsing non-recursive huge case (no substitution)" ,
        notRecursiveHugeTest, NULL, NULL, NULL, NULL,
        OPT_NO_SUBST },
      { "Parsing non-recursive huge case (SAX)" ,
        notRecursiveHugeTest, NULL, NULL, NULL, NULL,
        OPT_SAX },
      { "Parsing non-recursive huge case (SAX, no substitution)" ,
        notRecursiveHugeTest, NULL, NULL, NULL, NULL,
        OPT_SAX | OPT_NO_SUBST },
      { "Parsing non-recursive huge DTD case" ,
        hugeDtdTest, NULL, NULL, NULL, NULL,
        0 },
      {NULL, NULL, NULL, NULL, NULL, NULL, 0}
  };
  
  /************************************************************************
   *									*
   *		The main code driving the tests				*
   *									*
   ************************************************************************/
  
  static int
  launchTests(testDescPtr tst) {
      int res = 0, err = 0;
      size_t i;
      char *result;
      char *error;
      int mem;
  
      if (tst == NULL) return(-1);
      if (tst->in != NULL) {
  	glob_t globbuf;
  
  	globbuf.gl_offs = 0;
  	glob(tst->in, GLOB_DOOFFS, NULL, &globbuf);
  	for (i = 0;i < globbuf.gl_pathc;i++) {
  	    if (!checkTestFile(globbuf.gl_pathv[i]))
  	        continue;
  	    if (tst->suffix != NULL) {
  		result = resultFilename(globbuf.gl_pathv[i], tst->out,
  					tst->suffix);
  		if (result == NULL) {
  		    fprintf(stderr, "Out of memory !\n");
  		    fatalError();
  		}
  	    } else {
  	        result = NULL;
  	    }
  	    if (tst->err != NULL) {
  		error = resultFilename(globbuf.gl_pathv[i], tst->out,
  		                        tst->err);
  		if (error == NULL) {
  		    fprintf(stderr, "Out of memory !\n");
  		    fatalError();
  		}
  	    } else {
  	        error = NULL;
  	    }
  	    if ((result) &&(!checkTestFile(result))) {
  	        fprintf(stderr, "Missing result file %s\n", result);
  	    } else if ((error) &&(!checkTestFile(error))) {
  	        fprintf(stderr, "Missing error file %s\n", error);
  	    } else {
  		mem = xmlMemUsed();
  		res = tst->func(globbuf.gl_pathv[i], result, error,
  		                tst->options | XML_PARSE_COMPACT);
  		xmlResetLastError();
  		if (res != 0) {
  		    fprintf(stderr, "File %s generated an error\n",
  		            globbuf.gl_pathv[i]);
  		    nb_errors++;
  		    err++;
  		}
  		else if (xmlMemUsed() != mem) {
                      fprintf(stderr, "File %s leaked %d bytes\n",
                              globbuf.gl_pathv[i], xmlMemUsed() - mem);
                      nb_leaks++;
                      err++;
  		}
  	    }
  	    if (result)
  		free(result);
  	    if (error)
  		free(error);
  	}
  	globfree(&globbuf);
      } else {
          res = tst->func(NULL, NULL, NULL, tst->options);
  	if (res != 0) {
  	    nb_errors++;
  	    err++;
  	}
      }
      return(err);
  }
  
  static int verbose = 0;
  static int tests_quiet = 0;
  
  static int
  runtest(int i) {
      int ret = 0, res;
      int old_errors, old_tests, old_leaks;
  
      old_errors = nb_errors;
      old_tests = nb_tests;
      old_leaks = nb_leaks;
      if ((tests_quiet == 0) && (testDescriptions[i].desc != NULL))
  	printf("## %s\n", testDescriptions[i].desc);
      res = launchTests(&testDescriptions[i]);
      if (res != 0)
  	ret++;
      if (verbose) {
  	if ((nb_errors == old_errors) && (nb_leaks == old_leaks))
  	    printf("Ran %d tests, no errors\n", nb_tests - old_tests);
  	else
  	    printf("Ran %d tests, %d errors, %d leaks\n",
  		   nb_tests - old_tests,
  		   nb_errors - old_errors,
  		   nb_leaks - old_leaks);
      }
      return(ret);
  }
  
  int
  main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
      int i, a, ret = 0;
      int subset = 0;
  
      initializeLibxml2();
  
      for (a = 1; a < argc;a++) {
          if (!strcmp(argv[a], "-v"))
  	    verbose = 1;
          else if (!strcmp(argv[a], "-quiet"))
  	    tests_quiet = 1;
  	else {
  	    for (i = 0; testDescriptions[i].func != NULL; i++) {
  	        if (strstr(testDescriptions[i].desc, argv[a])) {
  		    ret += runtest(i);
  		    subset++;
  		}
  	    }
  	}
      }
      if (subset == 0) {
  	for (i = 0; testDescriptions[i].func != NULL; i++) {
  	    ret += runtest(i);
  	}
      }
      if ((nb_errors == 0) && (nb_leaks == 0)) {
          ret = 0;
  	printf("Total %d tests, no errors\n",
  	       nb_tests);
      } else {
          ret = 1;
  	printf("Total %d tests, %d errors, %d leaks\n",
  	       nb_tests, nb_errors, nb_leaks);
      }
      xmlCleanupParser();
  
      return(ret);
  }
  

Download